BaseRepository::paginateResults() - Code Metrics - Inspection of "[wip] - start moving out from BaseRepository the r..." - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#168)

by Simone
created 2018-08-04 14:09 UTC
BaseRepository::paginateResults() A

↳ Parent: BaseRepository
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	9
dl	0
loc	11
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	1
<?php

namespace Mado\QueryBundle\Repositories;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;
use Hateoas\Representation\Factory\PagerfantaFactory;
use Mado\QueryBundle\Objects\MetaDataAdapter;
use Mado\QueryBundle\Objects\PagerfantaBuilder;
use Mado\QueryBundle\Queries\QueryBuilderFactory;
use Mado\QueryBundle\Queries\QueryBuilderOptions;
use Mado\QueryBundle\Queries\Options\QueryOptionsBuilder;
use Mado\QueryBundle\Services\Pager;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Symfony\Component\HttpFoundation\Request;

/** @codeCoverageIgnore */
class BaseRepository extends EntityRepository
{
    protected $request;

    protected $useResultCache = false;

    protected $routeName;

    protected $currentEntityAlias;

    protected $embeddedFields;

    protected $joins = [];

    protected $queryBuilderFactory;

    protected $queryOptions;

    protected $metadata;

    private $lastQuery;
    
    private $lastParameters;

    public function __construct($manager, $class)
    {
        parent::__construct($manager, $class);

        $this->metadata = new MetaDataAdapter();
        $this->metadata->setClassMetadata($this->getClassMetadata());
        $this->metadata->setEntityName($this->getEntityName());

        $this->queryBuilderFactory = new QueryBuilderFactory($this->getEntityManager());

        $this->qoBuilder = new QueryOptionsBuilder();

        $entityAlias = $this->metadata->getEntityAlias();
        $this->qoBuilder->setEntityAlias($entityAlias);
    }

    public function initFromQueryBuilderOptions(QueryBuilderOptions $options)
    {
        $this->queryBuilderFactory->createQueryBuilder(
            $this->getEntityName(),
            $this->metadata->getEntityAlias()
        );

        $this->queryBuilderFactory->loadMetadataAndOptions(
            $this->metadata,
            $options
        );
    }

    public function getQueryBuilderFactory()
    {
        $this->initFromQueryBuilderOptions($this->queryOptions);

        return $this->queryBuilderFactory;
    }

    public function useResultCache($bool)
    {
        $this->useResultCache = $bool;
    }

    public function setRequest(Request $request)
    {
        return $this->setQueryOptionsFromRequest($request);
    }

    public function setRequestWithFilter(Request $request, $filter)
    {
        return $this->setQueryOptionsFromRequestWithCustomFilter($request, $filter);
    }

    public function setRequestWithOrFilter(Request $request, $orFilter)
    {
        return $this->setQueryOptionsFromRequestWithCustomOrFilter($request, $orFilter);
    }

    public function setQueryOptions(QueryBuilderOptions $options)
    {
        $this->queryOptions = $options;
    }

    public function setQueryOptionsFromRequest(Request $request = null)
    {
        $this->queryOptions = $this->qoBuilder->builderFromRequest($request);

        return $this;
    }

    public function setQueryOptionsFromRequestWithCustomFilter(Request $request = null, $filter)
    {
        $this->queryOptions = $this->qoBuilder->buildFromRequestAndCustomFilter($request, $filter);
        $this->queryOptions = $this->qoBuilder->buildFromRequestAndCustomFilter(/** @scrutinizer ignore-type */ $request, $filter);

        return $this;
    }

    public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, $orFilter)
    public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, /** @scrutinizer ignore-unused */ $orFilter)
    {
        $this->queryOptions = $this->qoBuilder->buildForOrFilter($request);
        $this->queryOptions = $this->qoBuilder->buildForOrFilter(/** @scrutinizer ignore-type */ $request);

        return $this;
    }

    public function getRequest()
    {
        return $this->request;
    }

    public function setRouteName($routeName = '')
    {
        $this->routeName = $routeName;
        return $this;
    }

    public function findAllNoPaginated()
    {
        $queryBuilderFactory = $this->getQueryBuilderFactory()
            ->filter()
            ->sort();

        $doctrineQueryBuilder = $queryBuilderFactory->getQueryBuilder();

        return $doctrineQueryBuilder->getQuery()->getResult();
    }
    
    public function findAllPaginated()
    {
        $this->initFromQueryBuilderOptions($this->queryOptions);

        $this->queryBuilderFactory->filter();
        $this->queryBuilderFactory->sort();

        $queryBuilder = $this->queryBuilderFactory->getQueryBuilder();

        if ($this->queryOptions->requireJustCount()) {
            $metadata = $this->metadata;
            $rootEntityAlias = $metadata->getEntityAlias();
            $select = 'count(' . $rootEntityAlias . '.id)';

            $count = $queryBuilder
                ->select($select)
                ->getQuery()
                ->getSingleScalarResult();

            return [ 'count' => $count ];
        }

        $this->lastQuery = $queryBuilder->getQuery()->getSql();
        $this->lastParameters = $queryBuilder->getQuery()->getParameters();

        return $this->paginateResults($queryBuilder);
    }

    public function getLastQuery()
    {
        return [
            'query' => $this->lastQuery,
            'params' =>  $this->lastParameters,
        ];
    }

    protected function paginateResults(QueryBuilder $queryBuilder)
    {
        $ormAdapter = new DoctrineORMAdapter($queryBuilder);
        $pagerfantaBuilder = new PagerfantaBuilder(new PagerfantaFactory(), $ormAdapter);
        $pager = new Pager();
        return $pager->paginateResults(
            $this->queryOptions,
            $ormAdapter,
            $pagerfantaBuilder,
            $this->routeName,
            $this->useResultCache
        );
    }

    protected function getCurrentEntityAlias() : string
    {
        return $this->currentEntityAlias;
    }

    protected function setCurrentEntityAlias(string $currentEntityAlias)
    {
        $this->currentEntityAlias = $currentEntityAlias;
    }

    protected function getEmbeddedFields() : array
    {
        return $this->embeddedFields;
    }

    protected function setEmbeddedFields(array $embeddedFields)
    {
        $this->embeddedFields = $embeddedFields;
    }

    public function getEntityAlias() : string
    {
        return $this->metadata->getEntityAlias();
    }

    protected function relationship($queryBuilder)
    {
        return $queryBuilder;
    }

    public function getQueryBuilderFactoryWithoutInitialization()
    {
        return $this->queryBuilderFactory;
    }
}

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — master (#168)

BaseRepository::paginateResults() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
