BaseRepository::findAllPaginated() - 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 10:39 UTC

BaseRepository::findAllPaginated() A

↳ Parent: BaseRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	26
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	16
dl	0
loc	26
rs	9.7333
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace Mado\QueryBundle\Repositories;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;
use Hateoas\Representation\Factory\PagerfantaFactory;
use Mado\QueryBundle\Exceptions\InvalidFiltersException;
use Mado\QueryBundle\Objects\MetaDataAdapter;
use Mado\QueryBundle\Objects\PagerfantaBuilder;
use Mado\QueryBundle\Queries\QueryBuilderFactory;
use Mado\QueryBundle\Queries\QueryBuilderOptions;
use Mado\QueryBundle\Queries\QueryOptionsBuilder;
filter:
    dependency_paths: ["lib/*"]
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();

    }

    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)
    {
        $entityAlias = $this->metadata->getEntityAlias();
        $this->qoBuilder->setEntityAlias($entityAlias);
        $this->queryOptions = $this->qoBuilder->builderFromRequest($request);

        return $this;
    }

    private function ensureFilterIsValid($filters)
    {
        if (!is_array($filters)) {

            $message = "Wrong query string exception: ";
            $message .= var_export($filters, true) . "\n";
            $message .= "Please check query string should be something like " .
                "http://127.0.0.1:8000/?filtering[status]=todo";

            throw new InvalidFiltersException($message);
        }
    }

    public function setQueryOptionsFromRequestWithCustomFilter(Request $request = null, $filter)
    {
        $filters = $request->query->get('filtering', []);
        $orFilters = $request->query->get('filtering_or', []);
        $sorting = $request->query->get('sorting', []);
        $printing = $request->query->get('printing', []);
        $rel = $request->query->get('rel', '');
        $page = $request->query->get('page', '');
        $select = $request->query->get('select', $this->metadata->getEntityAlias());
        $filtering = $request->query->get('filtering', '');
        $limit = $request->query->get('limit', '');
        $justCount = $request->query->get('justCount', 'false');

        $this->ensureFilterIsValid($filters);
        $filters = array_merge($filters, $filter);

        $filterOrCorrected = [];

        $count = 0;
        foreach ($orFilters as $key => $filterValue) {
            if (is_array($filterValue)) {
                foreach ($filterValue as $keyInternal => $internal) {
                    $filterOrCorrected[$keyInternal . '|' . $count] = $internal;
                    $count += 1;
                }
            } else {
                $filterOrCorrected[$key] = $filterValue;
            }
        }

        $this->queryOptions = QueryBuilderOptions::fromArray([
            '_route' => $request->attributes->get('_route'),
            '_route_params' => $request->attributes->get('_route_params', []),
            'id' => $request->attributes->get('id'),
            'filtering' => $filtering,
            'limit' => $limit,
            'page' => $page,
            'filters' => $filters,
            'orFilters' => $filterOrCorrected,
            'sorting' => $sorting,
            'rel' => $rel,
            'printing' => $printing,
            'select' => $select,
            'justCount' => $justCount,
        ]);

        return $this;
    }

    public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, $orFilter)
    {
        $filters = $request->query->get('filtering', []);
        $orFilters = $request->query->get('filtering_or', []);
        $sorting = $request->query->get('sorting', []);
        $printing = $request->query->get('printing', []);
        $rel = $request->query->get('rel', '');
        $page = $request->query->get('page', '');
        $select = $request->query->get('select', $this->metadata->getEntityAlias());
        $filtering = $request->query->get('filtering', '');
        $limit = $request->query->get('limit', '');

        $orFilters = array_merge($orFilters, $orFilter);

        $filterOrCorrected = [];

        $count = 0;
        foreach ($orFilters as $key => $filter) {
            if (is_array($filter)) {
                foreach ($filter as $keyInternal => $internal) {
                    $filterOrCorrected[$keyInternal . '|' . $count] = $internal;
                    $count += 1;
                }
            } else {
                $filterOrCorrected[$key] = $filter;
            }
        }

        $this->queryOptions = QueryBuilderOptions::fromArray([
            '_route' => $request->attributes->get('_route'),
            '_route_params' => $request->attributes->get('_route_params', []),
            'id' => $request->attributes->get('id'),
            'filtering' => $filtering,
            'limit' => $limit,
            'page' => $page,
            'filters' => $filters,
            'orFilters' => $filterOrCorrected,
            'sorting' => $sorting,
            'rel' => $rel,
            'printing' => $printing,
            'select' => $select,
        ]);

        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;
    }
}


1			<?php
2
3			namespace Mado\QueryBundle\Repositories;
4
5			use Doctrine\ORM\EntityRepository;
6			use Doctrine\ORM\QueryBuilder;
7			use Hateoas\Representation\Factory\PagerfantaFactory;
8			use Mado\QueryBundle\Exceptions\InvalidFiltersException;
9			use Mado\QueryBundle\Objects\MetaDataAdapter;
10			use Mado\QueryBundle\Objects\PagerfantaBuilder;
11			use Mado\QueryBundle\Queries\QueryBuilderFactory;
12			use Mado\QueryBundle\Queries\QueryBuilderOptions;
13			use Mado\QueryBundle\Queries\QueryOptionsBuilder;
			0 ignored issues – show Bug introduced 2018-08-04 10:35 UTC by Report Bug Copy Issue Report The type `Mado\QueryBundle\Queries\QueryOptionsBuilder` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
14			use Mado\QueryBundle\Services\Pager;
15			use Pagerfanta\Adapter\DoctrineORMAdapter;
16			use Symfony\Component\HttpFoundation\Request;
17
18			/** @codeCoverageIgnore */
19			class BaseRepository extends EntityRepository
20			{
21			protected $request;
22
23			protected $useResultCache = false;
24
25			protected $routeName;
26
27			protected $currentEntityAlias;
28
29			protected $embeddedFields;
30
31			protected $joins = [];
32
33			protected $queryBuilderFactory;
34
35			protected $queryOptions;
36
37			protected $metadata;
38
39			private $lastQuery;
40
41			private $lastParameters;
42
43			public function __construct($manager, $class)
44			{
45			parent::__construct($manager, $class);
46
47			$this->metadata = new MetaDataAdapter();
48			$this->metadata->setClassMetadata($this->getClassMetadata());
49			$this->metadata->setEntityName($this->getEntityName());
50
51			$this->queryBuilderFactory = new QueryBuilderFactory($this->getEntityManager());
52			$this->qoBuilder = new QueryOptionsBuilder();
			0 ignored issues – show Bug Best Practice introduced 2018-08-04 10:35 UTC by Report Bug Copy Issue Report The property `qoBuilder` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
53			}
54
55			public function initFromQueryBuilderOptions(QueryBuilderOptions $options)
56			{
57			$this->queryBuilderFactory->createQueryBuilder(
58			$this->getEntityName(),
59			$this->metadata->getEntityAlias()
60			);
61
62			$this->queryBuilderFactory->loadMetadataAndOptions(
63			$this->metadata,
64			$options
65			);
66			}
67
68			public function getQueryBuilderFactory()
69			{
70			$this->initFromQueryBuilderOptions($this->queryOptions);
71
72			return $this->queryBuilderFactory;
73			}
74
75			public function useResultCache($bool)
76			{
77			$this->useResultCache = $bool;
78			}
79
80			public function setRequest(Request $request)
81			{
82			return $this->setQueryOptionsFromRequest($request);
83			}
84
85			public function setRequestWithFilter(Request $request, $filter)
86			{
87			return $this->setQueryOptionsFromRequestWithCustomFilter($request, $filter);
88			}
89
90			public function setRequestWithOrFilter(Request $request, $orFilter)
91			{
92			return $this->setQueryOptionsFromRequestWithCustomOrFilter($request, $orFilter);
93			}
94
95			public function setQueryOptions(QueryBuilderOptions $options)
96			{
97			$this->queryOptions = $options;
98			}
99
100			public function setQueryOptionsFromRequest(Request $request = null)
101			{
102			$entityAlias = $this->metadata->getEntityAlias();
103			$this->qoBuilder->setEntityAlias($entityAlias);
104			$this->queryOptions = $this->qoBuilder->builderFromRequest($request);
105
106			return $this;
107			}
108
109			private function ensureFilterIsValid($filters)
110			{
111			if (!is_array($filters)) {
112
113			$message = "Wrong query string exception: ";
114			$message .= var_export($filters, true) . "\n";
115			$message .= "Please check query string should be something like " .
116			"http://127.0.0.1:8000/?filtering[status]=todo";
117
118			throw new InvalidFiltersException($message);
119			}
120			}
121
122			public function setQueryOptionsFromRequestWithCustomFilter(Request $request = null, $filter)
123			{
124			$filters = $request->query->get('filtering', []);
125			$orFilters = $request->query->get('filtering_or', []);
126			$sorting = $request->query->get('sorting', []);
127			$printing = $request->query->get('printing', []);
128			$rel = $request->query->get('rel', '');
129			$page = $request->query->get('page', '');
130			$select = $request->query->get('select', $this->metadata->getEntityAlias());
131			$filtering = $request->query->get('filtering', '');
132			$limit = $request->query->get('limit', '');
133			$justCount = $request->query->get('justCount', 'false');
134
135			$this->ensureFilterIsValid($filters);
136			$filters = array_merge($filters, $filter);
137
138			$filterOrCorrected = [];
139
140			$count = 0;
141			foreach ($orFilters as $key => $filterValue) {
142			if (is_array($filterValue)) {
143			foreach ($filterValue as $keyInternal => $internal) {
144			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
145			$count += 1;
146			}
147			} else {
148			$filterOrCorrected[$key] = $filterValue;
149			}
150			}
151
152			$this->queryOptions = QueryBuilderOptions::fromArray([
153			'_route' => $request->attributes->get('_route'),
154			'_route_params' => $request->attributes->get('_route_params', []),
155			'id' => $request->attributes->get('id'),
156			'filtering' => $filtering,
157			'limit' => $limit,
158			'page' => $page,
159			'filters' => $filters,
160			'orFilters' => $filterOrCorrected,
161			'sorting' => $sorting,
162			'rel' => $rel,
163			'printing' => $printing,
164			'select' => $select,
165			'justCount' => $justCount,
166			]);
167
168			return $this;
169			}
170
171			public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, $orFilter)
172			{
173			$filters = $request->query->get('filtering', []);
174			$orFilters = $request->query->get('filtering_or', []);
175			$sorting = $request->query->get('sorting', []);
176			$printing = $request->query->get('printing', []);
177			$rel = $request->query->get('rel', '');
178			$page = $request->query->get('page', '');
179			$select = $request->query->get('select', $this->metadata->getEntityAlias());
180			$filtering = $request->query->get('filtering', '');
181			$limit = $request->query->get('limit', '');
182
183			$orFilters = array_merge($orFilters, $orFilter);
184
185			$filterOrCorrected = [];
186
187			$count = 0;
188			foreach ($orFilters as $key => $filter) {
189			if (is_array($filter)) {
190			foreach ($filter as $keyInternal => $internal) {
191			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
192			$count += 1;
193			}
194			} else {
195			$filterOrCorrected[$key] = $filter;
196			}
197			}
198
199			$this->queryOptions = QueryBuilderOptions::fromArray([
200			'_route' => $request->attributes->get('_route'),
201			'_route_params' => $request->attributes->get('_route_params', []),
202			'id' => $request->attributes->get('id'),
203			'filtering' => $filtering,
204			'limit' => $limit,
205			'page' => $page,
206			'filters' => $filters,
207			'orFilters' => $filterOrCorrected,
208			'sorting' => $sorting,
209			'rel' => $rel,
210			'printing' => $printing,
211			'select' => $select,
212			]);
213
214			return $this;
215			}
216
217			public function getRequest()
218			{
219			return $this->request;
220			}
221
222			public function setRouteName($routeName = '')
223			{
224			$this->routeName = $routeName;
225			return $this;
226			}
227
228			public function findAllNoPaginated()
229			{
230			$queryBuilderFactory = $this->getQueryBuilderFactory()
231			->filter()
232			->sort();
233
234			$doctrineQueryBuilder = $queryBuilderFactory->getQueryBuilder();
235
236			return $doctrineQueryBuilder->getQuery()->getResult();
237			}
238
239			public function findAllPaginated()
240			{
241			$this->initFromQueryBuilderOptions($this->queryOptions);
242
243			$this->queryBuilderFactory->filter();
244			$this->queryBuilderFactory->sort();
245
246			$queryBuilder = $this->queryBuilderFactory->getQueryBuilder();
247
248			if ($this->queryOptions->requireJustCount()) {
249			$metadata = $this->metadata;
250			$rootEntityAlias = $metadata->getEntityAlias();
251			$select = 'count(' . $rootEntityAlias . '.id)';
252
253			$count = $queryBuilder
254			->select($select)
255			->getQuery()
256			->getSingleScalarResult();
257
258			return [ 'count' => $count ];
259			}
260
261			$this->lastQuery = $queryBuilder->getQuery()->getSql();
262			$this->lastParameters = $queryBuilder->getQuery()->getParameters();
263
264			return $this->paginateResults($queryBuilder);
265			}
266
267			public function getLastQuery()
268			{
269			return [
270			'query' => $this->lastQuery,
271			'params' => $this->lastParameters,
272			];
273			}
274
275			protected function paginateResults(QueryBuilder $queryBuilder)
276			{
277			$ormAdapter = new DoctrineORMAdapter($queryBuilder);
278			$pagerfantaBuilder = new PagerfantaBuilder(new PagerfantaFactory(), $ormAdapter);
279			$pager = new Pager();
280			return $pager->paginateResults(
281			$this->queryOptions,
282			$ormAdapter,
283			$pagerfantaBuilder,
284			$this->routeName,
285			$this->useResultCache
286			);
287			}
288
289			protected function getCurrentEntityAlias() : string
290			{
291			return $this->currentEntityAlias;
292			}
293
294			protected function setCurrentEntityAlias(string $currentEntityAlias)
295			{
296			$this->currentEntityAlias = $currentEntityAlias;
297			}
298
299			protected function getEmbeddedFields() : array
300			{
301			return $this->embeddedFields;
302			}
303
304			protected function setEmbeddedFields(array $embeddedFields)
305			{
306			$this->embeddedFields = $embeddedFields;
307			}
308
309			public function getEntityAlias() : string
310			{
311			return $this->metadata->getEntityAlias();
312			}
313
314			protected function relationship($queryBuilder)
315			{
316			return $queryBuilder;
317			}
318
319			public function getQueryBuilderFactoryWithoutInitialization()
320			{
321			return $this->queryBuilderFactory;
322			}
323			}
324

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — master (#168)

BaseRepository::findAllPaginated() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like