QueryFilter::getSimpleSearchBy() - Code Metrics - Inspection of "Simplify conditions in getFullSearchBy" - artprima/query-filter-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d72b98...60d9d9 )

by Denis

created 2018-03-11 09:30 UTC

QueryFilter::getSimpleSearchBy() B

↳ Parent: QueryFilter

Complexity

Conditions	5
Paths	4

Size

Total Lines	18
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	5.2742

Importance

Changes

Metric	Value
cc	5
eloc	8
nc	4
nop	2
dl	0
loc	18
ccs	7
cts	9
cp	0.7778
crap	5.2742
rs	8.8571
c	0
b	0
f	0

<?php declare(strict_types = 1);

namespace Artprima\QueryFilterBundle\QueryFilter;

use Artprima\QueryFilterBundle\Exception\InvalidArgumentException;
use Artprima\QueryFilterBundle\Query\Filter;
use Artprima\QueryFilterBundle\QueryFilter\Config\Alias;
use Artprima\QueryFilterBundle\QueryFilter\Config\ConfigInterface;
use Artprima\QueryFilterBundle\Response\ResponseInterface;

/**
 * Class QueryFilter
 *
 * @author Denis Voytyuk <[email protected]>
 */
class QueryFilter
{
    /**
     * @var string
     */
    private $responseClassName;

    /**
     * QueryFilter constructor.
     * @param string $responseClassName
     * @throws \ReflectionException
     * @throws InvalidArgumentException
     */
    public function __construct(string $responseClassName)
    {
        $refClass = new \ReflectionClass($responseClassName);
        if (!$refClass->implementsInterface(ResponseInterface::class)) {
            throw new InvalidArgumentException(sprintf(
                'Response class "%s" must implement "%s"',
                $responseClassName,
                ResponseInterface::class
            ));
        }

        $constructor = $refClass->getConstructor();
        if ($constructor !== null && $constructor->getNumberOfRequiredParameters() > 0) {
            throw new InvalidArgumentException(sprintf(
                'Response class "%s" must have a constructor without required parameters',
                $responseClassName
            ));
        }

        $this->responseClassName = $responseClassName;
    }

    /**
     * @param ConfigInterface $config
     * @return int current page number
     */
    private function getCurrentPage(ConfigInterface $config): int
    {
        $curPage = $config->getRequest()->getPageNum();

        if ($curPage < 1) {
            $curPage = 1;
        }

        return $curPage;
    }

    /**
     * @param ConfigInterface $config
     * @return array
     */
    private function getSortData(ConfigInterface $config): array
    {
        $sort = [
            'field' => $config->getRequest()->getSortBy(),
            'type' => $config->getRequest()->getSortDir(),
        ];
        $sortData = $config->getSortColsDefault();
        if (isset($sort['field'], $sort['type'])) {
            if (in_array($sort['type'], array('asc', 'desc'), true) && in_array($sort['field'], $config->getSortCols(), true)) {
                $sortData = array($sort['field'] => $sort['type']);
            }
        }

        return $sortData;
    }

    /**
     * @param string $field
     * @param array|string $val
     * @return Filter
     */
    private function getFilter(string $field, $val): Filter
    {
        $filter = new Filter();
        if (!is_array($val)) {
            $val = [
                'x' => $val,
                'type' => 'like',
            ];
        }

        $filter->setField($field);
        $filter->setType($val['type'] ?? 'like');
        $filter->setX($val['x'] ?? null);
        $filter->setY($val['y'] ?? null);
        $filter->setExtra($val['extra'] ?? null);
        $filter->setConnector($val['connector'] ?? 'and');
        $filter->setHaving((bool)($val['having'] ?? false));

        return $filter;
    }

    /**
     * @param array $allowedCols
     * @param array|null $search
     * @return Filter[]
     */
    private function getSimpleSearchBy(array $allowedCols, ?array $search): array
    {
        /** @var Filter[] $searchBy */
        $searchBy = [];

        if ($search === null) {
            return $searchBy;
        }

        foreach ($search as $key => $val) {
            if (!in_array($key, $allowedCols, true) || $val === null) {
                continue;
            }

            $searchBy[] = $this->getFilter($key, $val);
        }

        return $searchBy;
    }

    /**
     * @param array $allowedCols
     * @param array|null $search
     * @return Filter[]
     */
    private function getFullSearchBy(array $allowedCols, ?array $search): array
    {
        /** @var Filter[] $searchBy */
        $searchBy = [];

        if ($search === null) {
            return $searchBy;
        }

        foreach ($search as $key => $data) {
            if (!is_array($data) || !isset($data['field']) || !in_array($data['field'], $allowedCols, true)) {
                continue;
            }

            $searchBy[$key] = $this->getFilter($data['field'], $data);
        }

        return $searchBy;
    }

    /**
     * @param Filter[] $searchBy
     * @param Alias[] $aliases
     */
    private function replaceSearchByAliases(array $searchBy, array $aliases)
    {
        foreach ($searchBy as $filter) {
            if (array_key_exists($filter->getField(), $aliases)) {
                $filter->setField($aliases[$filter->getField()]->getExpr());
            }
        }
    }

    /**
     * Get searchby data prepared for query builder
     *
     * If simple, $search must be set to:
     * <code>
     *     $this->searchData = array(
     *         'column_name1' => 'search_value1',
     *         'column_name2' => 'search_value2',
     *     );
     * </code>
     * All comparisons will be treated as "like" here.
     *
     * If not simple, $search must be set to:
     * <code>
     *     $this->searchData = array(
     *         array('field' => 'column_name1', 'type' => 'like', 'val' => 'search_value1'),
     *         array('field' => 'column_name2', 'type' => 'eq', 'val' => 'search_value2'),
     *     );
     * </code>
     *
     * For both cases GroupConcat columns the result will receive extra $searchBy["column_name1"]["having"] = true
     *
     * @param ConfigInterface $config
     * @return array
     */
    private function getSearchBy(ConfigInterface $config): array
    {
        // Get basic search by
        $searchBy = $config->getRequest()->isSimple()
            ? $this->getSimpleSearchBy($config->getSearchAllowedCols(), $config->getRequest()->getQuery())
            : $this->getFullSearchBy($config->getSearchAllowedCols(), $config->getRequest()->getQuery());

        // Set search aliases to more complicated expressions
        $this->replaceSearchByAliases($searchBy, $config->getSearchByAliases());

        // Set search extra filters (can be used to display entries for one particular entity,
        // or to add some extra conditions/filterings)
        $searchBy = array_merge($searchBy, $config->getSearchByExtra());

        return $searchBy;
    }

    /**
     * @param ConfigInterface $config
     * @return QueryFilterArgs
     */
    private function getQueryFilterArgs(ConfigInterface $config): QueryFilterArgs
    {
        $searchBy = $this->getSearchBy($config);
        $currentPage = $this->getCurrentPage($config);
        $sortData = $this->getSortData($config);

        $limit = $config->getRequest()->getLimit();
        $allowedLimits = $config->getAllowedLimits();
        if ($limit === -1 || (!empty($allowedLimits) && !in_array($limit, $config->getAllowedLimits(), true))) {
            $limit = $config->getDefaultLimit();
        }

        $args = (new QueryFilterArgs())
            ->setSearchBy($searchBy)
            ->setSortBy($sortData)
            ->setLimit($limit)
            ->setOffset(($currentPage - 1) * $limit);

        return $args;
    }

    /**
     * @param ConfigInterface $config
     * @param QueryFilterArgs $args
     * @return QueryResult
     */
    private function getFilterData(ConfigInterface $config, QueryFilterArgs $args): QueryResult
    {
        // Query database to obtain corresponding entities
        $repositoryCallback = $config->getRepositoryCallback();

        // $repositoryCallback can be an array, but since PHP 7.0 it's possible to use it as a function directly
        // i.e. without using call_user_func[_array]().
        // For the reference: https://trowski.com/2015/06/20/php-callable-paradox/
        if (!\is_callable($repositoryCallback)) {
            throw new InvalidArgumentException('Repository callback is not callable');
        }

        $filterData = $repositoryCallback($args);

        return $filterData;
    }

    /**
     * Gets filtered data
     *
     * @param ConfigInterface $config
     * @return ResponseInterface
     */
    public function getData(ConfigInterface $config): ResponseInterface
    {
        $args = $this->getQueryFilterArgs($config);

        $startTime = microtime(true);
        $filterData = $this->getFilterData($config, $args);
        $duration = microtime(true) - $startTime;

        /** @var ResponseInterface $response */
        $response = new $this->responseClassName;
        $response->setData($filterData->getResult());
        $response->addMeta('total_records', $filterData->getTotalRows());
        $response->addMeta('metrics', array(
            'query_and_transformation' => $duration,
        ));

        return $response;
    }
}


1		<?php declare(strict_types = 1);
2
3		namespace Artprima\QueryFilterBundle\QueryFilter;
4
5		use Artprima\QueryFilterBundle\Exception\InvalidArgumentException;
6		use Artprima\QueryFilterBundle\Query\Filter;
7		use Artprima\QueryFilterBundle\QueryFilter\Config\Alias;
8		use Artprima\QueryFilterBundle\QueryFilter\Config\ConfigInterface;
9		use Artprima\QueryFilterBundle\Response\ResponseInterface;
10
11		/**
12		* Class QueryFilter
13		*
14		* @author Denis Voytyuk <[email protected]>
15		*/
16		class QueryFilter
17		{
18		/**
19		* @var string
20		*/
21		private $responseClassName;
22
23		/**
24		* QueryFilter constructor.
25		* @param string $responseClassName
26		* @throws \ReflectionException
27		* @throws InvalidArgumentException
28		*/
29	5	public function __construct(string $responseClassName)
30		{
31	5	$refClass = new \ReflectionClass($responseClassName);
32	5	if (!$refClass->implementsInterface(ResponseInterface::class)) {
33	1	throw new InvalidArgumentException(sprintf(
34	1	'Response class "%s" must implement "%s"',
35	1	$responseClassName,
36	1	ResponseInterface::class
37		));
38		}
39
40	4	$constructor = $refClass->getConstructor();
41	4	if ($constructor !== null && $constructor->getNumberOfRequiredParameters() > 0) {
42	1	throw new InvalidArgumentException(sprintf(
43	1	'Response class "%s" must have a constructor without required parameters',
44	1	$responseClassName
45		));
46		}
47
48	3	$this->responseClassName = $responseClassName;
49	3	}
50
51		/**
52		* @param ConfigInterface $config
53		* @return int current page number
54		*/
55	3	private function getCurrentPage(ConfigInterface $config): int
56		{
57	3	$curPage = $config->getRequest()->getPageNum();
58
59	3	if ($curPage < 1) {
60		$curPage = 1;
61		}
62
63	3	return $curPage;
64		}
65
66		/**
67		* @param ConfigInterface $config
68		* @return array
69		*/
70	3	private function getSortData(ConfigInterface $config): array
71		{
72		$sort = [
73	3	'field' => $config->getRequest()->getSortBy(),
74	3	'type' => $config->getRequest()->getSortDir(),
75		];
76	3	$sortData = $config->getSortColsDefault();
77	3	if (isset($sort['field'], $sort['type'])) {
78	3	if (in_array($sort['type'], array('asc', 'desc'), true) && in_array($sort['field'], $config->getSortCols(), true)) {
79	3	$sortData = array($sort['field'] => $sort['type']);
80		}
81		}
82
83	3	return $sortData;
84		}
85
86		/**
87		* @param string $field
88		* @param array\|string $val
89		* @return Filter
90		*/
91	3	private function getFilter(string $field, $val): Filter
92		{
93	3	$filter = new Filter();
94	3	if (!is_array($val)) {
95		$val = [
96	1	'x' => $val,
97	1	'type' => 'like',
98		];
99		}
100
101	3	$filter->setField($field);
102	3	$filter->setType($val['type'] ?? 'like');
103	3	$filter->setX($val['x'] ?? null);
104	3	$filter->setY($val['y'] ?? null);
105	3	$filter->setExtra($val['extra'] ?? null);
106	3	$filter->setConnector($val['connector'] ?? 'and');
107	3	$filter->setHaving((bool)($val['having'] ?? false));
108
109	3	return $filter;
110		}
111
112		/**
113		* @param array $allowedCols
114		* @param array\|null $search
115		* @return Filter[]
116		*/
117	1	private function getSimpleSearchBy(array $allowedCols, ?array $search): array
118		{
119		/** @var Filter[] $searchBy */
120	1	$searchBy = [];
121
122	1	if ($search === null) {
123		return $searchBy;
124		}
125
126	1	foreach ($search as $key => $val) {
127	1	if (!in_array($key, $allowedCols, true) \|\| $val === null) {
128		continue;
129		}
130
131	1	$searchBy[] = $this->getFilter($key, $val);
132		}
133
134	1	return $searchBy;
135		}
136
137		/**
138		* @param array $allowedCols
139		* @param array\|null $search
140		* @return Filter[]
141		*/
142	2	private function getFullSearchBy(array $allowedCols, ?array $search): array
143		{
144		/** @var Filter[] $searchBy */
145	2	$searchBy = [];
146
147	2	if ($search === null) {
148		return $searchBy;
149		}
150
151	2	foreach ($search as $key => $data) {
152	2	if (!is_array($data) \|\| !isset($data['field']) \|\| !in_array($data['field'], $allowedCols, true)) {
153		continue;
154		}
155
156	2	$searchBy[$key] = $this->getFilter($data['field'], $data);
157		}
158
159	2	return $searchBy;
160		}
161
162		/**
163		* @param Filter[] $searchBy
164		* @param Alias[] $aliases
165		*/
166	3	private function replaceSearchByAliases(array $searchBy, array $aliases)
167		{
168	3	foreach ($searchBy as $filter) {
169	3	if (array_key_exists($filter->getField(), $aliases)) {
170	3	$filter->setField($aliases[$filter->getField()]->getExpr());
171		}
172		}
173	3	}
174
175		/**
176		* Get searchby data prepared for query builder
177		*
178		* If simple, $search must be set to:
179		* <code>
180		* $this->searchData = array(
181		* 'column_name1' => 'search_value1',
182		* 'column_name2' => 'search_value2',
183		* );
184		* </code>
185		* All comparisons will be treated as "like" here.
186		*
187		* If not simple, $search must be set to:
188		* <code>
189		* $this->searchData = array(
190		* array('field' => 'column_name1', 'type' => 'like', 'val' => 'search_value1'),
191		* array('field' => 'column_name2', 'type' => 'eq', 'val' => 'search_value2'),
192		* );
193		* </code>
194		*
195		* For both cases GroupConcat columns the result will receive extra $searchBy["column_name1"]["having"] = true
196		*
197		* @param ConfigInterface $config
198		* @return array
199		*/
200	3	private function getSearchBy(ConfigInterface $config): array
201		{
202		// Get basic search by
203	3	$searchBy = $config->getRequest()->isSimple()
204	1	? $this->getSimpleSearchBy($config->getSearchAllowedCols(), $config->getRequest()->getQuery())
205	3	: $this->getFullSearchBy($config->getSearchAllowedCols(), $config->getRequest()->getQuery());
206
207		// Set search aliases to more complicated expressions
208	3	$this->replaceSearchByAliases($searchBy, $config->getSearchByAliases());
209
210		// Set search extra filters (can be used to display entries for one particular entity,
211		// or to add some extra conditions/filterings)
212	3	$searchBy = array_merge($searchBy, $config->getSearchByExtra());
213
214	3	return $searchBy;
215		}
216
217		/**
218		* @param ConfigInterface $config
219		* @return QueryFilterArgs
220		*/
221	3	private function getQueryFilterArgs(ConfigInterface $config): QueryFilterArgs
222		{
223	3	$searchBy = $this->getSearchBy($config);
224	3	$currentPage = $this->getCurrentPage($config);
225	3	$sortData = $this->getSortData($config);
226
227	3	$limit = $config->getRequest()->getLimit();
228	3	$allowedLimits = $config->getAllowedLimits();
229	3	if ($limit === -1 \|\| (!empty($allowedLimits) && !in_array($limit, $config->getAllowedLimits(), true))) {
230		$limit = $config->getDefaultLimit();
231		}
232
233	3	$args = (new QueryFilterArgs())
234	3	->setSearchBy($searchBy)
235	3	->setSortBy($sortData)
236	3	->setLimit($limit)
237	3	->setOffset(($currentPage - 1) * $limit);
238
239	3	return $args;
240		}
241
242		/**
243		* @param ConfigInterface $config
244		* @param QueryFilterArgs $args
245		* @return QueryResult
246		*/
247	3	private function getFilterData(ConfigInterface $config, QueryFilterArgs $args): QueryResult
248		{
249		// Query database to obtain corresponding entities
250	3	$repositoryCallback = $config->getRepositoryCallback();
251
252		// $repositoryCallback can be an array, but since PHP 7.0 it's possible to use it as a function directly
253		// i.e. without using call_user_func[_array]().
254		// For the reference: https://trowski.com/2015/06/20/php-callable-paradox/
255	3	if (!\is_callable($repositoryCallback)) {
256		throw new InvalidArgumentException('Repository callback is not callable');
257		}
258
259	3	$filterData = $repositoryCallback($args);
260
261	3	return $filterData;
262		}
263
264		/**
265		* Gets filtered data
266		*
267		* @param ConfigInterface $config
268		* @return ResponseInterface
269		*/
270	3	public function getData(ConfigInterface $config): ResponseInterface
271		{
272	3	$args = $this->getQueryFilterArgs($config);
273
274	3	$startTime = microtime(true);
275	3	$filterData = $this->getFilterData($config, $args);
276	3	$duration = microtime(true) - $startTime;
277
278		/** @var ResponseInterface $response */
279	3	$response = new $this->responseClassName;
280	3	$response->setData($filterData->getResult());
281	3	$response->addMeta('total_records', $filterData->getTotalRows());
282	3	$response->addMeta('metrics', array(
283	3	'query_and_transformation' => $duration,
284		));
285
286	3	return $response;
287		}
288		}
289

artprima / query-filter-bundle

Push — master ( d72b98...60d9d9 )

QueryFilter::getSimpleSearchBy() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like