Bdf\Prime\Relations\ByInheritance

Complexity

Total Complexity

20

Size/Duplication

Total Lines	217
Duplicated Lines	0 %

Test Coverage

Coverage

68.57%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	subRelation()	0	11	1
A	create()	0	5	1
A	__construct()	0	14	2
A	associate()	0	5	1
A	join()	0	15	2
A	relationRepository()	0	3	1
A	link()	0	5	1
A	saveAll()	0	7	1
A	load()	0	19	3
A	deleteAll()	0	7	1
A	dissociate()	0	5	1
A	add()	0	6	1
A	applyWhereKeys()	0	3	1
A	joinRepositories()	0	6	1
A	relations()	0	2	1
A	match()	0	2	1

<?php

namespace Bdf\Prime\Relations;

use Bdf\Prime\Collection\Indexer\EntityIndexer;
use Bdf\Prime\Collection\Indexer\EntityIndexerInterface;
use Bdf\Prime\Mapper\SingleTableInheritanceMapper;
use Bdf\Prime\Query\Contract\EntityJoinable;
use Bdf\Prime\Query\QueryInterface;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\Contract\WriteOperation;
use Bdf\Prime\Query\ReadCommandInterface;
use Bdf\Prime\Relations\Util\ForeignKeyRelation;
use Bdf\Prime\Repository\RepositoryInterface;
use LogicException;

/**
 * ByInheritance
 *
 * @todo options ?
 *
 * @template L as object
 *
 * @extends AbstractRelation<L, object>
 */
class ByInheritance extends AbstractRelation
{
    /** @use Polymorph<L> */
    use Polymorph;
    /** @use ForeignKeyRelation<L, object> */
    use ForeignKeyRelation;

    /**
     * Set inheritance relation
     *
     * @param string $attributeAim
     * @param RepositoryInterface<L> $local
     * @param string $localKey
     */
    public function __construct(string $attributeAim, RepositoryInterface $local, string $localKey)
    {
        parent::__construct($attributeAim, $local);

        $this->localKey = $localKey;

        $mapper = $local->mapper();

        if (!$mapper instanceof SingleTableInheritanceMapper) {
            throw new LogicException('The mapper could not manage single table inheritance relation');
        }

        $this->setDiscriminator($mapper->getDiscriminatorColumn());
        $this->setMap($mapper->getEntityMap());
    }

    /**
     * {@inheritdoc}
     */
    public function relationRepository(): RepositoryInterface
    {
        return $this->subRelation()->relationRepository();
    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]
    public function load(EntityIndexerInterface $collection, array $with = [], $constraints = [], array $without = []): void
    {
        if ($collection->empty()) {
            return;
        }

        $with = $this->rearrangeWith($with);
        $without = $this->rearrangeWithout($without);

        foreach ($collection->by($this->discriminator) as $type => $chunk) {
            $this->discriminatorValue = $type;
            $subRelation = $this->subRelation();

            $subRelation->load(
                EntityIndexer::fromArray($subRelation->localRepository()->mapper(), $chunk),
                $with[$type],
                $constraints,
                $without[$type]
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function link($owner): ReadCommandInterface
    {
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->link($owner);
    }

    /**
     * {@inheritdoc}
     */
    public function join(EntityJoinable $query, string $alias): void
    {
        $parts = explode('#', $alias);

        if (!isset($parts[1])) {
            throw new LogicException('Joins are not supported on polymorph without discriminator');
        }

        $this->discriminatorValue = end($parts);

        //Use real alias
        $this->subRelation()->setLocalAlias($this->localAlias)->join($query, $parts[0]);

        //TODO should be in join clause
        $query->where($this->getLocalAlias($query).$this->discriminator, $this->discriminatorValue);
    }

    /**
     * {@inheritdoc}
     */
    public function joinRepositories(EntityJoinable $query, string $alias, $discriminator = null): array
    {
        $this->discriminatorValue = $discriminator;

        return [
            $alias => $this->relationRepository()
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function associate($owner, $entity)
    {
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->associate($owner, $entity);
    }

    /**
     * {@inheritdoc}
     */
    public function dissociate($owner)
    {
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->dissociate($owner);
    }

    /**
     * {@inheritdoc}
     */
    public function create($owner, array $data = [])
    {
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->create($owner, $data);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]
    public function add($owner, $related): int
    {
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->add($owner, $related);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]
    public function saveAll($owner, array $relations = []): int
    {
        $relations = $this->rearrangeWith($relations);
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->saveAll($owner, $relations[$this->discriminatorValue]);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]
    public function deleteAll($owner, array $relations = []): int
    {
        $relations = $this->rearrangeWith($relations);
        $this->updateDiscriminatorValue($owner);

        return $this->subRelation()->deleteAll($owner, $relations[$this->discriminatorValue]);
    }

    /**
     * Get the delagated sub relation
     *
     * @return RelationInterface<L, object>
     */
    protected function subRelation(): RelationInterface
    {
        /** @var array{entity:class-string<L>} $infos */
        $infos = $this->map($this->discriminatorValue);

        $relation = $this->local->repository($infos['entity'])
            ->relation($this->attributeAim);

        // TODO doit on redescendre les options sur la relation ?

        return $relation;
    }

    /**
     * Unused method by inheritance
     *
     * {@inheritdoc}
     *
     * @return void
     */
    protected function relations($keys, $with, $constraints, $without): void

The parameter $without is not used and could be removed.

The parameter $constraints is not used and could be removed.

The parameter $with is not used and could be removed.

The parameter $keys is not used and could be removed.

    {
    }

    /**
     * Unused method by inheritance
     *
     * {@inheritdoc}
     *
     * @return void
     */
    protected function match($collection, $relations): void

The parameter $collection is not used and could be removed.

The parameter $relations is not used and could be removed.

    {
    }

    /**
     * {@inheritdoc}
     */
    protected function applyWhereKeys(ReadCommandInterface $query, $value): ReadCommandInterface
    {
        return $query;
    }
}