BaseRepository::findAllNoPaginated() - Code Metrics - Inspection of "fix composer version" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — feature/2.2/http-repository ( acdd74 )

by Simone

created 2018-08-05 22:48 UTC

BaseRepository::findAllNoPaginated() A

↳ Parent: BaseRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	9
c	0
b	0
f	0
ccs	0
cts	6
cp	0
rs	10
cc	1
nc	1
nop	0
crap	2

<?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\Services\Pager;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Symfony\Component\HttpFoundation\Request;

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

    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)
    {
        $requestAttributes = [];
        foreach ($request->attributes->all() as $attributeName => $attributeValue) {
            $requestAttributes[$attributeName] = $request->attributes->get(
                $attributeName,
                $attributeValue
            );
        }

        $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', '');

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

        $requestProperties = [
            'filtering'   => $filtering,
            'orFiltering' => $filterOrCorrected,
            'limit'       => $limit,
            'page'        => $page,
            'filters'     => $filters,
            'orFilters'   => $filterOrCorrected,
            'sorting'     => $sorting,
            'rel'         => $rel,
            'printing'    => $printing,
            'select'      => $select,
        ];

        $options = array_merge(
            $requestAttributes,
            $requestProperties
        );

        $this->queryOptions = QueryBuilderOptions::fromArray($options);

        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\Services\Pager;
14			use Pagerfanta\Adapter\DoctrineORMAdapter;
15			use Symfony\Component\HttpFoundation\Request;
16
17			class BaseRepository extends EntityRepository
18			{
19			protected $request;
20
21			protected $useResultCache = false;
22
23			protected $routeName;
24
25			protected $currentEntityAlias;
26
27			protected $embeddedFields;
28
29			protected $joins = [];
30
31			protected $queryBuilderFactory;
32
33			protected $queryOptions;
34
35			protected $metadata;
36
37			private $lastQuery;
38
39			private $lastParameters;
40
41			public function __construct($manager, $class)
42			{
43			parent::__construct($manager, $class);
44
45			$this->metadata = new MetaDataAdapter();
46			$this->metadata->setClassMetadata($this->getClassMetadata());
47			$this->metadata->setEntityName($this->getEntityName());
48
49			$this->queryBuilderFactory = new QueryBuilderFactory($this->getEntityManager());
50			}
51
52			public function initFromQueryBuilderOptions(QueryBuilderOptions $options)
53			{
54			$this->queryBuilderFactory->createQueryBuilder(
55			$this->getEntityName(),
56			$this->metadata->getEntityAlias()
57			);
58
59			$this->queryBuilderFactory->loadMetadataAndOptions(
60			$this->metadata,
61			$options
62			);
63			}
64
65			public function getQueryBuilderFactory()
66			{
67			$this->initFromQueryBuilderOptions($this->queryOptions);
68
69			return $this->queryBuilderFactory;
70			}
71
72			public function useResultCache($bool)
73			{
74			$this->useResultCache = $bool;
75			}
76
77			public function setRequest(Request $request)
78			{
79			return $this->setQueryOptionsFromRequest($request);
80			}
81
82			public function setRequestWithFilter(Request $request, $filter)
83			{
84			return $this->setQueryOptionsFromRequestWithCustomFilter($request, $filter);
85			}
86
87			public function setRequestWithOrFilter(Request $request, $orFilter)
88			{
89			return $this->setQueryOptionsFromRequestWithCustomOrFilter($request, $orFilter);
90			}
91
92			public function setQueryOptions(QueryBuilderOptions $options)
93			{
94			$this->queryOptions = $options;
95			}
96
97			public function setQueryOptionsFromRequest(Request $request = null)
98			{
99			$requestAttributes = [];
100			foreach ($request->attributes->all() as $attributeName => $attributeValue) {
101			$requestAttributes[$attributeName] = $request->attributes->get(
102			$attributeName,
103			$attributeValue
104			);
105			}
106
107			$filters = $request->query->get('filtering', []);
108			$orFilters = $request->query->get('filtering_or', []);
109			$sorting = $request->query->get('sorting', []);
110			$printing = $request->query->get('printing', []);
111			$rel = $request->query->get('rel', '');
112			$page = $request->query->get('page', '');
113			$select = $request->query->get('select', $this->metadata->getEntityAlias());
114			$filtering = $request->query->get('filtering', '');
115			$limit = $request->query->get('limit', '');
116
117			$filterOrCorrected = [];
118
119			$count = 0;
120			foreach ($orFilters as $key => $filter) {
121			if (is_array($filter)) {
122			foreach ($filter as $keyInternal => $internal) {
123			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
124			$count += 1;
125			}
126			} else {
127			$filterOrCorrected[$key] = $filter;
128			}
129			}
130
131			$requestProperties = [
132			'filtering' => $filtering,
133			'orFiltering' => $filterOrCorrected,
134			'limit' => $limit,
135			'page' => $page,
136			'filters' => $filters,
137			'orFilters' => $filterOrCorrected,
138			'sorting' => $sorting,
139			'rel' => $rel,
140			'printing' => $printing,
141			'select' => $select,
142			];
143
144			$options = array_merge(
145			$requestAttributes,
146			$requestProperties
147			);
148
149			$this->queryOptions = QueryBuilderOptions::fromArray($options);
150
151			return $this;
152			}
153
154			private function ensureFilterIsValid($filters)
155			{
156			if (!is_array($filters)) {
157
158			$message = "Wrong query string exception: ";
159			$message .= var_export($filters, true) . "\n";
160			$message .= "Please check query string should be something like " .
161			"http://127.0.0.1:8000/?filtering[status]=todo";
162
163			throw new InvalidFiltersException($message);
164			}
165			}
166
167			public function setQueryOptionsFromRequestWithCustomFilter(Request $request = null, $filter)
168			{
169			$filters = $request->query->get('filtering', []);
170			$orFilters = $request->query->get('filtering_or', []);
171			$sorting = $request->query->get('sorting', []);
172			$printing = $request->query->get('printing', []);
173			$rel = $request->query->get('rel', '');
174			$page = $request->query->get('page', '');
175			$select = $request->query->get('select', $this->metadata->getEntityAlias());
176			$filtering = $request->query->get('filtering', '');
177			$limit = $request->query->get('limit', '');
178			$justCount = $request->query->get('justCount', 'false');
179
180			$this->ensureFilterIsValid($filters);
181			$filters = array_merge($filters, $filter);
182
183			$filterOrCorrected = [];
184
185			$count = 0;
186			foreach ($orFilters as $key => $filterValue) {
187			if (is_array($filterValue)) {
188			foreach ($filterValue as $keyInternal => $internal) {
189			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
190			$count += 1;
191			}
192			} else {
193			$filterOrCorrected[$key] = $filterValue;
194			}
195			}
196
197			$this->queryOptions = QueryBuilderOptions::fromArray([
198			'_route' => $request->attributes->get('_route'),
199			'_route_params' => $request->attributes->get('_route_params', []),
200			'id' => $request->attributes->get('id'),
201			'filtering' => $filtering,
202			'limit' => $limit,
203			'page' => $page,
204			'filters' => $filters,
205			'orFilters' => $filterOrCorrected,
206			'sorting' => $sorting,
207			'rel' => $rel,
208			'printing' => $printing,
209			'select' => $select,
210			'justCount' => $justCount,
211			]);
212
213			return $this;
214			}
215
216			public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, $orFilter)
217			{
218			$filters = $request->query->get('filtering', []);
219			$orFilters = $request->query->get('filtering_or', []);
220			$sorting = $request->query->get('sorting', []);
221			$printing = $request->query->get('printing', []);
222			$rel = $request->query->get('rel', '');
223			$page = $request->query->get('page', '');
224			$select = $request->query->get('select', $this->metadata->getEntityAlias());
225			$filtering = $request->query->get('filtering', '');
226			$limit = $request->query->get('limit', '');
227
228			$orFilters = array_merge($orFilters, $orFilter);
229
230			$filterOrCorrected = [];
231
232			$count = 0;
233			foreach ($orFilters as $key => $filter) {
234			if (is_array($filter)) {
235			foreach ($filter as $keyInternal => $internal) {
236			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
237			$count += 1;
238			}
239			} else {
240			$filterOrCorrected[$key] = $filter;
241			}
242			}
243
244			$this->queryOptions = QueryBuilderOptions::fromArray([
245			'_route' => $request->attributes->get('_route'),
246			'_route_params' => $request->attributes->get('_route_params', []),
247			'id' => $request->attributes->get('id'),
248			'filtering' => $filtering,
249			'limit' => $limit,
250			'page' => $page,
251			'filters' => $filters,
252			'orFilters' => $filterOrCorrected,
253			'sorting' => $sorting,
254			'rel' => $rel,
255			'printing' => $printing,
256			'select' => $select,
257			]);
258
259			return $this;
260			}
261
262			public function getRequest()
263			{
264			return $this->request;
265			}
266
267			public function setRouteName($routeName = '')
268			{
269			$this->routeName = $routeName;
270			return $this;
271			}
272
273			public function findAllNoPaginated()
274			{
275			$queryBuilderFactory = $this->getQueryBuilderFactory()
276			->filter()
277			->sort();
278
279			$doctrineQueryBuilder = $queryBuilderFactory->getQueryBuilder();
280
281			return $doctrineQueryBuilder->getQuery()->getResult();
282			}
283
284			public function findAllPaginated()
285			{
286			$this->initFromQueryBuilderOptions($this->queryOptions);
287
288			$this->queryBuilderFactory->filter();
289			$this->queryBuilderFactory->sort();
290
291			$queryBuilder = $this->queryBuilderFactory->getQueryBuilder();
292
293			if ($this->queryOptions->requireJustCount()) {
294			$metadata = $this->metadata;
295			$rootEntityAlias = $metadata->getEntityAlias();
296			$select = 'count(' . $rootEntityAlias . '.id)';
297
298			$count = $queryBuilder
299			->select($select)
300			->getQuery()
301			->getSingleScalarResult();
302
303			return [ 'count' => $count ];
304			}
305
306			$this->lastQuery = $queryBuilder->getQuery()->getSql();
307			$this->lastParameters = $queryBuilder->getQuery()->getParameters();
308
309			return $this->paginateResults($queryBuilder);
310			}
311
312			public function getLastQuery()
313			{
314			return [
315			'query' => $this->lastQuery,
316			'params' => $this->lastParameters,
317			];
318			}
319
320			protected function paginateResults(QueryBuilder $queryBuilder)
321			{
322			$ormAdapter = new DoctrineORMAdapter($queryBuilder);
323			$pagerfantaBuilder = new PagerfantaBuilder(new PagerfantaFactory(), $ormAdapter);
324			$pager = new Pager();
325			return $pager->paginateResults(
326			$this->queryOptions,
327			$ormAdapter,
328			$pagerfantaBuilder,
329			$this->routeName,
330			$this->useResultCache
331			);
332			}
333
334			protected function getCurrentEntityAlias() : string
335			{
336			return $this->currentEntityAlias;
337			}
338
339			protected function setCurrentEntityAlias(string $currentEntityAlias)
340			{
341			$this->currentEntityAlias = $currentEntityAlias;
342			}
343
344			protected function getEmbeddedFields() : array
345			{
346			return $this->embeddedFields;
347			}
348
349			protected function setEmbeddedFields(array $embeddedFields)
350			{
351			$this->embeddedFields = $embeddedFields;
352			}
353
354			public function getEntityAlias() : string
355			{
356			return $this->metadata->getEntityAlias();
357			}
358
359			protected function relationship($queryBuilder)
360			{
361			return $queryBuilder;
362			}
363
364			public function getQueryBuilderFactoryWithoutInitialization()
365			{
366			return $this->queryBuilderFactory;
367			}
368			}
369

studiomado / query-bundle

GitHub Access Token became invalid

Push — feature/2.2/http-repository ( acdd74 )

BaseRepository::findAllNoPaginated() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like