Bdf\Prime\Relations\BelongsToMany

Complexity

Total Complexity

51

Size/Duplication

Total Lines	479
Duplicated Lines	0 %

Test Coverage

Coverage

89.4%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	relationRepository()	0	3	1
A	deleteAll()	0	4	1
A	extractConstraints()	0	20	4
A	detach()	0	29	5
A	dissociate()	0	6	1
A	setConstraints()	0	7	1
A	applyThroughConstraints()	0	3	1
A	has()	0	12	2
A	associate()	0	6	1
A	match()	0	17	6
A	attach()	0	29	5
A	add()	0	4	1
A	setThrough()	0	5	1
A	relationQuery()	0	19	6
A	join()	0	14	1
A	create()	0	9	1
A	saveAll()	0	10	2
A	joinRepositories()	0	5	1
B	throughQuery()	0	26	7
A	relations()	0	29	2
A	link()	0	9	1

<?php

namespace Bdf\Prime\Relations;

use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Query\Contract\Deletable;
use Bdf\Prime\Query\Contract\EntityJoinable;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\Contract\WriteOperation;
use Bdf\Prime\Query\Custom\KeyValue\KeyValueQuery;
use Bdf\Prime\Query\QueryInterface;
use Bdf\Prime\Query\ReadCommandInterface;
use Bdf\Prime\Repository\EntityRepository;
use Bdf\Prime\Repository\RepositoryInterface;

/**
 * BelongsToMany
 *
 * For a relation named 'relation' use the prefix 'relationThrough.' for adding constraints on through table.
 * ex:
 *
 * <code>
 * $query->with([
 *     'relation' => [
 *         'name :like'             => '...',
 *         'relationThrough.status' => '...'  // through constraint
 *     ]
 * ]);
 * </code>
 *
 * @package Bdf\Prime\Relations
 *
 * @todo Voir pour gérer la table de through dynamiquement. Si cette relation est une HasManyThrough, elle doit etre en readonly
 *
 * @template L as object
 * @template R as object
 *
 * @extends Relation<L, R>
 */
class BelongsToMany extends Relation
{
    /**
     * Through repository
     *
     * @var EntityRepository
     */
    protected $through;

    /**
     * Through local key
     *
     * @var string
     */
    protected $throughLocal;

    /**
     * Through distant key
     *
     * @var string
     */
    protected $throughDistant;

    /**
     * The through global constraints
     *
     * @var array
     */
    protected $throughConstraints = [];

    /**
     * Merge of all constraints
     *
     * @var array
     */
    protected $allConstraints = [];

    /**
     * {@inheritdoc}
     */
    protected $saveStrategy = self::SAVE_STRATEGY_REPLACE;

    //===============================
    // Save queries for optimisation
    //===============================

    /**
     * @var KeyValueQuery
     */
    private $throughQuery;

    /**
     * @var KeyValueQuery
     */
    private $relationQuery;


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

    /**
     * Set the though infos
     *
     * @param RepositoryInterface $through
     * @param string $throughLocal
     * @param string $throughDistant
     *
     * @return void
     */
    public function setThrough(RepositoryInterface $through, string $throughLocal, string $throughDistant): void
    {
        $this->through        = $through;

$through is of type Bdf\Prime\Repository\RepositoryInterface, but the property $through was declared to be of type Bdf\Prime\Repository\EntityRepository. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->throughLocal   = $throughLocal;
        $this->throughDistant = $throughDistant;
    }

    /**
     * {@inheritdoc}
     */
    public function setConstraints($constraints)
    {
        $this->allConstraints = $constraints;

        list($this->constraints, $this->throughConstraints) = $this->extractConstraints($constraints);

        return $this;
    }

    /**
     * Extract constraints design for through queries
     *
     * @param array|\Closure $constraints
     *
     * @return array
     */
    protected function extractConstraints($constraints)
    {
        if (!is_array($constraints)) {
            return [$constraints, []];
        }

        $through = [];
        $global = [];
        $prefix = $this->attributeAim.'Through.';
        $length = strlen($prefix);

        foreach ($constraints as $column => $value) {
            if (strpos($column, $prefix) === 0) {
                $through[substr($column, $length)] = $value;
            } else {
                $global[$column] = $value;
            }
        }

        return [$global, $through];
    }

    /**
     * {@inheritdoc}
     */
    public function join(EntityJoinable $query, string $alias): void
    {
        // @fixme ??
//        if ($alias === null) {
//            $alias = $this->attributeAim;
//        }

        // TODO rechercher l'alias de through dans les tables alias du query builder

        $query->joinEntity($this->through->entityName(), $this->throughLocal, $this->getLocalAlias($query).$this->localKey, $this->attributeAim.'Through');
        $query->joinEntity($this->distant->entityName(), $this->distantKey, $this->attributeAim.'Through>'.$this->throughDistant, $alias);

        $this->applyConstraints($query, [], $alias);
        $this->applyThroughConstraints($query, [], $this->attributeAim.'Through');
    }

    /**
     * {@inheritdoc}
     */
    public function joinRepositories(EntityJoinable $query, string $alias, $discriminator = null): array
    {
        return [
            $this->attributeAim.'Through' => $this->through,
            $alias => $this->distant,
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function link($owner): ReadCommandInterface
    {
        /** @var QueryInterface<\Bdf\Prime\Connection\ConnectionInterface, R>&EntityJoinable $query */
        $query = $this->distant->queries()->builder();

        return $query
            ->joinEntity($this->through->entityName(), $this->throughDistant, $this->distantKey, $this->attributeAim.'Through')

The method joinEntity() does not exist on Bdf\Prime\Query\QueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\QueryInterface.

            ->where($this->attributeAim.'Through.'.$this->throughLocal, $this->getLocalKeyValue($owner))
            ->where($this->allConstraints)
        ;
    }

    /**
     * Get a query from through entity repository
     *
     * @param string|array  $key
     * @param array $constraints
     *
     * @return ReadCommandInterface&Deletable
     */
    protected function throughQuery($key, $constraints = []): ReadCommandInterface
    {
        if (is_array($key)) {
            if (count($key) !== 1 || $constraints || $this->throughConstraints) {

The expression $constraints of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

The expression $this->throughConstraints of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                return $this->applyThroughConstraints(
                    $this->through->where($this->throughLocal, $key),
                    $constraints
                );
            }

            $key = $key[0];
        }

        if ($this->throughQuery) {
            return $this->throughQuery->where($this->throughLocal, $key);
        }

        $this->throughQuery = $this->through->queries()->keyValue($this->throughLocal, $key);

        if ($this->throughQuery) {
            return $this->throughQuery;
        }

        return $this->applyThroughConstraints(
            $this->through->where($this->throughLocal, $key),
            $constraints
        );
    }

    /**
     * Build the query for find related entities
     */
    protected function relationQuery(array $keys, $constraints): ReadCommandInterface
    {
        // Constraints can be on relation attributes : builder must be used
        // @todo Handle "bulk select"
        if (count($keys) !== 1 || $constraints || $this->constraints) {

The expression $this->constraints of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this->query($keys, $constraints)->by($this->distantKey);

The method by() does not exist on Bdf\Prime\Query\QueryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Query\SqlQueryInterface. Are you sure you never get one of those?

        }

        if ($this->relationQuery) {
            return $this->relationQuery->where($this->distantKey, reset($keys));
        }

        $query = $this->distant->queries()->keyValue($this->distantKey, reset($keys));

        if (!$query) {

$query is of type Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface, thus it always evaluated to true.

            return $this->query($keys, $constraints)->by($this->distantKey);
        }

        return $this->relationQuery = $query->by($this->distantKey);

The method by() does not exist on Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface.

    }

    /**
     * Apply the through constraints
     *
     * @param Q $query

The type Bdf\Prime\Relations\Q was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param array $constraints
     * @param string|null $context
     *
     * @return Q
     *
     * @template Q as ReadCommandInterface<\Bdf\Prime\Connection\ConnectionInterface, object>&\Bdf\Prime\Query\Contract\Whereable
     */
    protected function applyThroughConstraints(ReadCommandInterface $query, $constraints = [], ?string $context = null): ReadCommandInterface
    {
        return $query->where($this->applyContext($context, $constraints + $this->throughConstraints));

The method where() does not exist on Bdf\Prime\Query\ReadCommandInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\ReadCommandInterface.

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]
    protected function relations($keys, $with, $constraints, $without): array
    {
        list($constraints, $throughConstraints) = $this->extractConstraints($constraints);

        $throughEntities = [];
        $throughDistants = [];

        $collection = $this->throughQuery($keys, $throughConstraints)->execute([
            $this->throughLocal   => $this->throughLocal,
            $this->throughDistant => $this->throughDistant,
        ]);

        foreach ($collection as $entity) {
            $throughLocal   = $entity[$this->throughLocal];
            $throughDistant = $entity[$this->throughDistant];

            $throughDistants[$throughDistant] = $throughDistant;
            $throughEntities[$throughLocal][$throughDistant] = $throughDistant;
        }

        $relations = $this->relationQuery($throughDistants, $constraints)
            ->with($with)

The method with() does not exist on Bdf\Prime\Query\Custom\KeyValue\KeyValueQuery. Since you implemented __call, consider adding a @method annotation.

            ->without($without)
            ->all();

        return [
            'throughEntities' => $throughEntities,
            'entities'        => $relations,
        ];
    }

    /**
     * {@inheritdoc}
     */
    protected function match($collection, $relations): void
    {
        foreach ($relations['throughEntities'] as $key => $throughDistants) {
            $entities = [];

            foreach ($throughDistants as $throughDistant) {
                if (isset($relations['entities'][$throughDistant])) {
                    $entities[] = $relations['entities'][$throughDistant];
                }
            }

            if (empty($entities)) {
                continue;
            }

            foreach ($collection[$key] as $local) {
                $this->setRelation($local, $entities);
            }
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[WriteOperation]
    public function associate($owner, $entity)
    {
        $this->attach($owner, $entity);

        return $owner;
    }

    /**
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[WriteOperation]
    public function dissociate($owner)
    {
        $this->detach($owner, $this->getRelation($owner));

        return $owner;
    }

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

        $this->distant->save($entity);

        $this->add($owner, $entity);

        return $entity;
    }

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

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]
    public function saveAll($owner, array $relations = []): int
    {
        //Detach all relations
        if ($this->saveStrategy === self::SAVE_STRATEGY_REPLACE) {
            $this->throughQuery($this->getLocalKeyValue($owner))->delete();
        }

        // Attach new relations
        return $this->attach($owner, $this->getRelation($owner));
    }

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

    /**
     * Check whether the owner has a distant entity relation
     *
     * @param L $owner

The type Bdf\Prime\Relations\L was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param string|R $entity
     *
     * @return boolean
     * @throws PrimeException
     */
    #[ReadOperation]
    public function has($owner, $entity): bool
    {
        $data = [$this->throughLocal => $this->getLocalKeyValue($owner)];

        if (!is_object($entity)) {
            $data[$this->throughDistant] = $entity;
        } else {
            $data[$this->throughDistant] = $this->getDistantKeyValue($entity);
        }

        return $this->through->exists($this->through->entity($data));
    }

    /**
     * Attach a distant entity to an entity
     *
     * @param L $owner
     * @param string|R[]|R $entities
     *
     * @return int
     * @throws PrimeException
     */
    #[WriteOperation]
    public function attach($owner, $entities): int
    {
        if (empty($entities)) {
            return 0;
        }

        $ownerId = $this->getLocalKeyValue($owner);

        if (!is_array($entities)) {
            $entities = [$entities];
        }

        $nb = 0;

        foreach ($entities as $entity) {
            // distant could be a object or the distant id
            $data = [$this->throughLocal => $ownerId];

            if (!is_object($entity)) {
                $data[$this->throughDistant] = $entity;
            } else {
                $data[$this->throughDistant] = $this->getDistantKeyValue($entity);
            }

            $nb += $this->through->save($this->through->entity($data));
        }

        return $nb;
    }

    /**
     * Detach a distant entity of an entity
     *
     * @param L $owner
     * @param string|R[]|R $entities
     *
     * @return int
     * @throws PrimeException
     */
    #[WriteOperation]
    public function detach($owner, $entities): int
    {
        if (empty($entities)) {
            return 0;
        }

        $ownerId = $this->getLocalKeyValue($owner);

        if (!is_array($entities)) {
            $entities = [$entities];
        }

        $nb = 0;

        foreach ($entities as $entity) {
            // distant could be a object or the distant id
            $data = [$this->throughLocal => $ownerId];

            if (!is_object($entity)) {
                $data[$this->throughDistant] = $entity;
            } else {
                $data[$this->throughDistant] = $this->getDistantKeyValue($entity);
            }

            $nb += $this->through->delete($this->through->entity($data));
        }

        return $nb;
    }
}