BaseRepository::setQueryOptionsFromRequest() - Code Metrics - Inspection of "add find all without pagination" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#150)

unknown

created 2018-06-14 09:32 UTC

BaseRepository::setQueryOptionsFromRequest() B

↳ Parent: BaseRepository

Complexity

Conditions	5
Paths	6

Size

Total Lines	55
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	55
ccs	0
cts	38
cp	0
rs	8.7752
cc	5
eloc	39
nc	6
nop	1
crap	30

How to fix Long Method

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

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

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

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

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

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — master (#150)

BaseRepository::setQueryOptionsFromRequest() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like