BaseRepository::getEmbeddedFields() - Code Metrics - Inspection of "add new FilterObject component" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#75)

by Simone

created 2018-01-04 22:36 UTC

BaseRepository::getEmbeddedFields() 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	1
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\Configuration\Route;
filter:
    dependency_paths: ["lib/*"]
use Hateoas\Representation\Factory\PagerfantaFactory;
filter:
    dependency_paths: ["lib/*"]
use Mado\QueryBundle\Queries\QueryBuilderFactory;
use Mado\QueryBundle\Queries\QueryBuilderOptions;
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->setFilters($options->getFilters());
        $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'),
            'customer_id' => $request->attributes->get('customer_id'),
            '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'),
            'customer_id' => $request->attributes->get('customer_id'),
            '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(null != $this->use_result_cache && $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 = $this->createRouter();

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

    protected function customQueryStringValues()
    {
        return [];
    }

    protected function createRouter()
    {
        $params = [];

        $list = array_merge([
            'filtering',
            'limit',
            'page',
            'sorting',
        ], $this->customQueryStringValues());

        foreach ($list as $itemKey => $itemValue) {
            $params[$itemValue] = $this->queryOptions->get($itemValue);
        }

        if(!isset($this->route_name)){
            $this->route_name = $this->queryOptions->get('_route');
        }

        return new Route($this->route_name, $params);
    }

    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\Configuration\Route;
		0 ignored issues – show Bug introduced 2017-08-29 10:25 UTC by Report Bug Copy Issue Report The type `Hateoas\Configuration\Route` 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...
8		use Hateoas\Representation\Factory\PagerfantaFactory;
		0 ignored issues – show Bug introduced 2017-08-29 10:25 UTC by Report Bug Copy Issue Report The type `Hateoas\Representation\Factory\PagerfantaFactory` 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...
9		use Mado\QueryBundle\Queries\QueryBuilderFactory;
10		use Mado\QueryBundle\Queries\QueryBuilderOptions;
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	5
37		public function __construct($manager, $class)
38	5	{
39		parent::__construct($manager, $class);
40	5
41		$this->fields = array_keys($this->getClassMetadata()->fieldMappings);
42	5
43	5	$entityName = explode('\\', strtolower($this->getEntityName()) );
44	5	$entityName = $entityName[count($entityName)-1];
45	5	$entityAlias = $entityName[0];
46		$this->entityAlias = $entityAlias;
47	5
48	5	$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->setFilters($options->getFilters());
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	1
79		public function setRequest(Request $request)
80	1	{
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	3
99		public function setQueryOptionsFromRequest(Request $request = null)
100	3	{
101		$requestAttributes = [];
102	3	foreach ($request->attributes->all() as $attributeName => $attributeValue) {
103	3	$requestAttributes[$attributeName] = $request->attributes->get(
104	3	$attributeName,
105	3	$attributeValue
106	3	);
107	3	}
108	3
109	3	$filters = $request->query->get('filtering', []);
110	3	$orFilters = $request->query->get('filtering_or', []);
111		$sorting = $request->query->get('sorting', []);
112	3	$printing = $request->query->get('printing', []);
113		$rel = $request->query->get('rel', '');
114	3	$page = $request->query->get('page', '');
115	3	$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	3	}
128	3	} else {
129	3	$filterOrCorrected[$key] = $filter;
130	3	}
131	3	}
132	3
133	3	$requestProperties = [
134	3	'filtering' => $filtering,
135	3	'orFiltering' => $filterOrCorrected,
136	3	'limit' => $limit,
137		'page' => $page,
138		'filters' => $filters,
139	3	'orFilters' => $filterOrCorrected,
140	3	'sorting' => $sorting,
141	3	'rel' => $rel,
142		'printing' => $printing,
143		'select' => $select,
144	3	];
145
146	3	$options = array_merge(
147		$requestAttributes,
148		$requestProperties
149	4	);
150
151	4	$this->queryOptions = QueryBuilderOptions::fromArray($options);
152
153	4	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	4	$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		'customer_id' => $request->attributes->get('customer_id'),
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	1	$count = 0;
219		foreach ($orFilters as $key => $filter) {
220	1	if (is_array($filter)) {
221		foreach ($filter as $keyInternal => $internal) {
222	1	$filterOrCorrected[$keyInternal .'\|' . $count] = $internal;
223	1	$count += 1;
224	1	}
225	1	} else {
226	1	$filterOrCorrected[$key] = $filter;
227	1	}
228	1	}
229	1
230	1	$this->queryOptions = QueryBuilderOptions::fromArray([
231		'_route' => $request->attributes->get('_route'),
232	1	'customer_id' => $request->attributes->get('customer_id'),
233		'id' => $request->attributes->get('id'),
234	1	'filtering' => $filtering,
235		'limit' => $limit,
236	1	'page' => $page,
237	1	'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	1	{
250	1	return $this->request;
251	1	}
252	1
253	1	public function setRouteName($route_name = '')
254	1	{
255	1	$this->route_name = $route_name;
256	1	return $this;
257	1	}
258	1
259	1	public function findAllPaginated()
260	1	{
261		$this->initFromQueryBuilderOptions($this->queryOptions);
262
263	1	$this->queryBuilderFactory->filter();
264	1	$this->queryBuilderFactory->sort();
265	1
266		return $this->paginateResults($this->queryBuilderFactory->getQueryBuilder());
267		}
268	1
269		protected function paginateResults(QueryBuilder $queryBuilder) {
270	1	$limit = $this->queryOptions->get('limit', 10);
271		$page = $this->queryOptions->get('page', 1);
272
273	4	$pagerAdapter = new DoctrineORMAdapter($queryBuilder);
274
275	4	$query = $pagerAdapter->getQuery();
276		if(null != $this->use_result_cache && $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 = $this->createRouter();
288
289		return $pagerFactory->createRepresentation($pager, $router);
290		}
291
292		protected function customQueryStringValues()
293		{
294		return [];
295		}
296
297		protected function createRouter()
298		{
299		$params = [];
300
301		$list = array_merge([
302		'filtering',
303		'limit',
304		'page',
305		'sorting',
306		], $this->customQueryStringValues());
307
308		foreach ($list as $itemKey => $itemValue) {
309		$params[$itemValue] = $this->queryOptions->get($itemValue);
310		}
311
312		if(!isset($this->route_name)){
313		$this->route_name = $this->queryOptions->get('_route');
314		}
315
316		return new Route($this->route_name, $params);
317		}
318
319		protected function getCurrentEntityAlias() : string
320		{
321		return $this->currentEntityAlias;
322		}
323
324		protected function setCurrentEntityAlias(string $currentEntityAlias)
325		{
326		$this->currentEntityAlias = $currentEntityAlias;
327		}
328
329		protected function getEmbeddedFields() : array
330		{
331		return $this->embeddedFields;
332		}
333
334		protected function setEmbeddedFields(array $embeddedFields)
335		{
336		$this->embeddedFields = $embeddedFields;
337		}
338
339		public function getEntityAlias(string $entityName) : string
340		{
341		$arrayEntityName = explode('\\', strtolower($entityName) );
342		return $arrayEntityName[count($arrayEntityName)-1];
343		}
344
345		protected function relationship($queryBuilder)
346		{
347		return $queryBuilder;
348		}
349
350		public function getQueryBuilderFactoryWithoutInitialization()
351		{
352		return $this->queryBuilderFactory;
353		}
354		}
355

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — master (#75)

BaseRepository::getEmbeddedFields() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like