QueryFilter::filter() - Code Metrics - Inspection of "Solve bugs for nullable type (#13)" - bugloos/query-filter-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 7ac0ad...a216bf )

by Milad

created 2022-05-30 12:35 UTC

QueryFilter::filter() A

↳ Parent: QueryFilter

Complexity

Conditions	2
Paths	2

Size

Total Lines	19
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	9
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	19
rs	9.9666

<?php

declare(strict_types=1);

namespace Bugloos\QueryFilterBundle\Service;

use Bugloos\QueryFilterBundle\Enum\ColumnType;
use Closure;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\QueryBuilder;
use JsonException;
use Bugloos\QueryFilterBundle\FilterHandler\Contract\WithRelationInterface;
use Bugloos\QueryFilterBundle\FilterHandler\Factory\FilterFactory;
use Bugloos\QueryFilterBundle\Traits\QueryFilterTrait;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\InvalidArgumentException;
use Symfony\Contracts\Cache\CacheInterface;

/**
 * @author Milad Ghofrani <[email protected]>
 */
class QueryFilter
{
    use QueryFilterTrait;

    private const DEFAULT_CACHE_TIME = 3600;

    private const SEPARATOR = '.';

    private EntityManagerInterface $entityManager;

    private FilterFactory $filterFactory;

    private CacheInterface $cache;

    private string $rootAlias;

    private string $rootEntity;

    private ClassMetadata $rootClass;

    private QueryBuilder $query;

    private string $cacheKey;

    private array $filters = [];

    private array $mapper = [];

    private array $strategies = [];

    private array $types = [];

    private ?int $cacheTime = null;

    private bool $withOr = false;

    private int $defaultCacheTime;

    private string $separator;

    public function __construct(
        EntityManagerInterface $entityManager,
        CacheInterface $cache,
        FilterFactory $filterFactory,
        $defaultCacheTime = self::DEFAULT_CACHE_TIME,
        $separator = self::SEPARATOR
    ) {
        $this->entityManager = $entityManager;
        $this->cache = $cache;
        $this->filterFactory = $filterFactory;
        $this->defaultCacheTime = $defaultCacheTime;
        $this->separator = $separator;
    }

    public function for(QueryBuilder $query): self
    {
        $this->initializeRootQueryConfig($query);

        return $this;
    }

    /**
     * @param $filters
     *
     * @return self
     *
     * @throws JsonException
     */
    public function parameters($filters): self
    {
        if (empty($filters)) {
            return $this;
        }

        if (!\is_array($filters)) {
            throw new \InvalidArgumentException(
                'Filter parameters should be an array type'
            );
        }

        // Remove empty value from array
        $this->filters = array_filter($filters, static function ($var) {
            return null !== $var && '' !== $var;
        });

        // Create cache key by request
        $this->createCacheKey($this->filters);

        return $this;
    }

    /**
     * @throws InvalidArgumentException
     */
    public function filter(): QueryBuilder
    {
        // Early return if array is empty
        if (empty($this->filters)) {
            return $this->query;
        }
        // Calculate and cache fields.
        [$filterParameters, $filterWhereClauses, $relationJoins] = $this->cache->get(
            $this->cacheKey,
            $this->addWhereClauses()
        );

        $this->applyRelationJoinToQuery($relationJoins);

        $this->applyWhereClausesToQuery($filterWhereClauses);

        $this->applyParametersToQuery($filterParameters);

        return $this->query;
    }

    private function applyWhereClausesToQuery($filterWhereClauses): void
    {
        if (!empty($filterWhereClauses)) {
            if ($this->withOr) {
                $this->query->andWhere($this->query->expr()->orX()->addMultiple($filterWhereClauses));
            } else {
                $this->query->andWhere($this->query->expr()->andx()->addMultiple($filterWhereClauses));
            }
        }
    }

    private function applyParametersToQuery($filterParameters): void
    {
        foreach ($filterParameters as $parameterName => $parameterValue) {
            $this->query->setParameter($parameterName, $parameterValue);
        }
    }

    private function applyRelationJoinToQuery($relationJoins): void
    {
        // Remove exist joined from a list
        $filteredJoins = array_diff($relationJoins, $this->query->getAllAliases());

        // Add a left join to query which does not exist in the query
        if (!empty($filteredJoins)) {
            foreach ($filteredJoins as $property => $column) {
                $this->query->addSelect($column);
                $this->query->leftJoin($property, $column);
            }
        }
    }

    /**
     * @param $array
     *
     * @throws JsonException
     */
    private function createCacheKey($array): void
    {
        $this->cacheKey = md5($this->rootEntity.json_encode($array, \JSON_THROW_ON_ERROR));
    }

    /**
     * @author Milad Ghofrani <[email protected]>
     */
    private function addWhereClauses(): Closure
    {
        return function (CacheItemInterface $item) {
            $item->expiresAfter($this->cacheTime ?: $this->defaultCacheTime);

            $filterParameters = [];
            $filterWhereClauses = [];
            $relationJoins = [];

            foreach ($this->filters as $parameter => $value) {
                // Check user set a strategy for this $parameter
                $strategy = $this->strategies[$parameter] ?? null;

                // Check user set a type for this $parameter
                $type = $this->types[$parameter] ?? null;

                // Check $parameter exists in mapper
                $parameter = (\array_key_exists($parameter, $this->mapper))
                    ? $this->mapper[$parameter] : $parameter;

                $relationsAndFieldName = explode($this->separator, $parameter);

                $filteringHandler = $this->filterFactory->createFilterHandler($relationsAndFieldName);

                $filterParameter = $filteringHandler->filterParameter(
                    $this->rootAlias,
                    $this->rootClass,
                    $relationsAndFieldName,
                    $type
                );

                if($type !== ColumnType::NULLABLE){
                    $filterParameters[$filterParameter] = $filteringHandler->filterValue($value, $strategy);
                }

                $filterWhereClauses[] = $filteringHandler->filterWhereClause(
                    $this->rootAlias,
                    $relationsAndFieldName,
                    $filterParameter,
                    $strategy,
                    $value
                );

                if ($filteringHandler instanceof WithRelationInterface) {
                    $relationJoins = $filteringHandler->relationJoin(
                        $relationJoins,
                        $this->rootAlias,
                        $this->rootClass,
                        $relationsAndFieldName
                    );
                }
            }

            return [$filterParameters, $filterWhereClauses, $relationJoins];
        };
    }

    private function initializeRootQueryConfig($query): void
    {
        $rootEntities = $query->getRootEntities();
        $rootAliasArray = $query->getRootAliases();

        if (!isset($rootEntities[0], $rootAliasArray[0])) {
            throw new \InvalidArgumentException('Root Alias not defined correctly.');
        }

        $this->query = $query;
        $this->rootAlias = $rootAliasArray[0];
        $this->rootEntity = $rootEntities[0];
        $this->rootClass = $this->entityManager->getClassMetadata($this->rootEntity);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Bugloos\QueryFilterBundle\Service;
6
7			use Bugloos\QueryFilterBundle\Enum\ColumnType;
8			use Closure;
9			use Doctrine\ORM\EntityManagerInterface;
10			use Doctrine\ORM\Mapping\ClassMetadata;
11			use Doctrine\ORM\QueryBuilder;
12			use JsonException;
13			use Bugloos\QueryFilterBundle\FilterHandler\Contract\WithRelationInterface;
14			use Bugloos\QueryFilterBundle\FilterHandler\Factory\FilterFactory;
15			use Bugloos\QueryFilterBundle\Traits\QueryFilterTrait;
16			use Psr\Cache\CacheItemInterface;
17			use Psr\Cache\InvalidArgumentException;
18			use Symfony\Contracts\Cache\CacheInterface;
19
20			/**
21			* @author Milad Ghofrani <[email protected]>
22			*/
23			class QueryFilter
24			{
25			use QueryFilterTrait;
26
27			private const DEFAULT_CACHE_TIME = 3600;
28
29			private const SEPARATOR = '.';
30
31			private EntityManagerInterface $entityManager;
32
33			private FilterFactory $filterFactory;
34
35			private CacheInterface $cache;
36
37			private string $rootAlias;
38
39			private string $rootEntity;
40
41			private ClassMetadata $rootClass;
42
43			private QueryBuilder $query;
44
45			private string $cacheKey;
46
47			private array $filters = [];
48
49			private array $mapper = [];
50
51			private array $strategies = [];
52
53			private array $types = [];
54
55			private ?int $cacheTime = null;
56
57			private bool $withOr = false;
58
59			private int $defaultCacheTime;
60
61			private string $separator;
62
63			public function __construct(
64			EntityManagerInterface $entityManager,
65			CacheInterface $cache,
66			FilterFactory $filterFactory,
67			$defaultCacheTime = self::DEFAULT_CACHE_TIME,
68			$separator = self::SEPARATOR
69			) {
70			$this->entityManager = $entityManager;
71			$this->cache = $cache;
72			$this->filterFactory = $filterFactory;
73			$this->defaultCacheTime = $defaultCacheTime;
74			$this->separator = $separator;
75			}
76
77			public function for(QueryBuilder $query): self
78			{
79			$this->initializeRootQueryConfig($query);
80
81			return $this;
82			}
83
84			/**
85			* @param $filters
86			*
87			* @return self
88			*
89			* @throws JsonException
90			*/
91			public function parameters($filters): self
92			{
93			if (empty($filters)) {
94			return $this;
95			}
96
97			if (!\is_array($filters)) {
98			throw new \InvalidArgumentException(
99			'Filter parameters should be an array type'
100			);
101			}
102
103			// Remove empty value from array
104			$this->filters = array_filter($filters, static function ($var) {
105			return null !== $var && '' !== $var;
106			});
107
108			// Create cache key by request
109			$this->createCacheKey($this->filters);
110
111			return $this;
112			}
113
114			/**
115			* @throws InvalidArgumentException
116			*/
117			public function filter(): QueryBuilder
118			{
119			// Early return if array is empty
120			if (empty($this->filters)) {
121			return $this->query;
122			}
123			// Calculate and cache fields.
124			[$filterParameters, $filterWhereClauses, $relationJoins] = $this->cache->get(
125			$this->cacheKey,
126			$this->addWhereClauses()
127			);
128
129			$this->applyRelationJoinToQuery($relationJoins);
130
131			$this->applyWhereClausesToQuery($filterWhereClauses);
132
133			$this->applyParametersToQuery($filterParameters);
134
135			return $this->query;
136			}
137
138			private function applyWhereClausesToQuery($filterWhereClauses): void
139			{
140			if (!empty($filterWhereClauses)) {
141			if ($this->withOr) {
142			$this->query->andWhere($this->query->expr()->orX()->addMultiple($filterWhereClauses));
143			} else {
144			$this->query->andWhere($this->query->expr()->andx()->addMultiple($filterWhereClauses));
145			}
146			}
147			}
148
149			private function applyParametersToQuery($filterParameters): void
150			{
151			foreach ($filterParameters as $parameterName => $parameterValue) {
152			$this->query->setParameter($parameterName, $parameterValue);
153			}
154			}
155
156			private function applyRelationJoinToQuery($relationJoins): void
157			{
158			// Remove exist joined from a list
159			$filteredJoins = array_diff($relationJoins, $this->query->getAllAliases());
160
161			// Add a left join to query which does not exist in the query
162			if (!empty($filteredJoins)) {
163			foreach ($filteredJoins as $property => $column) {
164			$this->query->addSelect($column);
165			$this->query->leftJoin($property, $column);
166			}
167			}
168			}
169
170			/**
171			* @param $array
172			*
173			* @throws JsonException
174			*/
175			private function createCacheKey($array): void
176			{
177			$this->cacheKey = md5($this->rootEntity.json_encode($array, \JSON_THROW_ON_ERROR));
178			}
179
180			/**
181			* @author Milad Ghofrani <[email protected]>
182			*/
183			private function addWhereClauses(): Closure
184			{
185			return function (CacheItemInterface $item) {
186			$item->expiresAfter($this->cacheTime ?: $this->defaultCacheTime);
187
188			$filterParameters = [];
189			$filterWhereClauses = [];
190			$relationJoins = [];
191
192			foreach ($this->filters as $parameter => $value) {
193			// Check user set a strategy for this $parameter
194			$strategy = $this->strategies[$parameter] ?? null;
195
196			// Check user set a type for this $parameter
197			$type = $this->types[$parameter] ?? null;
198
199			// Check $parameter exists in mapper
200			$parameter = (\array_key_exists($parameter, $this->mapper))
201			? $this->mapper[$parameter] : $parameter;
202
203			$relationsAndFieldName = explode($this->separator, $parameter);
204
205			$filteringHandler = $this->filterFactory->createFilterHandler($relationsAndFieldName);
206
207			$filterParameter = $filteringHandler->filterParameter(
208			$this->rootAlias,
209			$this->rootClass,
210			$relationsAndFieldName,
211			$type
212			);
213
214			if($type !== ColumnType::NULLABLE){
215			$filterParameters[$filterParameter] = $filteringHandler->filterValue($value, $strategy);
216			}
217
218			$filterWhereClauses[] = $filteringHandler->filterWhereClause(
219			$this->rootAlias,
220			$relationsAndFieldName,
221			$filterParameter,
222			$strategy,
223			$value
224			);
225
226			if ($filteringHandler instanceof WithRelationInterface) {
227			$relationJoins = $filteringHandler->relationJoin(
228			$relationJoins,
229			$this->rootAlias,
230			$this->rootClass,
231			$relationsAndFieldName
232			);
233			}
234			}
235
236			return [$filterParameters, $filterWhereClauses, $relationJoins];
237			};
238			}
239
240			private function initializeRootQueryConfig($query): void
241			{
242			$rootEntities = $query->getRootEntities();
243			$rootAliasArray = $query->getRootAliases();
244
245			if (!isset($rootEntities[0], $rootAliasArray[0])) {
246			throw new \InvalidArgumentException('Root Alias not defined correctly.');
247			}
248
249			$this->query = $query;
250			$this->rootAlias = $rootAliasArray[0];
251			$this->rootEntity = $rootEntities[0];
252			$this->rootClass = $this->entityManager->getClassMetadata($this->rootEntity);
253			}
254			}
255

bugloos / query-filter-bundle

Push — main ( 7ac0ad...a216bf )

QueryFilter::filter() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like