Jgut\Doctrine\Repository\ORM\RelationalRepository

Complexity

Total Complexity

13

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getClassName()	0	4	1
A	getManager()	0	4	1
A	getClassAlias()	0	8	2
A	findPaginatedBy()	0	6	1
B	getQueryBuilderFromCriteria()	0	28	6
A	paginate()	0	4	1
A	countBy()	0	4	1

<?php

/*
 * doctrine-orm-repositories (https://github.com/juliangut/doctrine-orm-repositories).
 * Doctrine2 ORM utility entity repositories.
 *
 * @license MIT
 * @link https://github.com/juliangut/doctrine-orm-repositories
 * @author Julián Gutiérrez <juliangut@gmail.com>
 */

declare(strict_types=1);

namespace Jgut\Doctrine\Repository\ORM;

use Doctrine\Common\Util\ClassUtils;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\Tools\Pagination\Paginator as RelationalPaginator;
use Jgut\Doctrine\Repository\EventsTrait;
use Jgut\Doctrine\Repository\PaginatorTrait;
use Jgut\Doctrine\Repository\Repository;
use Jgut\Doctrine\Repository\RepositoryTrait;
use Rb\Specification\Doctrine\SpecificationAwareInterface;
use Rb\Specification\Doctrine\SpecificationRepositoryTrait;
use Zend\Paginator\Paginator;

/**
 * Relational entity repository.
 */
class RelationalRepository extends EntityRepository implements Repository, SpecificationAwareInterface
{
    use SpecificationRepositoryTrait;
    use RepositoryTrait;
    use EventsTrait;
    use PaginatorTrait;

    /**
     * Class alias.
     *
     * @var string
     */
    protected $classAlias;

    /**
     * Get class alias.
     *
     * @return string
     */
    protected function getClassAlias(): string
    {
        if ($this->classAlias === null) {
            $this->classAlias = strtoupper($this->getEntityName()[0]);
        }

        return $this->classAlias;
    }

    /**
     * {@inheritdoc}
     */
    public function getClassName(): string
    {
        return ClassUtils::getRealClass(parent::getClassName());
    }

    /**
     * {@inheritdoc}
     */
    protected function getManager(): EntityManager
    {
        return $this->getEntityManager();
    }

    /**
     * {@inheritdoc}
     *
     * @param array      $criteria
     * @param array|null $orderBy
     * @param int        $itemsPerPage
     *
     * @return \Zend\Paginator\Paginator
     */
    public function findPaginatedBy($criteria, array $orderBy = [], int $itemsPerPage = 10): Paginator
    {
        $queryBuilder = $this->getQueryBuilderFromCriteria($criteria, $orderBy);

        return $this->paginate($queryBuilder->getQuery(), $itemsPerPage);
    }

    /**
     * Get query builder from criteria array.
     *
     * @param array $criteria
     * @param array $orderBy
     *
     * @return QueryBuilder
     */
    protected function getQueryBuilderFromCriteria(array $criteria, array $orderBy = []): QueryBuilder
    {
        $entityAlias = $this->getClassAlias();
        $queryBuilder = $this->createQueryBuilder($entityAlias);

        foreach ($criteria as $field => $value) {
            if (is_null($value)) {
                $queryBuilder->andWhere(sprintf('%s.%s IS NULL', $entityAlias, $field));
            } else {
                $parameter = sprintf('%s_%s', $field, substr(sha1($field), 0, 4));

                $queryBuilder->andWhere(sprintf('%s.%s = :%s', $entityAlias, $field, $parameter));
                $queryBuilder->setParameter($parameter, $value);
            }
        }

        if (is_array($orderBy)) {
            $entityAlias = count($queryBuilder->getRootAliases())
                ? $queryBuilder->getRootAliases()[0]
                : $this->getClassAlias();

            foreach ($orderBy as $field => $order) {
                $queryBuilder->addOrderBy($entityAlias . '.' . $field, $order);
            }
        }

        return $queryBuilder;
    }

    /**
     * Paginate query.
     *
     * @param Query $query
     * @param int   $itemsPerPage
     *
     * @return Paginator
     */
    protected function paginate(Query $query, int $itemsPerPage = 10): Paginator
    {
        return $this->getPaginator(new RelationalPaginatorAdapter(new RelationalPaginator($query)), $itemsPerPage);
    }

    /**
     * {@inheritdoc}
     *
     * @param array|QueryBuilder $criteria
     *
     * @return int
     */
    public function countBy($criteria): int
    {
        return $this->getEntityManager()->getUnitOfWork()->getEntityPersister($this->getEntityName())->count($criteria);
    }
}