BaseRepository::customQueryStringValues() - Code Metrics - Inspection of "remove deprecations" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — remove-deprecations ( 1aa855 )

by Simone

created 2018-01-26 14:41 UTC

BaseRepository::customQueryStringValues() A

↳ Parent: BaseRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace Mado\QueryBundle\Repositories;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;
use Hateoas\Representation\Factory\PagerfantaFactory;
use Mado\QueryBundle\Queries\QueryBuilderFactory;
use Mado\QueryBundle\Queries\QueryBuilderOptions;
use Mado\QueryBundle\Services\Router;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Pagerfanta\Pagerfanta;
use Symfony\Component\HttpFoundation\Request;

class BaseRepository extends EntityRepository
{
    protected $fields;

    protected $request;

    protected $use_result_cache = false;

    protected $entityAlias;

    protected $route_name;

    protected $currentEntityAlias;

    protected $embeddedFields;

    protected $joins = [];

    protected $queryBuilderFactory;

    protected $queryOptions;

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

        $this->fields = array_keys($this->getClassMetadata()->fieldMappings);

        $entityName = explode('\\', strtolower($this->getEntityName()));
        $entityName = $entityName[count($entityName) - 1];
        $entityAlias = $entityName[0];
        $this->entityAlias = $entityAlias;

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

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

        $fieldMappings = $this->getClassMetadata()->fieldMappings;
        $this->fields = array_keys($fieldMappings);

        $this->queryBuilderFactory->setFields($this->fields ?? []);
        $this->queryBuilderFactory->setAndFilters($options->getAndFilters());
        $this->queryBuilderFactory->setOrFilters($options->getOrFilters());
        $this->queryBuilderFactory->setSorting($options->getSorting());
        $this->queryBuilderFactory->setRel([$options->getRel()]);
        $this->queryBuilderFactory->setPrinting($options->getPrinting());
        $this->queryBuilderFactory->setSelect($options->getSelect());
    }

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

        return $this->queryBuilderFactory;
    }

    public function useResultCache($bool)
    {
        $this->use_result_cache = $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->entityAlias);
        $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;
    }

    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->entityAlias);
        $filtering = $request->query->get('filtering', '');
        $limit = $request->query->get('limit', '');

        $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->entityAlias);
        $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($route_name = '')
    {
        $this->route_name = $route_name;
        return $this;
    }

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

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

        return $this->paginateResults($this->queryBuilderFactory->getQueryBuilder());
    }

    protected function paginateResults(QueryBuilder $queryBuilder) {
        $limit = $this->queryOptions->get('limit', 10);
        $page = $this->queryOptions->get('page', 1);

        $pagerAdapter = new DoctrineORMAdapter($queryBuilder);

        $query = $pagerAdapter->getQuery();
        if (isset($this->use_result_cache) and $this->use_result_cache) {
            $query->useResultCache(true, 600);
        }

        $pager = new Pagerfanta($pagerAdapter);
        $pager->setNormalizeOutOfRangePages(true);
        $pager->setMaxPerPage($limit);
        $pager->setCurrentPage($page);

        $pagerFactory = new PagerfantaFactory();

        $router = new Router();
        $route = $router->createRouter($this->queryOptions, $this->route_name);

        return $pagerFactory->createRepresentation($pager, $route);
    }

    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 $entityName) : string
    {
        $arrayEntityName = explode('\\', strtolower($entityName));
        return $arrayEntityName[count($arrayEntityName) - 1];
    }

    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\Queries\QueryBuilderFactory;
9			use Mado\QueryBundle\Queries\QueryBuilderOptions;
10			use Mado\QueryBundle\Services\Router;
11			use Pagerfanta\Adapter\DoctrineORMAdapter;
12			use Pagerfanta\Pagerfanta;
13			use Symfony\Component\HttpFoundation\Request;
14
15			class BaseRepository extends EntityRepository
16			{
17			protected $fields;
18
19			protected $request;
20
21			protected $use_result_cache = false;
22
23			protected $entityAlias;
24
25			protected $route_name;
26
27			protected $currentEntityAlias;
28
29			protected $embeddedFields;
30
31			protected $joins = [];
32
33			protected $queryBuilderFactory;
34
35			protected $queryOptions;
36
37			public function __construct($manager, $class)
38			{
39			parent::__construct($manager, $class);
40
41			$this->fields = array_keys($this->getClassMetadata()->fieldMappings);
42
43			$entityName = explode('\\', strtolower($this->getEntityName()));
44			$entityName = $entityName[count($entityName) - 1];
45			$entityAlias = $entityName[0];
46			$this->entityAlias = $entityAlias;
47
48			$this->queryBuilderFactory = new QueryBuilderFactory($this->getEntityManager());
49			}
50
51			public function initFromQueryBuilderOptions(QueryBuilderOptions $options)
52			{
53			$this->queryBuilderFactory->createQueryBuilder($this->getEntityName(), $this->entityAlias);
54
55			$fieldMappings = $this->getClassMetadata()->fieldMappings;
56			$this->fields = array_keys($fieldMappings);
57
58			$this->queryBuilderFactory->setFields($this->fields ?? []);
59			$this->queryBuilderFactory->setAndFilters($options->getAndFilters());
60			$this->queryBuilderFactory->setOrFilters($options->getOrFilters());
61			$this->queryBuilderFactory->setSorting($options->getSorting());
62			$this->queryBuilderFactory->setRel([$options->getRel()]);
63			$this->queryBuilderFactory->setPrinting($options->getPrinting());
64			$this->queryBuilderFactory->setSelect($options->getSelect());
65			}
66
67			public function getQueryBuilderFactory()
68			{
69			$this->initFromQueryBuilderOptions($this->queryOptions);
70
71			return $this->queryBuilderFactory;
72			}
73
74			public function useResultCache($bool)
75			{
76			$this->use_result_cache = $bool;
77			}
78
79			public function setRequest(Request $request)
80			{
81			return $this->setQueryOptionsFromRequest($request);
82			}
83
84			public function setRequestWithFilter(Request $request, $filter)
85			{
86			return $this->setQueryOptionsFromRequestWithCustomFilter($request, $filter);
87			}
88
89			public function setRequestWithOrFilter(Request $request, $orFilter)
90			{
91			return $this->setQueryOptionsFromRequestWithCustomOrFilter($request, $orFilter);
92			}
93
94			public function setQueryOptions(QueryBuilderOptions $options)
95			{
96			$this->queryOptions = $options;
97			}
98
99			public function setQueryOptionsFromRequest(Request $request = null)
100			{
101			$requestAttributes = [];
102			foreach ($request->attributes->all() as $attributeName => $attributeValue) {
103			$requestAttributes[$attributeName] = $request->attributes->get(
104			$attributeName,
105			$attributeValue
106			);
107			}
108
109			$filters = $request->query->get('filtering', []);
110			$orFilters = $request->query->get('filtering_or', []);
111			$sorting = $request->query->get('sorting', []);
112			$printing = $request->query->get('printing', []);
113			$rel = $request->query->get('rel', '');
114			$page = $request->query->get('page', '');
115			$select = $request->query->get('select', $this->entityAlias);
116			$filtering = $request->query->get('filtering', '');
117			$limit = $request->query->get('limit', '');
118
119			$filterOrCorrected = [];
120
121			$count = 0;
122			foreach ($orFilters as $key => $filter) {
123			if (is_array($filter)) {
124			foreach ($filter as $keyInternal => $internal) {
125			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
126			$count += 1;
127			}
128			} else {
129			$filterOrCorrected[$key] = $filter;
130			}
131			}
132
133			$requestProperties = [
134			'filtering' => $filtering,
135			'orFiltering' => $filterOrCorrected,
136			'limit' => $limit,
137			'page' => $page,
138			'filters' => $filters,
139			'orFilters' => $filterOrCorrected,
140			'sorting' => $sorting,
141			'rel' => $rel,
142			'printing' => $printing,
143			'select' => $select,
144			];
145
146			$options = array_merge(
147			$requestAttributes,
148			$requestProperties
149			);
150
151			$this->queryOptions = QueryBuilderOptions::fromArray($options);
152
153			return $this;
154			}
155
156			public function setQueryOptionsFromRequestWithCustomFilter(Request $request = null, $filter)
157			{
158			$filters = $request->query->get('filtering', []);
159			$orFilters = $request->query->get('filtering_or', []);
160			$sorting = $request->query->get('sorting', []);
161			$printing = $request->query->get('printing', []);
162			$rel = $request->query->get('rel', '');
163			$page = $request->query->get('page', '');
164			$select = $request->query->get('select', $this->entityAlias);
165			$filtering = $request->query->get('filtering', '');
166			$limit = $request->query->get('limit', '');
167
168			$filters = array_merge($filters, $filter);
169
170			$filterOrCorrected = [];
171
172			$count = 0;
173			foreach ($orFilters as $key => $filterValue) {
174			if (is_array($filterValue)) {
175			foreach ($filterValue as $keyInternal => $internal) {
176			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
177			$count += 1;
178			}
179			} else {
180			$filterOrCorrected[$key] = $filterValue;
181			}
182			}
183
184			$this->queryOptions = QueryBuilderOptions::fromArray([
185			'_route' => $request->attributes->get('_route'),
186			'_route_params' => $request->attributes->get('_route_params', []),
187			'id' => $request->attributes->get('id'),
188			'filtering' => $filtering,
189			'limit' => $limit,
190			'page' => $page,
191			'filters' => $filters,
192			'orFilters' => $filterOrCorrected,
193			'sorting' => $sorting,
194			'rel' => $rel,
195			'printing' => $printing,
196			'select' => $select,
197			]);
198
199			return $this;
200			}
201
202			public function setQueryOptionsFromRequestWithCustomOrFilter(Request $request = null, $orFilter)
203			{
204			$filters = $request->query->get('filtering', []);
205			$orFilters = $request->query->get('filtering_or', []);
206			$sorting = $request->query->get('sorting', []);
207			$printing = $request->query->get('printing', []);
208			$rel = $request->query->get('rel', '');
209			$page = $request->query->get('page', '');
210			$select = $request->query->get('select', $this->entityAlias);
211			$filtering = $request->query->get('filtering', '');
212			$limit = $request->query->get('limit', '');
213
214			$orFilters = array_merge($orFilters, $orFilter);
215
216			$filterOrCorrected = [];
217
218			$count = 0;
219			foreach ($orFilters as $key => $filter) {
220			if (is_array($filter)) {
221			foreach ($filter as $keyInternal => $internal) {
222			$filterOrCorrected[$keyInternal . '\|' . $count] = $internal;
223			$count += 1;
224			}
225			} else {
226			$filterOrCorrected[$key] = $filter;
227			}
228			}
229
230			$this->queryOptions = QueryBuilderOptions::fromArray([
231			'_route' => $request->attributes->get('_route'),
232			'_route_params' => $request->attributes->get('_route_params', []),
233			'id' => $request->attributes->get('id'),
234			'filtering' => $filtering,
235			'limit' => $limit,
236			'page' => $page,
237			'filters' => $filters,
238			'orFilters' => $filterOrCorrected,
239			'sorting' => $sorting,
240			'rel' => $rel,
241			'printing' => $printing,
242			'select' => $select,
243			]);
244
245			return $this;
246			}
247
248			public function getRequest()
249			{
250			return $this->request;
251			}
252
253			public function setRouteName($route_name = '')
254			{
255			$this->route_name = $route_name;
256			return $this;
257			}
258
259			public function findAllPaginated()
260			{
261			$this->initFromQueryBuilderOptions($this->queryOptions);
262
263			$this->queryBuilderFactory->filter();
264			$this->queryBuilderFactory->sort();
265
266			return $this->paginateResults($this->queryBuilderFactory->getQueryBuilder());
267			}
268
269			protected function paginateResults(QueryBuilder $queryBuilder) {
270			$limit = $this->queryOptions->get('limit', 10);
271			$page = $this->queryOptions->get('page', 1);
272
273			$pagerAdapter = new DoctrineORMAdapter($queryBuilder);
274
275			$query = $pagerAdapter->getQuery();
276			if (isset($this->use_result_cache) and $this->use_result_cache) {
277			$query->useResultCache(true, 600);
278			}
279
280			$pager = new Pagerfanta($pagerAdapter);
281			$pager->setNormalizeOutOfRangePages(true);
282			$pager->setMaxPerPage($limit);
283			$pager->setCurrentPage($page);
284
285			$pagerFactory = new PagerfantaFactory();
286
287			$router = new Router();
288			$route = $router->createRouter($this->queryOptions, $this->route_name);
289
290			return $pagerFactory->createRepresentation($pager, $route);
291			}
292
293			protected function getCurrentEntityAlias() : string
294			{
295			return $this->currentEntityAlias;
296			}
297
298			protected function setCurrentEntityAlias(string $currentEntityAlias)
299			{
300			$this->currentEntityAlias = $currentEntityAlias;
301			}
302
303			protected function getEmbeddedFields() : array
304			{
305			return $this->embeddedFields;
306			}
307
308			protected function setEmbeddedFields(array $embeddedFields)
309			{
310			$this->embeddedFields = $embeddedFields;
311			}
312
313			public function getEntityAlias(string $entityName) : string
314			{
315			$arrayEntityName = explode('\\', strtolower($entityName));
316			return $arrayEntityName[count($arrayEntityName) - 1];
317			}
318
319			protected function relationship($queryBuilder)
320			{
321			return $queryBuilder;
322			}
323
324			public function getQueryBuilderFactoryWithoutInitialization()
325			{
326			return $this->queryBuilderFactory;
327			}
328			}
329

studiomado / query-bundle

GitHub Access Token became invalid

Push — remove-deprecations ( 1aa855 )

BaseRepository::customQueryStringValues() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like