Spiral\ORM\Entities\Relations\BelongsToMorphedRelation

Complexity

Total Complexity

9

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getClass()	0	9	2
A	setRelated()	0	8	1
A	queueCommands()	0	15	3
A	getRoles()	0	4	1
B	queueRelated()	0	24	2

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */

namespace Spiral\ORM\Entities\Relations;

use Spiral\ORM\CommandInterface;
use Spiral\ORM\Commands\NullCommand;
use Spiral\ORM\ContextualCommandInterface;
use Spiral\ORM\Entities\Relations\Traits\LookupTrait;
use Spiral\ORM\Exceptions\RelationException;
use Spiral\ORM\ORMInterface;
use Spiral\ORM\Record;

/**
 * Similar to BelongsTo, however morph key value used to resolve parent record. Record allows
 * mutable parent type.
 */
class BelongsToMorphedRelation extends SingularRelation
{
    use LookupTrait;

    /**
     * Always saved before parent.
     */
    const LEADING_RELATION = true;

    /**
     * No placeholder for belongs to.
     */
    const CREATE_PLACEHOLDER = false;

    /**
     * {@inheritdoc}
     */
    public function getClass(): string
    {
        if (empty($parentType = $this->parent->getField($this->key(Record::MORPH_KEY)))) {
            return parent::getClass();
        }

        //Resolve parent using role map
        return $this->schema[ORMInterface::R_ROLE_NAME][$parentType];
    }

    /**
     * {@inheritdoc}
     */
    public function setRelated($value)
    {
        //Make sure value is accepted
        $this->assertValid($value);

        $this->loaded = true;
        $this->instance = $value;
    }

    /**
     * @param ContextualCommandInterface $parentCommand
     *
     * @return CommandInterface
     *
     * @throws RelationException
     */
    public function queueCommands(ContextualCommandInterface $parentCommand): CommandInterface
    {
        if (!empty($this->instance)) {
            return $this->queueRelated($parentCommand);
        }

        if (!$this->schema[Record::NULLABLE]) {
            throw new RelationException("No data presented in non nullable relation");
        }

        $parentCommand->addContext($this->schema[Record::INNER_KEY], null);
        $parentCommand->addContext($this->schema[Record::MORPH_KEY], null);

        return new NullCommand();
    }

    /**
     * {@inheritdoc}
     */
    protected function getRoles(): array
    {
        return $this->schema[ORMInterface::R_ROLE_NAME];
    }

    /**
     * Store related instance
     *
     * @param ContextualCommandInterface $parentCommand
     *
     * @return ContextualCommandInterface
     */
    private function queueRelated(
        ContextualCommandInterface $parentCommand
    ): ContextualCommandInterface {
        //Command or command set needed to store
        $innerCommand = $this->instance->queueStore(true);

        if (!$this->isSynced($this->parent, $this->instance)) {
            //Syncing FKs before primary command been executed
            $innerCommand->onExecute(function ($innerCommand) use ($parentCommand) {
                $parentCommand->addContext(
                    $this->key(Record::INNER_KEY),
                    $this->lookupKey(Record::OUTER_KEY, $this->parent, $innerCommand)
                );

                //Morph key value
                $parentCommand->addContext(
                    $this->key(Record::MORPH_KEY),
                    $this->orm->define(get_class($this->instance), ORMInterface::R_ROLE_NAME)
                );
            });
        }

        return $innerCommand;
    }
}