Majora\Framework\Loader\Bridge\Doctrine\DoctrineLoaderTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes	6
Bugs	1	Features	2

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createFilteredQuery()	0	15	3
A	retrieveAll()	0	19	3
A	retrieveOne()	0	9	1
A	retrieve()	0	4	1
A	assertIsConfigured()	0	10	4
A	__construct()	0	7	2
A	onLoad()	0	6	1
C	toEntityCollection()	0	31	7
A	createQuery()	0	6	1

<?php

namespace Majora\Framework\Loader\Bridge\Doctrine;

use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityRepository;
use Majora\Framework\Loader\LoaderTrait;

/**
 * Trait to use into Doctrine loaders to get a simple implementation of LoaderInterface.
 *
 * @method getEntityRepository : EntityRepository
 * @method setEntityRepository(EntityRepository)
 *
 * @property $entityClass
 * @property $collectionClass
 * @property $filterResolver
 */
trait DoctrineLoaderTrait
{
    use LoaderTrait;

    /**
     * Construct.
     *
     * @param EntityRepository $entityRepository (optionnal)
     */
    public function __construct(EntityRepository $entityRepository = null)
    {
        if ($entityRepository) {
            @trigger_error('Repository constructor injection is deprecated for ORM implementation due to circular references with Doctrine events and will be removed in 2.0. Use setEntityRepository() instead.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

            $this->setEntityRepository($entityRepository);
        }
    }

    /**
     * Checks if loader is properly configured.
     *
     * @throws \RuntimeException if not configured
     */
    private function assertIsConfigured()
    {
        if (!$this->entityClass || !$this->collectionClass || !$this->filterResolver) {
            throw new \RuntimeException(sprintf(
                '%s methods cannot be used while it has not been initialize through %s::configureMetadata().',
                static::class,
                static::class
            ));
        }
    }

    /**
     * Hook called with every entity or collection loaded through this loader.
     *
     * @param CollectionnableInterface|EntityCollection $entity
     *
     * @return $object same entity or collection

The doc-type $object could not be parsed: Unknown type name "$object" at position 0. (view supported doc-types)

     */
    protected function onLoad($entity)
    {
        @trigger_error(__METHOD__.' is deprecated and will be removed in 2.0. Use full class delegate instead, see Majora\Framework\Loader\LazyLoaderInterface.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        return $entity;
    }

    /**
     * Convert given array or Collection result set to managed entity collection class.
     *
     * @param array|Collection $result
     *
     * @return EntityCollection
     */
    protected function toEntityCollection($result)
    {
        switch (true) {

            // already a collection ?
            case is_object($result) && is_subclass_of($result, $this->collectionClass) :

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $this->collectionClass can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

There must be no space before the colon in a CASE statement

                $collection = $result;
                break;

            // already a collection ?
            case $result instanceof Collection :

There must be no space before the colon in a CASE statement

                $collection = new $this->collectionClass($result->toArray());
                break;

            // simple related entity ?
            case is_object($result) && is_subclass_of($result, $this->entityClass) :

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $this->entityClass can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

There must be no space before the colon in a CASE statement

                $collection = new $this->collectionClass(array($result));
                break;

            // simple array ?
            case is_array($result) :

There must be no space before the colon in a CASE statement

                $collection = new $this->collectionClass($result);
                break;

            default:
                $collection = new $this->collectionClass();
                break;
        }

        return $this->onLoad($collection);
    }

    /**
     * Create entity query.
     * Proxy to base query builder method to use to custom all queries from this loader.
     *
     * @param string $alias
     *
     * @return QueryBuilder
     */
    protected function createQuery($alias = 'entity')
    {
        return $this->getEntityRepository()

It seems like getEntityRepository() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->createQueryBuilder($alias)
        ;
    }

    /**
     * create query an filter it with given data.
     *
     * @param array $filters
     *
     * @return Query
     */
    private function createFilteredQuery(array $filters)
    {
        $qb = $this->createQuery('entity');

        foreach ($filters as $field => $filter) {
            $qb->andWhere(is_array($filter)
                    ? sprintf('entity.%s in (:%s)', $field, $field)
                    : sprintf('entity.%s = :%s', $field, $field)
                )
                ->setParameter(sprintf(':%s', $field), $filter)
            ;
        }

        return $qb->getQuery();
    }

    /**
     * @see LoaderInterface::retrieveAll()
     */
    public function retrieveAll(array $filters = array(), $limit = null, $offset = null)
    {
        $this->assertIsConfigured();

        $query = $this->createFilteredQuery(
            $this->filterResolver->resolve($filters)
        );

        if ($limit) {
            $query->setMaxResults($limit);
        }
        if ($offset) {
            $query->setFirstResult($offset);
        }

        return $this->toEntityCollection(
            $query->getResult()
        );
    }

    /**
     * @see LoaderInterface::retrieveOne()
     */
    public function retrieveOne(array $filters = array())
    {
        $this->assertIsConfigured();

        return $this->onLoad($this->createFilteredQuery($filters)
            ->setMaxResults(1)
            ->getOneOrNullResult()
        );
    }

    /**
     * @see LoaderInterface::retrieve()
     */
    public function retrieve($id)
    {
        return $this->onLoad($this->retrieveOne(array('id' => $id)));
    }
}