FeatureTypeLoop::buildModelCriteria() - Code Metrics - thelia-modules/FeatureType - Measure and Improve Code Quality continuously with Scrutinizer

FeatureTypeLoop::buildModelCriteria() C
last analyzed 2020-12-16 10:19 UTC

↳ Parent: FeatureTypeLoop

Complexity

Conditions	10
Paths	96

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	62
rs	6.9624
c	0
b	0
f	0
cc	10
nc	96
nop	0

How to fix Long Method Complexity

<?php
/*************************************************************************************/
/*      This file is part of the module FeatureType                                  */
/*                                                                                   */
/*      For the full copyright and license information, please view the LICENSE.txt  */
/*      file that was distributed with this source code.                             */
/*************************************************************************************/

namespace FeatureType\Loop;

use FeatureType\Model\FeatureType;
use FeatureType\Model\FeatureTypeQuery;
use FeatureType\Model\Map\FeatureFeatureTypeTableMap;
use FeatureType\Model\Map\FeatureTypeTableMap;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\ActiveQuery\Join;
use Thelia\Core\Template\Element\BaseI18nLoop;
use Thelia\Core\Template\Element\LoopResult;
use Thelia\Core\Template\Element\LoopResultRow;
use Thelia\Core\Template\Element\PropelSearchLoopInterface;
use Thelia\Core\Template\Loop\Argument\Argument;
use Thelia\Core\Template\Loop\Argument\ArgumentCollection;

/**
 * Class FeatureTypeLoop
 * @package FeatureType\Loop
 * @author Gilles Bourgeat <[email protected]>
 */
class FeatureTypeLoop extends BaseI18nLoop implements PropelSearchLoopInterface
{
    /**
     * Definition of loop arguments
     *
     * example :
     *
     * public function getArgDefinitions()
     * {
     *  return new ArgumentCollection(
     *
     *       Argument::createIntListTypeArgument('id'),
     *           new Argument(
     *           'ref',
     *           new TypeCollection(
     *               new Type\AlphaNumStringListType()
     *           )
     *       ),
     *       Argument::createIntListTypeArgument('category'),
     *       Argument::createBooleanTypeArgument('new'),
     *       ...
     *   );
     * }
     *
     * @return \Thelia\Core\Template\Loop\Argument\ArgumentCollection
     */
    protected function getArgDefinitions()
    {
        return new ArgumentCollection(
            Argument::createIntListTypeArgument("id"),
            Argument::createIntListTypeArgument("exclude_id"),
            Argument::createAnyTypeArgument('slug'),
            Argument::createIntListTypeArgument("feature_id"),
            Argument::createEnumListTypeArgument(
                "order",
                [
                    "id",
                    "id-reverse",
                    "feature_type",
                    "feature_type-reverse",
                ],
                "id"
            )
        );
    }
    /**
     * this method returns a Propel ModelCriteria
     *
     * @return \Propel\Runtime\ActiveQuery\ModelCriteria
     */
    public function buildModelCriteria()
    {
        $query = new FeatureTypeQuery();

        /* manage translations */
        $this->configureI18nProcessing($query, array('TITLE', 'DESCRIPTION'));

        if (null !== $id = $this->getId()) {
            $query->filterById($id);
        }

        if (null !== $id = $this->getExcludeId()) {
            $query->filterById($id, Criteria::NOT_IN);
        }

        if (null !== $slug = $this->getSlug()) {
            $query->filterBySlug($slug);
        }

        if (null !== $featureId = $this->getFeatureId()) {
            $join = new Join();

            $join->addExplicitCondition(
                FeatureTypeTableMap::TABLE_NAME,
                'ID',
                null,
                FeatureFeatureTypeTableMap::TABLE_NAME,
                'FEATURE_TYPE_ID',
                null
            );

            $join->setJoinType(Criteria::JOIN);

            $query
                ->addJoinObject($join, 'feature_type_join')
                ->addJoinCondition(
                    'feature_type_join',
                    '`feature_feature_type`.`feature_id` IN (?)',
                    implode(',', $featureId),
                    null,
                    \PDO::PARAM_INT
                );
        }

        foreach ($this->getOrder() as $order) {
            switch ($order) {
                case "id":
                    $query->orderById();
                    break;
                case "id-reverse":
                    $query->orderById(Criteria::DESC);
                    break;
                case "slug":
                    $query->orderBySlug();
                    break;
                case "slug-reverse":
                    $query->orderBySlug(Criteria::DESC);
                    break;
            }
        }
        return $query;
    }

    /**
     * @param LoopResult $loopResult
     *
     * @return LoopResult
     */
    public function parseResults(LoopResult $loopResult)
    {
        /** @var FeatureType $entry */
        foreach ($loopResult->getResultDataCollection() as $entry) {
            $row = new LoopResultRow($entry);
            $row
                ->set("ID", $entry->getId())
                ->set("SLUG", $entry->getSlug())
                ->set("TITLE", $entry->getVirtualColumn('i18n_TITLE'))
                ->set("DESCRIPTION", $entry->getVirtualColumn('i18n_DESCRIPTION'))
                ->set("CSS_CLASS", $entry->getCssClass())
                ->set("PATTERN", $entry->getPattern())
                ->set("INPUT_TYPE", $entry->getInputType())
                ->set("MIN", $entry->getMin())
                ->set("MAX", $entry->getMax())
                ->set("STEP", $entry->getStep())
                ->set("IMAGE_MAX_WIDTH", $entry->getImageMaxWidth())
                ->set("IMAGE_MAX_HEIGHT", $entry->getImageMaxHeight())
                ->set("IMAGE_RATIO", $entry->getImageRatio())
                ->set("IS_MULTILINGUAL_FEATURE_AV_VALUE", $entry->getIsMultilingualFeatureAvValue())
                ->set("HAS_FEATURE_AV_VALUE", $entry->getHasFeatureAvValue())
            ;

            $this->addOutputFields($row, $entry);

            $loopResult->addRow($row);
        }

        return $loopResult;
    }
}


1			<?php
2			/*************************************************************************************/
3			/* This file is part of the module FeatureType */
4			/* */
5			/* For the full copyright and license information, please view the LICENSE.txt */
6			/* file that was distributed with this source code. */
7			/*************************************************************************************/
8
9			namespace FeatureType\Loop;
10
11			use FeatureType\Model\FeatureType;
12			use FeatureType\Model\FeatureTypeQuery;
13			use FeatureType\Model\Map\FeatureFeatureTypeTableMap;
14			use FeatureType\Model\Map\FeatureTypeTableMap;
15			use Propel\Runtime\ActiveQuery\Criteria;
16			use Propel\Runtime\ActiveQuery\Join;
17			use Thelia\Core\Template\Element\BaseI18nLoop;
18			use Thelia\Core\Template\Element\LoopResult;
19			use Thelia\Core\Template\Element\LoopResultRow;
20			use Thelia\Core\Template\Element\PropelSearchLoopInterface;
21			use Thelia\Core\Template\Loop\Argument\Argument;
22			use Thelia\Core\Template\Loop\Argument\ArgumentCollection;
23
24			/**
25			* Class FeatureTypeLoop
26			* @package FeatureType\Loop
27			* @author Gilles Bourgeat <[email protected]>
28			*/
29			class FeatureTypeLoop extends BaseI18nLoop implements PropelSearchLoopInterface
30			{
31			/**
32			* Definition of loop arguments
33			*
34			* example :
35			*
36			* public function getArgDefinitions()
37			* {
38			* return new ArgumentCollection(
39			*
40			* Argument::createIntListTypeArgument('id'),
41			* new Argument(
42			* 'ref',
43			* new TypeCollection(
44			* new Type\AlphaNumStringListType()
45			* )
46			* ),
47			* Argument::createIntListTypeArgument('category'),
48			* Argument::createBooleanTypeArgument('new'),
49			* ...
50			* );
51			* }
52			*
53			* @return \Thelia\Core\Template\Loop\Argument\ArgumentCollection
54			*/
55			protected function getArgDefinitions()
56			{
57			return new ArgumentCollection(
58			Argument::createIntListTypeArgument("id"),
59			Argument::createIntListTypeArgument("exclude_id"),
60			Argument::createAnyTypeArgument('slug'),
61			Argument::createIntListTypeArgument("feature_id"),
62			Argument::createEnumListTypeArgument(
63			"order",
64			[
65			"id",
66			"id-reverse",
67			"feature_type",
68			"feature_type-reverse",
69			],
70			"id"
71			)
72			);
73			}
74			/**
75			* this method returns a Propel ModelCriteria
76			*
77			* @return \Propel\Runtime\ActiveQuery\ModelCriteria
78			*/
79			public function buildModelCriteria()
80			{
81			$query = new FeatureTypeQuery();
82
83			/* manage translations */
84			$this->configureI18nProcessing($query, array('TITLE', 'DESCRIPTION'));
85
86			if (null !== $id = $this->getId()) {
87			$query->filterById($id);
88			}
89
90			if (null !== $id = $this->getExcludeId()) {
91			$query->filterById($id, Criteria::NOT_IN);
92			}
93
94			if (null !== $slug = $this->getSlug()) {
95			$query->filterBySlug($slug);
96			}
97
98			if (null !== $featureId = $this->getFeatureId()) {
99			$join = new Join();
100
101			$join->addExplicitCondition(
102			FeatureTypeTableMap::TABLE_NAME,
103			'ID',
104			null,
105			FeatureFeatureTypeTableMap::TABLE_NAME,
106			'FEATURE_TYPE_ID',
107			null
108			);
109
110			$join->setJoinType(Criteria::JOIN);
111
112			$query
113			->addJoinObject($join, 'feature_type_join')
114			->addJoinCondition(
115			'feature_type_join',
116			'`feature_feature_type`.`feature_id` IN (?)',
117			implode(',', $featureId),
118			null,
119			\PDO::PARAM_INT
120			);
121			}
122
123			foreach ($this->getOrder() as $order) {
124			switch ($order) {
125			case "id":
126			$query->orderById();
127			break;
128			case "id-reverse":
129			$query->orderById(Criteria::DESC);
130			break;
131			case "slug":
132			$query->orderBySlug();
133			break;
134			case "slug-reverse":
135			$query->orderBySlug(Criteria::DESC);
136			break;
137			}
138			}
139			return $query;
140			}
141
142			/**
143			* @param LoopResult $loopResult
144			*
145			* @return LoopResult
146			*/
147			public function parseResults(LoopResult $loopResult)
148			{
149			/** @var FeatureType $entry */
150			foreach ($loopResult->getResultDataCollection() as $entry) {
151			$row = new LoopResultRow($entry);
152			$row
153			->set("ID", $entry->getId())
154			->set("SLUG", $entry->getSlug())
155			->set("TITLE", $entry->getVirtualColumn('i18n_TITLE'))
156			->set("DESCRIPTION", $entry->getVirtualColumn('i18n_DESCRIPTION'))
157			->set("CSS_CLASS", $entry->getCssClass())
158			->set("PATTERN", $entry->getPattern())
159			->set("INPUT_TYPE", $entry->getInputType())
160			->set("MIN", $entry->getMin())
161			->set("MAX", $entry->getMax())
162			->set("STEP", $entry->getStep())
163			->set("IMAGE_MAX_WIDTH", $entry->getImageMaxWidth())
164			->set("IMAGE_MAX_HEIGHT", $entry->getImageMaxHeight())
165			->set("IMAGE_RATIO", $entry->getImageRatio())
166			->set("IS_MULTILINGUAL_FEATURE_AV_VALUE", $entry->getIsMultilingualFeatureAvValue())
167			->set("HAS_FEATURE_AV_VALUE", $entry->getHasFeatureAvValue())
168			;
169
170			$this->addOutputFields($row, $entry);
171
172			$loopResult->addRow($row);
173			}
174
175			return $loopResult;
176			}
177			}
178

thelia-modules / FeatureType

FeatureTypeLoop::buildModelCriteria() C last analyzed 2020-12-16 10:19 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

FeatureTypeLoop::buildModelCriteria() C
last analyzed 2020-12-16 10:19 UTC