Spiral\ORM\Entities\Relations\HasManyRelation

Complexity

Total Complexity

21

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
B	setRelated()	0	28	5
A	getDeleted()	0	4	1
A	add()	0	7	1
A	delete()	0	18	3
B	queueCommands()	0	26	5
A	queueRelated()	0	19	2
A	loadRelated()	0	9	2
A	createSelector()	0	17	2

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\ORM\Entities\Relations;

use Spiral\ORM\CommandInterface;
use Spiral\ORM\Commands\NullCommand;
use Spiral\ORM\Commands\TransactionalCommand;
use Spiral\ORM\ContextualCommandInterface;
use Spiral\ORM\Entities\RecordSelector;
use Spiral\ORM\Entities\Relations\Traits\LookupTrait;
use Spiral\ORM\Exceptions\RelationException;
use Spiral\ORM\Helpers\WhereDecorator;
use Spiral\ORM\Record;
use Spiral\ORM\RecordInterface;

/**
 * Attention, this relation delete operation works inside loaded scope!
 *
 * When empty array assigned to relation it will schedule all related instances to be deleted.
 *
 * If you wish to load with relation WITHOUT loading previous records use [] initialization.
 */
class HasManyRelation extends MultipleRelation implements \IteratorAggregate, \Countable
{
    use LookupTrait;

    /**
     * Records deleted from list. Potentially pre-schedule command?
     *
     * @var RecordInterface[]
     */
    private $deletedInstances = [];

    /**
     * {@inheritdoc}
     *
     * @throws RelationException
     */
    public function setRelated($value)
    {
        $this->loadData(true);

        if (is_null($value)) {
            $value = [];
        }

        if (!is_array($value)) {
            throw new RelationException("HasMany relation can only be set with array of entities");
        }

        //todo: optimize this section!? combine values with existed? use flat array

        //Cleaning existed instances
        $this->deletedInstances = array_unique(array_merge(
            $this->deletedInstances,
            $this->instances
        ));

        $this->instances = [];
        foreach ($value as $item) {
            if (!is_null($item)) {
                $this->assertValid($item);
                $this->instances[] = $item;
            }
        }
    }

    /**
     * Iterate over deleted instances.
     *
     * @return \ArrayIterator
     */
    public function getDeleted()
    {
        return new \ArrayIterator($this->deletedInstances);
    }

    /**
     * Add new record into entity set. Attention, usage of this method WILL load relation data
     * unless partial.
     *
     * @param RecordInterface $record
     *
     * @return self
     *
     * @throws RelationException
     */
    public function add(RecordInterface $record): self
    {
        $this->assertValid($record);
        $this->loadData(true)->instances[] = $record;

        return $this;
    }

    /**
     * Delete one record, strict compaction, make sure exactly same instance is given.
     *
     * @param RecordInterface $record
     *
     * @return self
     *
     * @throws RelationException
     */
    public function delete(RecordInterface $record): self
    {
        $this->loadData(true);
        $this->assertValid($record);

        foreach ($this->instances as $index => $instance) {
            if ($this->match($instance, $record)) {
                //Remove from save
                unset($this->instances[$index]);
                $this->deletedInstances[] = $instance;
                break;
            }
        }

        $this->instances = array_values($this->instances);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function queueCommands(ContextualCommandInterface $parentCommand): CommandInterface
    {
        //No autoloading here

        if (empty($this->instances) && empty($this->deletedInstances)) {
            return new NullCommand();
        }

        $transaction = new TransactionalCommand();

        //Delete old instances first
        foreach ($this->deletedInstances as $deleted) {
            //To de-associate use BELONGS_TO relation
            $transaction->addCommand($deleted->queueDelete());
        }

        //Store all instances
        foreach ($this->instances as $instance) {
            $transaction->addCommand($this->queueRelated($parentCommand, $instance));
        }

        //Flushing instances
        $this->deletedInstances = [];

        return $transaction;
    }

    /**
     * @param ContextualCommandInterface $parentCommand
     * @param RecordInterface            $instance
     *
     * @return CommandInterface
     */
    protected function queueRelated(
        ContextualCommandInterface $parentCommand,
        RecordInterface $instance
    ): CommandInterface {
        //Related entity store command
        $innerCommand = $instance->queueStore(true);

        if (!$this->isSynced($this->parent, $instance)) {
            //Delayed linking
            $parentCommand->onExecute(function ($outerCommand) use ($innerCommand) {
                $innerCommand->addContext(
                    $this->key(Record::OUTER_KEY),
                    $this->lookupKey(Record::INNER_KEY, $this->parent, $outerCommand)
                );
            });
        }

        return $innerCommand;
    }

    /**
     * Fetch data from database. Lazy load.
     *
     * @return array
     */
    protected function loadRelated(): array
    {
        $innerKey = $this->parent->getField($this->key(Record::INNER_KEY));
        if (!empty($innerKey)) {
            return $this->createSelector($innerKey)->fetchData();
        }

        return [];
    }

    /**
     * Create outer selector for a given inner key value.
     *
     * @param mixed $innerKey
     *
     * @return RecordSelector
     */
    protected function createSelector($innerKey): RecordSelector
    {
        $selector = $this->orm->selector($this->class)->where(
            $this->key(Record::OUTER_KEY),
            $innerKey

The call to RecordSelector::where() has too many arguments starting with $innerKey.

        );

        if (!empty($this->schema[Record::WHERE])) {
            //Configuring where conditions with alias resolution
            $decorator = new WhereDecorator($selector, 'where', $selector->getAlias());
            $decorator->where($this->schema[Record::WHERE]);

            return $selector;
        }

        return $selector;
    }
}