DynamicAggregateFilter::getOptionUrlParameters() - Code Metrics - Inspection of "[WIP] Dynamic aggregate filter" - ongr-io/FilterManagerBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#188)

unknown

created 2016-09-06 05:32 UTC

DynamicAggregateFilter::getOptionUrlParameters() A

↳ Parent: DynamicAggregateFilter

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	2

Metric	Value
c	2
b	0
f	2
dl	0
loc	7
rs	9.4285
cc	1
eloc	4
nc	1
nop	2

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\FilterManagerBundle\Filter\Widget\Dynamic;

use ONGR\ElasticsearchBundle\Result\Aggregation\AggregationValue;
use ONGR\ElasticsearchDSL\Aggregation\FilterAggregation;
use ONGR\ElasticsearchDSL\Aggregation\NestedAggregation;
use ONGR\ElasticsearchDSL\Aggregation\TermsAggregation;
use ONGR\ElasticsearchDSL\BuilderInterface;
use ONGR\ElasticsearchDSL\Query\BoolQuery;
use ONGR\ElasticsearchDSL\Query\NestedQuery;
use ONGR\ElasticsearchDSL\Query\TermQuery;
use ONGR\ElasticsearchDSL\Query\TermsQuery;
use ONGR\ElasticsearchDSL\Search;
use ONGR\ElasticsearchBundle\Result\DocumentIterator;
use ONGR\FilterManagerBundle\Filter\FilterState;
use ONGR\FilterManagerBundle\Filter\Helper\SizeAwareTrait;
use ONGR\FilterManagerBundle\Filter\Helper\ViewDataFactoryInterface;
use ONGR\FilterManagerBundle\Filter\ViewData\AggregateViewData;
use ONGR\FilterManagerBundle\Filter\ViewData;
use ONGR\FilterManagerBundle\Filter\Widget\AbstractSingleRequestValueFilter;
use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareInterface;
use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareTrait;
use ONGR\FilterManagerBundle\Search\SearchRequest;
use Symfony\Component\HttpFoundation\Request;

/**
 * This class provides single terms choice.
 */
class DynamicAggregateFilter extends AbstractSingleRequestValueFilter implements FieldAwareInterface, ViewDataFactoryInterface
{
    use FieldAwareTrait, SizeAwareTrait;

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

    /**
     * @var string
     */
    private $nameField;

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

    /**
     * @param array $sortType
     */
    public function setSortType($sortType)
    {
        $this->sortType = $sortType;
    }

    /**
     * @return array
     */
    public function getSortType()
    {
        return $this->sortType;
    }

    /**
     * @return string
     */
    public function getNameField()
    {
        return $this->nameField;
    }

    /**
     * @param string $nameField
     */
    public function setNameField($nameField)
    {
        $this->nameField = $nameField;
    }

    /**
     * {@inheritdoc}
     */
    public function modifySearch(Search $search, FilterState $state = null, SearchRequest $request = null)
    {
        list($path, $field) = explode('>', $this->getField());

        if ($state && $state->isActive()) {
            $boolQuery = new BoolQuery();
            foreach ($state->getValue() as $value) {
                $boolQuery->add(
                    new NestedQuery(
                        $path,
                        new TermQuery($field, $value)
                    )
                );
            }
            $search->addPostFilter($boolQuery);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function preProcessSearch(Search $search, Search $relatedSearch, FilterState $state = null)
    {
        list($path, $field) = explode('>', $this->getField());
        $name = $state->getName();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
        $aggregation = new NestedAggregation(
            $name,
            $path
        );
        $termsAggregation = new TermsAggregation('query', $field);
        $termsAggregation->addParameter('size', 0);

        if ($this->getSortType()) {
            $termsAggregation->addParameter('order', [$this->getSortType()['type'] => $this->getSortType()['order']]);
        }

        if ($this->getSize() > 0) {
            $termsAggregation->addParameter('size', $this->getSize());
        }

        $termsAggregation->addAggregation(
            new TermsAggregation('name', $this->getNameField())
        );
        $aggregation->addAggregation($termsAggregation);
        $filterAggregation = new FilterAggregation($name . '-filter');
        $filterAggregation->setFilter($relatedSearch->getPostFilters());

        if ($state->isActive()) {
            $this->valueArray = $state->getValue();

            foreach ($state->getValue() as $key => $term) {
                $terms = $state->getValue();
                array_splice($terms, $key, 1);

                if (!count($terms)) {
                    break;
                }

                $this->addSubFilterAggregation(
                    $filterAggregation,
                    $aggregation,
                    $terms,
                    $term
                );
            }

            $this->addSubFilterAggregation(
                $filterAggregation,
                $aggregation,
                $state->getValue(),
                'all-selected'
            );
        } else {
            $filterAggregation->addAggregation($aggregation);
        }

        $search->addAggregation($filterAggregation);
    }

    /**
     * {@inheritdoc}
     */
    public function createViewData()
    {
        return new AggregateViewData();
    }

    /**
     * {@inheritdoc}
     */
    public function getViewData(DocumentIterator $result, ViewData $data)
    {
        $unsortedChoices = [];

        /** @var AggregationValue $bucket */
        foreach ($this->fetchAggregation($result, $data->getName()) as $bucket) {
            $active = $this->isChoiceActive($bucket['key'], $data);
            $choice = new ViewData\Choice();
            $choice->setLabel($bucket->getValue('key'));
            $choice->setCount($bucket['doc_count']);
            $choice->setActive($active);
            if ($active) {

                $choice->setUrlParameters($this->getUnsetUrlParameters($bucket['key'], $data));
            } else {
                $choice->setUrlParameters($this->getOptionUrlParameters($bucket['key'], $data));
            }
            $unsortedChoices[$bucket->getAggregation('name')->getBuckets()[0]['key']][] = $choice;
        }

        /** @var AggregateViewData $data */
        foreach ($unsortedChoices as $name => $choices) {
            $choiceViewData = new ViewData\ChoicesAwareViewData();
            $choiceViewData->setName($name);
            $choiceViewData->setChoices($choices);
            $choiceViewData->setUrlParameters([]);
            $choiceViewData->setResetUrlParameters([]);
            $data->addItem($choiceViewData);
        }

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function isRelated()
    {
        return true;
    }

    /**
     * Fetches buckets from search results.
     *
     * @param DocumentIterator $result Search results.
     * @param string           $name   Filter name.
     *
     * @return array Buckets.
     */
    private function fetchAggregation(DocumentIterator $result, $name)
    {
        $data = [];
        $aggregation = $result->getAggregation(sprintf('%s-filter', $name));

        if ($result->getAggregation($name)) {
            $aggregation = $aggregation->find($name.'.query');
            $data['unfiltered'] = $aggregation;

            return $data;
        }

        if (isset($this->valueArray)) {
            foreach ($this->valueArray as $value) {
                $data[$value] = $aggregation->find($value.'.query');
            }

            $data['all-selected'] = $aggregation->find('all-selected.query');

            return $data;
        }

        return [];
    }

    /**
     * A method used to add an additional filter to the aggregations
     * in preProcessSearch
     *
     * @param FilterAggregation $filterAggregation
     * @param NestedAggregation $deepLevelAggregation
     * @param array             $terms Terms of additional filter
     * @param string            $aggName
     *
     * @return BuilderInterface
     */
    private function addSubFilterAggregation(
        $filterAggregation,
        $deepLevelAggregation,
        $terms,
        $aggName
    ) {
        list($path, $field) = explode('>', $this->getField());
        $innerFilterAggregation = new FilterAggregation(
            $aggName,
            new NestedQuery(
                $path,
                new TermsQuery($field, $terms)
            )
        );
        $innerFilterAggregation->addAggregation($deepLevelAggregation);
        $filterAggregation->addAggregation($innerFilterAggregation);
    }

    /**
     * @param string   $key
     * @param ViewData $data
     *
     * @return array
     */
    private function getOptionUrlParameters($key, ViewData $data)
    {
        $parameters = $data->getResetUrlParameters();
        $parameters[$this->getRequestField()][] = $key;

        return $parameters;
    }

    /**
     * Returns url with selected term disabled.
     *
     * @param string   $key
     * @param ViewData $data
     *
     * @return array
     */
    private function getUnsetUrlParameters($key, ViewData $data)

    {
        return $data->getResetUrlParameters();
    }

    /**
     * Returns whether choice with the specified key is active.
     *
     * @param string   $key
     * @param ViewData $data
     *
     * @return bool
     */
    private function isChoiceActive($key, ViewData $data)
    {
        return $data->getState()->isActive() && in_array($key, $data->getState()->getValue());
    }
}


1		<?php
2
3		/*
4		* This file is part of the ONGR package.
5		*
6		* (c) NFQ Technologies UAB <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace ONGR\FilterManagerBundle\Filter\Widget\Dynamic;
13
14		use ONGR\ElasticsearchBundle\Result\Aggregation\AggregationValue;
15		use ONGR\ElasticsearchDSL\Aggregation\FilterAggregation;
16		use ONGR\ElasticsearchDSL\Aggregation\NestedAggregation;
17		use ONGR\ElasticsearchDSL\Aggregation\TermsAggregation;
18		use ONGR\ElasticsearchDSL\BuilderInterface;
19		use ONGR\ElasticsearchDSL\Query\BoolQuery;
20		use ONGR\ElasticsearchDSL\Query\NestedQuery;
21		use ONGR\ElasticsearchDSL\Query\TermQuery;
22		use ONGR\ElasticsearchDSL\Query\TermsQuery;
23		use ONGR\ElasticsearchDSL\Search;
24		use ONGR\ElasticsearchBundle\Result\DocumentIterator;
25		use ONGR\FilterManagerBundle\Filter\FilterState;
26		use ONGR\FilterManagerBundle\Filter\Helper\SizeAwareTrait;
27		use ONGR\FilterManagerBundle\Filter\Helper\ViewDataFactoryInterface;
28		use ONGR\FilterManagerBundle\Filter\ViewData\AggregateViewData;
29		use ONGR\FilterManagerBundle\Filter\ViewData;
30		use ONGR\FilterManagerBundle\Filter\Widget\AbstractSingleRequestValueFilter;
31		use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareInterface;
32		use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareTrait;
33		use ONGR\FilterManagerBundle\Search\SearchRequest;
34		use Symfony\Component\HttpFoundation\Request;
35
36		/**
37		* This class provides single terms choice.
38		*/
39		class DynamicAggregateFilter extends AbstractSingleRequestValueFilter implements FieldAwareInterface, ViewDataFactoryInterface
40		{
41		use FieldAwareTrait, SizeAwareTrait;
42
43		/**
44		* @var array
45		*/
46		private $sortType;
47
48		/**
49		* @var string
50		*/
51		private $nameField;
52
53		/**
54		* @var array
55		*/
56		private $valueArray;
57
58		/**
59		* @param array $sortType
60		*/
61		public function setSortType($sortType)
62		{
63		$this->sortType = $sortType;
64		}
65
66		/**
67		* @return array
68		*/
69		public function getSortType()
70		{
71		return $this->sortType;
72		}
73
74		/**
75		* @return string
76		*/
77		public function getNameField()
78		{
79		return $this->nameField;
80		}
81
82		/**
83		* @param string $nameField
84		*/
85		public function setNameField($nameField)
86		{
87		$this->nameField = $nameField;
88		}
89
90		/**
91		* {@inheritdoc}
92		*/
93		public function modifySearch(Search $search, FilterState $state = null, SearchRequest $request = null)
94		{
95		list($path, $field) = explode('>', $this->getField());
96
97		if ($state && $state->isActive()) {
98		$boolQuery = new BoolQuery();
99		foreach ($state->getValue() as $value) {
100		$boolQuery->add(
101		new NestedQuery(
102		$path,
103		new TermQuery($field, $value)
104		)
105		);
106		}
107		$search->addPostFilter($boolQuery);
108		}
109		}
110
111		/**
112		* {@inheritdoc}
113		*/
114		public function preProcessSearch(Search $search, Search $relatedSearch, FilterState $state = null)
115		{
116		list($path, $field) = explode('>', $this->getField());
117		$name = $state->getName();
		0 ignored issues – show Bug introduced 2016-09-06 06:35 UTC by Report Bug Copy Issue Report It seems like `$state` is not always an object, but can also be of type `null`. Maybe add an additional type check? If a variable is not always an object, we recommend to add an additional type check to ensure your method call is safe: function someFunction(A $objectMaybe = null) { if ($objectMaybe instanceof A) { $objectMaybe->doSomething(); } } Loading history...
118		$aggregation = new NestedAggregation(
119		$name,
120		$path
121		);
122		$termsAggregation = new TermsAggregation('query', $field);
123		$termsAggregation->addParameter('size', 0);
124
125		if ($this->getSortType()) {
126		$termsAggregation->addParameter('order', [$this->getSortType()['type'] => $this->getSortType()['order']]);
127		}
128
129		if ($this->getSize() > 0) {
130		$termsAggregation->addParameter('size', $this->getSize());
131		}
132
133		$termsAggregation->addAggregation(
134		new TermsAggregation('name', $this->getNameField())
135		);
136		$aggregation->addAggregation($termsAggregation);
137		$filterAggregation = new FilterAggregation($name . '-filter');
138		$filterAggregation->setFilter($relatedSearch->getPostFilters());
139
140		if ($state->isActive()) {
141		$this->valueArray = $state->getValue();
142
143		foreach ($state->getValue() as $key => $term) {
144		$terms = $state->getValue();
145		array_splice($terms, $key, 1);
146
147		if (!count($terms)) {
148		break;
149		}
150
151		$this->addSubFilterAggregation(
152		$filterAggregation,
153		$aggregation,
154		$terms,
155		$term
156		);
157		}
158
159		$this->addSubFilterAggregation(
160		$filterAggregation,
161		$aggregation,
162		$state->getValue(),
163		'all-selected'
164		);
165		} else {
166		$filterAggregation->addAggregation($aggregation);
167		}
168
169		$search->addAggregation($filterAggregation);
170		}
171
172		/**
173		* {@inheritdoc}
174		*/
175		public function createViewData()
176		{
177		return new AggregateViewData();
178		}
179
180		/**
181		* {@inheritdoc}
182		*/
183		public function getViewData(DocumentIterator $result, ViewData $data)
184		{
185		$unsortedChoices = [];
186
187		/** @var AggregationValue $bucket */
188		foreach ($this->fetchAggregation($result, $data->getName()) as $bucket) {
189		$active = $this->isChoiceActive($bucket['key'], $data);
190		$choice = new ViewData\Choice();
191		$choice->setLabel($bucket->getValue('key'));
192		$choice->setCount($bucket['doc_count']);
193		$choice->setActive($active);
194	View Code Duplication	if ($active) {
		0 ignored issues – show Duplication introduced 2016-09-06 06:35 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
195		$choice->setUrlParameters($this->getUnsetUrlParameters($bucket['key'], $data));
196		} else {
197		$choice->setUrlParameters($this->getOptionUrlParameters($bucket['key'], $data));
198		}
199		$unsortedChoices[$bucket->getAggregation('name')->getBuckets()[0]['key']][] = $choice;
200		}
201
202		/** @var AggregateViewData $data */
203		foreach ($unsortedChoices as $name => $choices) {
204		$choiceViewData = new ViewData\ChoicesAwareViewData();
205		$choiceViewData->setName($name);
206		$choiceViewData->setChoices($choices);
207		$choiceViewData->setUrlParameters([]);
208		$choiceViewData->setResetUrlParameters([]);
209		$data->addItem($choiceViewData);
210		}
211
212		return $data;
213		}
214
215		/**
216		* {@inheritdoc}
217		*/
218		public function isRelated()
219		{
220		return true;
221		}
222
223		/**
224		* Fetches buckets from search results.
225		*
226		* @param DocumentIterator $result Search results.
227		* @param string $name Filter name.
228		*
229		* @return array Buckets.
230		*/
231		private function fetchAggregation(DocumentIterator $result, $name)
232		{
233		$data = [];
234		$aggregation = $result->getAggregation(sprintf('%s-filter', $name));
235
236		if ($result->getAggregation($name)) {
237		$aggregation = $aggregation->find($name.'.query');
238		$data['unfiltered'] = $aggregation;
239
240		return $data;
241		}
242
243		if (isset($this->valueArray)) {
244		foreach ($this->valueArray as $value) {
245		$data[$value] = $aggregation->find($value.'.query');
246		}
247
248		$data['all-selected'] = $aggregation->find('all-selected.query');
249
250		return $data;
251		}
252
253		return [];
254		}
255
256		/**
257		* A method used to add an additional filter to the aggregations
258		* in preProcessSearch
259		*
260		* @param FilterAggregation $filterAggregation
261		* @param NestedAggregation $deepLevelAggregation
262		* @param array $terms Terms of additional filter
263		* @param string $aggName
264		*
265		* @return BuilderInterface
266		*/
267		private function addSubFilterAggregation(
268		$filterAggregation,
269		$deepLevelAggregation,
270		$terms,
271		$aggName
272		) {
273		list($path, $field) = explode('>', $this->getField());
274		$innerFilterAggregation = new FilterAggregation(
275		$aggName,
276		new NestedQuery(
277		$path,
278		new TermsQuery($field, $terms)
279		)
280		);
281		$innerFilterAggregation->addAggregation($deepLevelAggregation);
282		$filterAggregation->addAggregation($innerFilterAggregation);
283		}
284
285		/**
286		* @param string $key
287		* @param ViewData $data
288		*
289		* @return array
290		*/
291		private function getOptionUrlParameters($key, ViewData $data)
292		{
293		$parameters = $data->getResetUrlParameters();
294		$parameters[$this->getRequestField()][] = $key;
295
296		return $parameters;
297		}
298
299		/**
300		* Returns url with selected term disabled.
301		*
302		* @param string $key
303		* @param ViewData $data
304		*
305		* @return array
306		*/
307		private function getUnsetUrlParameters($key, ViewData $data)
		0 ignored issues – show Unused Code introduced 2016-09-06 06:35 UTC by Report Bug Copy Issue Report The parameter `$key` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
308		{
309		return $data->getResetUrlParameters();
310		}
311
312		/**
313		* Returns whether choice with the specified key is active.
314		*
315		* @param string $key
316		* @param ViewData $data
317		*
318		* @return bool
319		*/
320		private function isChoiceActive($key, ViewData $data)
321		{
322		return $data->getState()->isActive() && in_array($key, $data->getState()->getValue());
323		}
324		}
325

ongr-io / FilterManagerBundle

Pull Request — master (#188)

DynamicAggregateFilter::getOptionUrlParameters() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like