SingleTermChoice::getViewData() - Code Metrics - Inspection of "Show zero choices" - ongr-io/FilterManagerBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#190)

unknown

created 2016-09-12 10:14 UTC

SingleTermChoice::getViewData() C

↳ Parent: SingleTermChoice

Complexity

Conditions	10
Paths	88

Size

Total Lines	51
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	51
rs	6
c	0
b	0
f	0
cc	10
eloc	31
nc	88
nop	2

How to fix Long Method Complexity

<?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\Choice;

use ONGR\ElasticsearchDSL\Aggregation\FilterAggregation;
use ONGR\ElasticsearchDSL\Aggregation\TermsAggregation;
use ONGR\ElasticsearchDSL\Query\TermQuery;
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\ChoicesAwareViewData;
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;

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

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

    /**
     * @var bool
     */
    private $showZeroChoices;

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

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

    /**
     * @param bool $showZeroChoices
     */
    public function setShowZeroChoices($showZeroChoices)
    {
        $this->showZeroChoices = $showZeroChoices;
    }

    /**
     * @return bool
     */
    public function getShowZeroChoices()
    {
        return $this->showZeroChoices;
    }

    /**
     * {@inheritdoc}
     */
    public function modifySearch(Search $search, FilterState $state = null, SearchRequest $request = null)
    {
        if ($state && $state->isActive()) {
            $search->addPostFilter(new TermQuery($this->getField(), $state->getValue()));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function preProcessSearch(Search $search, Search $relatedSearch, FilterState $state = null)
    {
        $name = $state ? $state->getName() : $this->getField();
        $aggregation = new TermsAggregation($name, $this->getField());

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

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

        if ($relatedSearch->getPostFilters()) {
            $filterAggregation = new FilterAggregation($name . '-filter');
            $filterAggregation->setFilter($relatedSearch->getPostFilters());
            $filterAggregation->addAggregation($aggregation);
            $search->addAggregation($filterAggregation);

            if ($this->showZeroChoices) {
                $unfilteredAggregation = clone $aggregation;
                $unfilteredAggregation->setName($name . '-unfiltered');
                $search->addAggregation($unfilteredAggregation);
            }
        } else {
            $search->addAggregation($aggregation);
        }
    }

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

    /**
     * {@inheritdoc}
     */
    public function getViewData(DocumentIterator $result, ViewData $data)
    {
        /** @var ChoicesAwareViewData $data */

        $unsortedChoices = [];
        $zeroValueChoices = [];

        if ($this->showZeroChoices && $agg = $result->getAggregation($data->getName() . '-unfiltered')) {
            foreach ($agg as $bucket) {
                $zeroValueChoices[$bucket['key']] = $bucket['doc_count'];
            }
        }

        foreach ($this->fetchAggregation($result, $data->getName()) as $bucket) {
            $active = $this->isChoiceActive($bucket['key'], $data);
            $choice = new ViewData\Choice();
            $choice->setLabel($bucket['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['key']] = $choice;

            if (!empty($zeroValueChoices)) {
                unset($zeroValueChoices[$bucket['key']]);
            }
        }

        foreach ($zeroValueChoices as $choiceLabel => $value) {
            $choice = new ViewData\Choice();
            $choice->setLabel($choiceLabel);
            $choice->setCount(0);
            $choice->setActive(false);
            $choice->setUrlParameters($data->getResetUrlParameters());
            $unsortedChoices[$choiceLabel] = $choice;
        }

        // Add the prioritized choices first.
        if ($this->getSortType()) {
            $unsortedChoices = $this->addPriorityChoices($unsortedChoices, $data);
        }

        foreach ($unsortedChoices as $choice) {
            $data->addChoice($choice);
        }

        return $data;
    }

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

    /**
     * Adds prioritized choices.
     *
     * @param array                $unsortedChoices
     * @param ChoicesAwareViewData $data
     *
     * @return array
     */
    protected function addPriorityChoices(array $unsortedChoices, ChoicesAwareViewData $data)
    {
        foreach ($this->getSortType()['priorities'] as $name) {
            if (array_key_exists($name, $unsortedChoices)) {
                $data->addChoice($unsortedChoices[$name]);
                unset($unsortedChoices[$name]);
            }
        }

        return $unsortedChoices;
    }

    /**
     * Fetches buckets from search results.
     *
     * @param DocumentIterator $result Search results.
     * @param string           $name   Filter name.
     *
     * @return array Buckets.
     */
    protected function fetchAggregation(DocumentIterator $result, $name)
    {
        $aggregation = $result->getAggregation($name);
        if (isset($aggregation)) {
            return $aggregation;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $aggregation = $result->getAggregation(sprintf('%s-filter', $name));
        if (isset($aggregation)) {
            return $aggregation->find($name);
        }

        return [];
    }

    /**
     * @param string   $key
     * @param ViewData $data
     *
     * @return array
     */
    protected 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
     */
    protected 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
     */
    protected function isChoiceActive($key, ViewData $data)
    {
        return $data->getState()->isActive() && $data->getState()->getValue() == $key;
    }
}


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\Choice;
13
14			use ONGR\ElasticsearchDSL\Aggregation\FilterAggregation;
15			use ONGR\ElasticsearchDSL\Aggregation\TermsAggregation;
16			use ONGR\ElasticsearchDSL\Query\TermQuery;
17			use ONGR\ElasticsearchDSL\Search;
18			use ONGR\ElasticsearchBundle\Result\DocumentIterator;
19			use ONGR\FilterManagerBundle\Filter\FilterState;
20			use ONGR\FilterManagerBundle\Filter\Helper\SizeAwareTrait;
21			use ONGR\FilterManagerBundle\Filter\Helper\ViewDataFactoryInterface;
22			use ONGR\FilterManagerBundle\Filter\ViewData\ChoicesAwareViewData;
23			use ONGR\FilterManagerBundle\Filter\ViewData;
24			use ONGR\FilterManagerBundle\Filter\Widget\AbstractSingleRequestValueFilter;
25			use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareInterface;
26			use ONGR\FilterManagerBundle\Filter\Helper\FieldAwareTrait;
27			use ONGR\FilterManagerBundle\Search\SearchRequest;
28
29			/**
30			* This class provides single terms choice.
31			*/
32			class SingleTermChoice extends AbstractSingleRequestValueFilter implements FieldAwareInterface, ViewDataFactoryInterface
33			{
34			use FieldAwareTrait, SizeAwareTrait;
35
36			/**
37			* @var array
38			*/
39			private $sortType;
40
41			/**
42			* @var bool
43			*/
44			private $showZeroChoices;
45
46			/**
47			* @param array $sortType
48			*/
49			public function setSortType($sortType)
50			{
51			$this->sortType = $sortType;
52			}
53
54			/**
55			* @return array
56			*/
57			public function getSortType()
58			{
59			return $this->sortType;
60			}
61
62			/**
63			* @param bool $showZeroChoices
64			*/
65			public function setShowZeroChoices($showZeroChoices)
66			{
67			$this->showZeroChoices = $showZeroChoices;
68			}
69
70			/**
71			* @return bool
72			*/
73			public function getShowZeroChoices()
74			{
75			return $this->showZeroChoices;
76			}
77
78			/**
79			* {@inheritdoc}
80			*/
81			public function modifySearch(Search $search, FilterState $state = null, SearchRequest $request = null)
82			{
83			if ($state && $state->isActive()) {
84			$search->addPostFilter(new TermQuery($this->getField(), $state->getValue()));
85			}
86			}
87
88			/**
89			* {@inheritdoc}
90			*/
91			public function preProcessSearch(Search $search, Search $relatedSearch, FilterState $state = null)
92			{
93			$name = $state ? $state->getName() : $this->getField();
94			$aggregation = new TermsAggregation($name, $this->getField());
95
96			if ($this->getSortType()) {
97			$aggregation->addParameter('order', [$this->getSortType()['type'] => $this->getSortType()['order']]);
98			}
99
100			$aggregation->addParameter('size', 0);
101			if ($this->getSize() > 0) {
102			$aggregation->addParameter('size', $this->getSize());
103			}
104
105			if ($relatedSearch->getPostFilters()) {
106			$filterAggregation = new FilterAggregation($name . '-filter');
107			$filterAggregation->setFilter($relatedSearch->getPostFilters());
108			$filterAggregation->addAggregation($aggregation);
109			$search->addAggregation($filterAggregation);
110
111			if ($this->showZeroChoices) {
112			$unfilteredAggregation = clone $aggregation;
113			$unfilteredAggregation->setName($name . '-unfiltered');
114			$search->addAggregation($unfilteredAggregation);
115			}
116			} else {
117			$search->addAggregation($aggregation);
118			}
119			}
120
121			/**
122			* {@inheritdoc}
123			*/
124			public function createViewData()
125			{
126			return new ChoicesAwareViewData();
127			}
128
129			/**
130			* {@inheritdoc}
131			*/
132			public function getViewData(DocumentIterator $result, ViewData $data)
133			{
134			/** @var ChoicesAwareViewData $data */
135
136			$unsortedChoices = [];
137			$zeroValueChoices = [];
138
139			if ($this->showZeroChoices && $agg = $result->getAggregation($data->getName() . '-unfiltered')) {
140			foreach ($agg as $bucket) {
141			$zeroValueChoices[$bucket['key']] = $bucket['doc_count'];
142			}
143			}
144
145			foreach ($this->fetchAggregation($result, $data->getName()) as $bucket) {
146			$active = $this->isChoiceActive($bucket['key'], $data);
147			$choice = new ViewData\Choice();
148			$choice->setLabel($bucket['key']);
149			$choice->setCount($bucket['doc_count']);
150			$choice->setActive($active);
151			if ($active) {
152			$choice->setUrlParameters($this->getUnsetUrlParameters($bucket['key'], $data));
153			} else {
154			$choice->setUrlParameters($this->getOptionUrlParameters($bucket['key'], $data));
155			}
156			$unsortedChoices[$bucket['key']] = $choice;
157
158			if (!empty($zeroValueChoices)) {
159			unset($zeroValueChoices[$bucket['key']]);
160			}
161			}
162
163			foreach ($zeroValueChoices as $choiceLabel => $value) {
164			$choice = new ViewData\Choice();
165			$choice->setLabel($choiceLabel);
166			$choice->setCount(0);
167			$choice->setActive(false);
168			$choice->setUrlParameters($data->getResetUrlParameters());
169			$unsortedChoices[$choiceLabel] = $choice;
170			}
171
172			// Add the prioritized choices first.
173			if ($this->getSortType()) {
174			$unsortedChoices = $this->addPriorityChoices($unsortedChoices, $data);
175			}
176
177			foreach ($unsortedChoices as $choice) {
178			$data->addChoice($choice);
179			}
180
181			return $data;
182			}
183
184			/**
185			* {@inheritdoc}
186			*/
187			public function isRelated()
188			{
189			return true;
190			}
191
192			/**
193			* Adds prioritized choices.
194			*
195			* @param array $unsortedChoices
196			* @param ChoicesAwareViewData $data
197			*
198			* @return array
199			*/
200			protected function addPriorityChoices(array $unsortedChoices, ChoicesAwareViewData $data)
201			{
202			foreach ($this->getSortType()['priorities'] as $name) {
203			if (array_key_exists($name, $unsortedChoices)) {
204			$data->addChoice($unsortedChoices[$name]);
205			unset($unsortedChoices[$name]);
206			}
207			}
208
209			return $unsortedChoices;
210			}
211
212			/**
213			* Fetches buckets from search results.
214			*
215			* @param DocumentIterator $result Search results.
216			* @param string $name Filter name.
217			*
218			* @return array Buckets.
219			*/
220			protected function fetchAggregation(DocumentIterator $result, $name)
221			{
222			$aggregation = $result->getAggregation($name);
223			if (isset($aggregation)) {
224			return $aggregation;
			0 ignored issues – show Bug Best Practice introduced 2016-01-26 16:36 UTC by Report Bug Copy Issue Report The return type of `return $aggregation;` (`ONGR\ElasticsearchBundle...gation\AggregationValue`) is incompatible with the return type documented by `ONGR\FilterManagerBundle...hoice::fetchAggregation` of type `array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
225			}
226
227			$aggregation = $result->getAggregation(sprintf('%s-filter', $name));
228			if (isset($aggregation)) {
229			return $aggregation->find($name);
230			}
231
232			return [];
233			}
234
235			/**
236			* @param string $key
237			* @param ViewData $data
238			*
239			* @return array
240			*/
241			protected function getOptionUrlParameters($key, ViewData $data)
242			{
243			$parameters = $data->getResetUrlParameters();
244			$parameters[$this->getRequestField()] = $key;
245
246			return $parameters;
247			}
248
249			/**
250			* Returns url with selected term disabled.
251			*
252			* @param string $key
253			* @param ViewData $data
254			*
255			* @return array
256			*/
257			protected function getUnsetUrlParameters($key, ViewData $data)
258			{
259			return $data->getResetUrlParameters();
260			}
261
262			/**
263			* Returns whether choice with the specified key is active.
264			*
265			* @param string $key
266			* @param ViewData $data
267			*
268			* @return bool
269			*/
270			protected function isChoiceActive($key, ViewData $data)
271			{
272			return $data->getState()->isActive() && $data->getState()->getValue() == $key;
273			}
274			}
275

ongr-io / FilterManagerBundle

Pull Request — master (#190)

SingleTermChoice::getViewData() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like