CriteriaQueryBuilder::orderByDefaultField() - Code Metrics - Inspection of "PC-5691 Limit of set sorting" - paycoreio/criteria-query-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#15)

unknown

created 2021-03-01 13:52 UTC

CriteriaQueryBuilder::orderByDefaultField() A

↳ Parent: CriteriaQueryBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Paymaxi\Component\Query;

use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\EntityRepository;
use Paymaxi\Component\Query\Filter\FilterInterface;
use Paymaxi\Component\Query\Handler\AbstractHandler;
use Paymaxi\Component\Query\Handler\CriteriaHandler;
use Paymaxi\Component\Query\Handler\FilterHandlerInterface;
use Paymaxi\Component\Query\Handler\HandlerInterface;
use Paymaxi\Component\Query\Handler\QueryBuilderHandler;
use Paymaxi\Component\Query\Handler\SortHandlerInterface;
use Paymaxi\Component\Query\Sort\SortInterface;
use Sylius\Component\Registry\ServiceRegistry;

/**
 * Class CriteriaQueryBuilder
 *
 */
class CriteriaQueryBuilder implements CriteriaQueryBuilderInterface
{
    /** @var Criteria */
    protected $criteria;

    /** @var \Doctrine\ORM\QueryBuilder */
    protected $qb;

    /** @var array */
    private $filterParams;

    /** @var array */
    private $sortingFields;

    /** @var array */
    private $defaultOrder;

    /** @var ServiceRegistry|HandlerInterface[]|AbstractHandler[] */
    private $handlers;

    /** @var bool */
    private $applied = false;

    public const DEFAULT_ORDER_FIELD = 'created';

    private $supportedSortingFields = [];

    /**
     * @param EntityRepository $repository
     * @param array $filterParams
     * @param array $sortingFields
     *
     * @internal param ApiManagerInterface $manager
     */
    public function __construct(EntityRepository $repository, array $filterParams = [], array $sortingFields = [])
    {
        $this->qb = $repository->createQueryBuilder('e');
        $this->criteria = new Criteria();
        $this->handlers = new ServiceRegistry(HandlerInterface::class);

        $this->initDefaultHandlers();
        $this->setFilterParams($filterParams);
        $this->setSortingFields($sortingFields);
    }

    protected function initDefaultHandlers(): void
    {
        $this->handlers->register(CriteriaHandler::class, new CriteriaHandler($this->criteria));
        $this->handlers->register(QueryBuilderHandler::class, new QueryBuilderHandler($this->qb));
    }

    /**
     * @param FilterInterface $filter
     *
     * @return CriteriaQueryBuilderInterface
     */
    public function addFilter(FilterInterface $filter): CriteriaQueryBuilderInterface
    {
        $supports = false;

        /** @var AbstractHandler $handler */
        foreach ($this->handlers->all() as $handler) {
            if ($handler instanceof FilterHandlerInterface && $handler->supports($filter)) {
                $supports = true;
                $handler->addFilter($filter);
            }
        }

        if (!$supports) {
            throw new \RuntimeException('No available handler for this filter.');
        }

        $this->resetApply();

        return $this;
    }

    protected function resetApply():void
    {
        $this->applied = false;
    }

    /**
     * @param SortInterface $sort
     *
     * @return CriteriaQueryBuilderInterface
     */
    public function addSorting(SortInterface $sort): CriteriaQueryBuilderInterface
    {
        $supports = false;

        /** @var AbstractHandler $handler */
        foreach ($this->handlers->all() as $handler) {
            if ($handler instanceof SortHandlerInterface && $handler->supports($sort)) {
                $supports = true;
                $handler->addSorting($sort);
                $this->supportedSortingFields[] = $sort->getFieldName();
            }
        }

        if (!$supports) {
            throw new \RuntimeException('No available handler for this sorting.');
        }

        $this->resetApply();

        return $this;
    }

    /**
     * @return \Doctrine\ORM\QueryBuilder
     * @throws \Doctrine\ORM\Query\QueryException
     */
    public function getQb(): \Doctrine\ORM\QueryBuilder
    {
        $clone = clone $this;
        $clone->apply();

        return $clone->qb->addCriteria($clone->getCriteria());
    }

    /**
     * It caused changes in qb and criteria
     */
    protected function apply(): void
    {
        if ($this->applied) {
            return;
        }

        if (0 === \count($this->sortingFields)) {
            $this->criteria->orderBy($this->getDefaultOrder());
        }
        else {
            if(!isset($this->sortingFields[self::DEFAULT_ORDER_FIELD])) {
                $this->sortingFields = array_merge($this->sortingFields, $this->orderByDefaultField());
            }
        }

        $this->applySorting();
        $this->applyFilters();

        $this->applied = true;
    }

    /**
     * @return Criteria
     */
    public function getCriteria(): Criteria
    {
        $this->apply();

        return $this->criteria;
    }

    private function applyFilters()
    {
        foreach ($this->filterParams as $field => $value) {
            foreach ($this->handlers->all() as $handler) {
                if ($handler instanceof FilterHandlerInterface) {
                    $handler->filter($field, $value);
                }
            }
        }
    }

    private function applySorting()
    {
        foreach ($this->sortingFields as $field => $order) {
            foreach ($this->handlers->all() as $handler) {
                if ($handler instanceof SortHandlerInterface) {
                    $handler->sort($field, $order);
                }
            }
        }
    }

    /**
     * @return array
     */
    public function getDefaultOrder(): array
    {
        $order = $this->defaultOrder ?? [];
        if(in_array(self::DEFAULT_ORDER_FIELD, $this->supportedSortingFields) &&
            !isset($order[self::DEFAULT_ORDER_FIELD])) {
            $order = array_merge($order, $this->orderByDefaultField());
        }
        return $order;
    }

    /**
     * @param array $defaultOrder
     */
    public function setDefaultOrder(array $defaultOrder): void
    {
        $this->defaultOrder = $defaultOrder;
    }

    /**
     * @param array $filterParams
     */
    public function setFilterParams(array $filterParams)
    {
        $this->resetApply();

        $this->filterParams = $filterParams;
    }

    /**
     * @param array $sortingFields
     */
    public function setSortingFields(array $sortingFields)
    {
        $this->resetApply();
        
        $this->sortingFields = $sortingFields;
    }

    /**
     * @return ServiceRegistry
     */
    public function getHandlers():ServiceRegistry
    {
        return $this->handlers;
    }

    /**
     * @param string $identifier
     * @param HandlerInterface $handler
     */
    public function addHandler(string $identifier, HandlerInterface $handler):void
    {
        $this->handlers->register($identifier, $handler);
    }

    public function getSupportedSortingFields() : array
    {
        return $this->supportedSortingFields;
    }

    private function orderByDefaultField() : array
    {
        return [self::DEFAULT_ORDER_FIELD => 'DESC'];
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Paymaxi\Component\Query;
6
7		use Doctrine\Common\Collections\Criteria;
8		use Doctrine\ORM\EntityRepository;
9		use Paymaxi\Component\Query\Filter\FilterInterface;
10		use Paymaxi\Component\Query\Handler\AbstractHandler;
11		use Paymaxi\Component\Query\Handler\CriteriaHandler;
12		use Paymaxi\Component\Query\Handler\FilterHandlerInterface;
13		use Paymaxi\Component\Query\Handler\HandlerInterface;
14		use Paymaxi\Component\Query\Handler\QueryBuilderHandler;
15		use Paymaxi\Component\Query\Handler\SortHandlerInterface;
16		use Paymaxi\Component\Query\Sort\SortInterface;
17		use Sylius\Component\Registry\ServiceRegistry;
18
19		/**
20		* Class CriteriaQueryBuilder
21		*
22		*/
23		class CriteriaQueryBuilder implements CriteriaQueryBuilderInterface
24		{
25		/** @var Criteria */
26		protected $criteria;
27
28		/** @var \Doctrine\ORM\QueryBuilder */
29		protected $qb;
30
31		/** @var array */
32		private $filterParams;
33
34		/** @var array */
35		private $sortingFields;
36
37		/** @var array */
38		private $defaultOrder;
39
40		/** @var ServiceRegistry\|HandlerInterface[]\|AbstractHandler[] */
41		private $handlers;
42
43		/** @var bool */
44		private $applied = false;
45
46		public const DEFAULT_ORDER_FIELD = 'created';
47
48		private $supportedSortingFields = [];
49
50		/**
51		* @param EntityRepository $repository
52		* @param array $filterParams
53	4	* @param array $sortingFields
54		*
55	4	* @internal param ApiManagerInterface $manager
56	4	*/
57	4	public function __construct(EntityRepository $repository, array $filterParams = [], array $sortingFields = [])
58		{
59	4	$this->qb = $repository->createQueryBuilder('e');
60	4	$this->criteria = new Criteria();
61	4	$this->handlers = new ServiceRegistry(HandlerInterface::class);
62	4
63		$this->initDefaultHandlers();
64	4	$this->setFilterParams($filterParams);
65		$this->setSortingFields($sortingFields);
66	4	}
67	4
68	4	protected function initDefaultHandlers(): void
69		{
70		$this->handlers->register(CriteriaHandler::class, new CriteriaHandler($this->criteria));
71		$this->handlers->register(QueryBuilderHandler::class, new QueryBuilderHandler($this->qb));
72		}
73
74		/**
75	4	* @param FilterInterface $filter
76		*
77	4	* @return CriteriaQueryBuilderInterface
78		*/
79		public function addFilter(FilterInterface $filter): CriteriaQueryBuilderInterface
80	4	{
81	4	$supports = false;
82	4
83	4	/** @var AbstractHandler $handler */
84		foreach ($this->handlers->all() as $handler) {
85		if ($handler instanceof FilterHandlerInterface && $handler->supports($filter)) {
86		$supports = true;
87	4	$handler->addFilter($filter);
88		}
89		}
90
91	4	if (!$supports) {
92		throw new \RuntimeException('No available handler for this filter.');
93	4	}
94
95		$this->resetApply();
96	4
97		return $this;
98	4	}
99	4
100		protected function resetApply():void
101		{
102		$this->applied = false;
103		}
104
105		/**
106		* @param SortInterface $sort
107		*
108		* @return CriteriaQueryBuilderInterface
109		*/
110		public function addSorting(SortInterface $sort): CriteriaQueryBuilderInterface
111		{
112		$supports = false;
113
114		/** @var AbstractHandler $handler */
115		foreach ($this->handlers->all() as $handler) {
116		if ($handler instanceof SortHandlerInterface && $handler->supports($sort)) {
117		$supports = true;
118		$handler->addSorting($sort);
119		$this->supportedSortingFields[] = $sort->getFieldName();
120		}
121		}
122
123		if (!$supports) {
124		throw new \RuntimeException('No available handler for this sorting.');
125		}
126
127		$this->resetApply();
128
129		return $this;
130		}
131	3
132		/**
133	3	* @return \Doctrine\ORM\QueryBuilder
134	3	* @throws \Doctrine\ORM\Query\QueryException
135		*/
136	3	public function getQb(): \Doctrine\ORM\QueryBuilder
137		{
138		$clone = clone $this;
139		$clone->apply();
140
141		return $clone->qb->addCriteria($clone->getCriteria());
142	4	}
143
144	4	/**
145	3	* It caused changes in qb and criteria
146		*/
147		protected function apply(): void
148	4	{
149	4	if ($this->applied) {
150		return;
151		}
152	4
153	4	if (0 === \count($this->sortingFields)) {
154		$this->criteria->orderBy($this->getDefaultOrder());
155	4	}
156	4	else {
157		if(!isset($this->sortingFields[self::DEFAULT_ORDER_FIELD])) {
158		$this->sortingFields = array_merge($this->sortingFields, $this->orderByDefaultField());
159		}
160		}
161	4
162		$this->applySorting();
163	4	$this->applyFilters();
164
165	4	$this->applied = true;
166		}
167
168	4	/**
169		* @return Criteria
170	4	*/
171	3	public function getCriteria(): Criteria
172	3	{
173	3	$this->apply();
174
175		return $this->criteria;
176		}
177	4
178		private function applyFilters()
179	4	{
180		foreach ($this->filterParams as $field => $value) {
181	4	foreach ($this->handlers->all() as $handler) {
182		if ($handler instanceof FilterHandlerInterface) {
183		$handler->filter($field, $value);
184		}
185		}
186		}
187		}
188	4
189		private function applySorting()
190		{
191		foreach ($this->sortingFields as $field => $order) {
192		foreach ($this->handlers->all() as $handler) {
193	4	if ($handler instanceof SortHandlerInterface) {
194		$handler->sort($field, $order);
195	4	}
196		}
197		}
198		}
199
200		/**
201	4	* @return array
202		*/
203	4	public function getDefaultOrder(): array
204	4	{
205		$order = $this->defaultOrder ?? [];
206		if(in_array(self::DEFAULT_ORDER_FIELD, $this->supportedSortingFields) &&
207		!isset($order[self::DEFAULT_ORDER_FIELD])) {
208		$order = array_merge($order, $this->orderByDefaultField());
209	4	}
210		return $order;
211	4	}
212
213	4	/**
214	4	* @param array $defaultOrder
215		*/
216		public function setDefaultOrder(array $defaultOrder): void
217		{
218		$this->defaultOrder = $defaultOrder;
219	4	}
220
221	4	/**
222		* @param array $filterParams
223	4	*/
224	4	public function setFilterParams(array $filterParams)
225		{
226		$this->resetApply();
227
228		$this->filterParams = $filterParams;
229		}
230
231		/**
232		* @param array $sortingFields
233		*/
234		public function setSortingFields(array $sortingFields)
235		{
236		$this->resetApply();
237
238		$this->sortingFields = $sortingFields;
239		}
240
241		/**
242		* @return ServiceRegistry
243		*/
244		public function getHandlers():ServiceRegistry
245		{
246		return $this->handlers;
247		}
248
249		/**
250		* @param string $identifier
251		* @param HandlerInterface $handler
252		*/
253		public function addHandler(string $identifier, HandlerInterface $handler):void
254		{
255		$this->handlers->register($identifier, $handler);
256		}
257
258		public function getSupportedSortingFields() : array
259		{
260		return $this->supportedSortingFields;
261		}
262
263		private function orderByDefaultField() : array
264		{
265		return [self::DEFAULT_ORDER_FIELD => 'DESC'];
266		}
267		}
268

paycoreio / criteria-query-builder

Pull Request — master (#15)

CriteriaQueryBuilder::orderByDefaultField() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like