Category::countAllProductsVisibleOnly() - Code Metrics - Inspection of "Add param product_count_visible_only loop category" - thelia/thelia - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2356)

by zzuutt

created 2017-02-21 15:42 UTC

Category::countAllProductsVisibleOnly() A

↳ Parent: Category

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	2

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

<?php

namespace Thelia\Model;

use Propel\Runtime\ActiveQuery\Criteria;
use Thelia\Core\Event\Category\CategoryEvent;
use Thelia\Files\FileModelParentInterface;
use Thelia\Model\Base\Category as BaseCategory;
use Thelia\Core\Event\TheliaEvents;
use Propel\Runtime\Connection\ConnectionInterface;
use Thelia\Model\Tools\ModelEventDispatcherTrait;
use Thelia\Model\Tools\PositionManagementTrait;
use Thelia\Model\Tools\UrlRewritingTrait;

class Category extends BaseCategory implements FileModelParentInterface

{
    use ModelEventDispatcherTrait;

    use PositionManagementTrait;

    use UrlRewritingTrait;

    /**
     * @return int number of child for the current category
     */
    public function countChild()
    {
        return CategoryQuery::countChild($this->getId());
    }

    /**
     * {@inheritDoc}
     */
    public function getRewrittenUrlViewName()
    {
        return 'category';
    }

    /**
     *
     * count all products for current category and sub categories
     *
     * /!\ the number of queries is exponential, use it with caution
     *
     * @return int
     */
    public function countAllProducts($visibleOnly = false)
    {
        $children = CategoryQuery::findAllChild($this->getId());
        array_push($children, $this);

        $countProduct = 0;

        foreach ($children as $child) {
            $req = ProductQuery::create();
            $req->filterByCategory($child);
            if($visibleOnly) {
                $req->filterByVisible(true);
            }

            $countProduct += $req->count();
        }

        return $countProduct;
    }

    /**
     *
     * count visible products only for current category and sub categories
     *
     * /!\ the number of queries is exponential, use it with caution
     *
     * @return int
     */
    public function countAllProductsVisibleOnly()
    {
        return $this->countAllProducts(true);
    }
    
    /**
     * Get the root category
     * @param  int   $categoryId
     * @return mixed
     */
    public function getRoot($categoryId)
    {
        $category = CategoryQuery::create()->findPk($categoryId);

        if (0 !== $category->getParent()) {
            $parentCategory = CategoryQuery::create()->findPk($category->getParent());

            if (null !== $parentCategory) {
                $categoryId = $this->getRoot($parentCategory->getId());
            }
        }

        return $categoryId;
    }

    /**
     * Calculate next position relative to our parent
     */
    protected function addCriteriaToPositionQuery($query)
    {
        $query->filterByParent($this->getParent());
    }

    public function deleteProducts(ConnectionInterface $con = null)
    {
        $productsCategories = ProductCategoryQuery::create()
            ->filterByCategoryId($this->getId())
            ->filterByDefaultCategory(1)
            ->find($con);

        if ($productsCategories) {
            foreach ($productsCategories as $productCategory) {
                $product = $productCategory->getProduct();
                if ($product) {
                    $product->delete($con);
                }
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function preInsert(ConnectionInterface $con = null)
    {
        $this->setPosition($this->getNextPosition());

        $this->dispatchEvent(TheliaEvents::BEFORE_CREATECATEGORY, new CategoryEvent($this));

        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function postInsert(ConnectionInterface $con = null)
    {
        $this->dispatchEvent(TheliaEvents::AFTER_CREATECATEGORY, new CategoryEvent($this));
    }

    /**
     * {@inheritDoc}
     */
    public function preUpdate(ConnectionInterface $con = null)
    {
        $this->dispatchEvent(TheliaEvents::BEFORE_UPDATECATEGORY, new CategoryEvent($this));

        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function postUpdate(ConnectionInterface $con = null)
    {
        $this->dispatchEvent(TheliaEvents::AFTER_UPDATECATEGORY, new CategoryEvent($this));
    }

    /**
     * {@inheritDoc}
     */
    public function preDelete(ConnectionInterface $con = null)
    {
        $this->dispatchEvent(TheliaEvents::BEFORE_DELETECATEGORY, new CategoryEvent($this));
        $this->reorderBeforeDelete(
            array(
                "parent" => $this->getParent(),
            )
        );
        $this->deleteProducts($con);

        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function postDelete(ConnectionInterface $con = null)
    {
        $this->markRewrittenUrlObsolete();

        //delete all subcategories
        $subCategories = CategoryQuery::findAllChild($this->getId());

        foreach ($subCategories as $category) {
            if (!is_null($this->dispatcher)) {
                $category->setDispatcher($this->getDispatcher());
            }

            $category->delete();
        }

        $this->dispatchEvent(TheliaEvents::AFTER_DELETECATEGORY, new CategoryEvent($this));
    }

    /**
     * Overload for the position management
     * @param Base\ProductCategory $productCategory
     * @inheritdoc
     */
    protected function doAddProductCategory($productCategory)
    {
        parent::doAddProductCategory($productCategory);

        $productCategoryPosition = ProductCategoryQuery::create()
            ->filterByCategoryId($productCategory->getCategoryId())
            ->orderByPosition(Criteria::DESC)
            ->findOne();

        $productCategory->setPosition($productCategoryPosition !== null ? $productCategoryPosition->getPosition() + 1 : 1);
    }
}


1			<?php
2
3			namespace Thelia\Model;
4
5			use Propel\Runtime\ActiveQuery\Criteria;
6			use Thelia\Core\Event\Category\CategoryEvent;
7			use Thelia\Files\FileModelParentInterface;
8			use Thelia\Model\Base\Category as BaseCategory;
9			use Thelia\Core\Event\TheliaEvents;
10			use Propel\Runtime\Connection\ConnectionInterface;
11			use Thelia\Model\Tools\ModelEventDispatcherTrait;
12			use Thelia\Model\Tools\PositionManagementTrait;
13			use Thelia\Model\Tools\UrlRewritingTrait;
14
15			class Category extends BaseCategory implements FileModelParentInterface
			0 ignored issues – show Bug introduced 2015-11-22 20:39 UTC by Report Bug Copy Issue Report There is one abstract method `getTitle` in this class; you could implement it, or declare this class as abstract. Loading history...
16			{
17			use ModelEventDispatcherTrait;
18
19			use PositionManagementTrait;
20
21			use UrlRewritingTrait;
22
23			/**
24			* @return int number of child for the current category
25			*/
26			public function countChild()
27			{
28			return CategoryQuery::countChild($this->getId());
29			}
30
31			/**
32			* {@inheritDoc}
33			*/
34			public function getRewrittenUrlViewName()
35			{
36			return 'category';
37			}
38
39			/**
40			*
41			* count all products for current category and sub categories
42			*
43			* /!\ the number of queries is exponential, use it with caution
44			*
45			* @return int
46			*/
47			public function countAllProducts($visibleOnly = false)
48			{
49			$children = CategoryQuery::findAllChild($this->getId());
50			array_push($children, $this);
51
52			$countProduct = 0;
53
54			foreach ($children as $child) {
55			$req = ProductQuery::create();
56			$req->filterByCategory($child);
57			if($visibleOnly) {
58			$req->filterByVisible(true);
59			}
60
61			$countProduct += $req->count();
62			}
63
64			return $countProduct;
65			}
66
67			/**
68			*
69			* count visible products only for current category and sub categories
70			*
71			* /!\ the number of queries is exponential, use it with caution
72			*
73			* @return int
74			*/
75			public function countAllProductsVisibleOnly()
76			{
77			return $this->countAllProducts(true);
78			}
79
80			/**
81			* Get the root category
82			* @param int $categoryId
83			* @return mixed
84			*/
85			public function getRoot($categoryId)
86			{
87			$category = CategoryQuery::create()->findPk($categoryId);
88
89			if (0 !== $category->getParent()) {
90			$parentCategory = CategoryQuery::create()->findPk($category->getParent());
91
92			if (null !== $parentCategory) {
93			$categoryId = $this->getRoot($parentCategory->getId());
94			}
95			}
96
97			return $categoryId;
98			}
99
100			/**
101			* Calculate next position relative to our parent
102			*/
103			protected function addCriteriaToPositionQuery($query)
104			{
105			$query->filterByParent($this->getParent());
106			}
107
108			public function deleteProducts(ConnectionInterface $con = null)
109			{
110			$productsCategories = ProductCategoryQuery::create()
111			->filterByCategoryId($this->getId())
112			->filterByDefaultCategory(1)
113			->find($con);
114
115			if ($productsCategories) {
116			foreach ($productsCategories as $productCategory) {
117			$product = $productCategory->getProduct();
118			if ($product) {
119			$product->delete($con);
120			}
121			}
122			}
123			}
124
125			/**
126			* {@inheritDoc}
127			*/
128			public function preInsert(ConnectionInterface $con = null)
129			{
130			$this->setPosition($this->getNextPosition());
131
132			$this->dispatchEvent(TheliaEvents::BEFORE_CREATECATEGORY, new CategoryEvent($this));
133
134			return true;
135			}
136
137			/**
138			* {@inheritDoc}
139			*/
140			public function postInsert(ConnectionInterface $con = null)
141			{
142			$this->dispatchEvent(TheliaEvents::AFTER_CREATECATEGORY, new CategoryEvent($this));
143			}
144
145			/**
146			* {@inheritDoc}
147			*/
148			public function preUpdate(ConnectionInterface $con = null)
149			{
150			$this->dispatchEvent(TheliaEvents::BEFORE_UPDATECATEGORY, new CategoryEvent($this));
151
152			return true;
153			}
154
155			/**
156			* {@inheritDoc}
157			*/
158			public function postUpdate(ConnectionInterface $con = null)
159			{
160			$this->dispatchEvent(TheliaEvents::AFTER_UPDATECATEGORY, new CategoryEvent($this));
161			}
162
163			/**
164			* {@inheritDoc}
165			*/
166			public function preDelete(ConnectionInterface $con = null)
167			{
168			$this->dispatchEvent(TheliaEvents::BEFORE_DELETECATEGORY, new CategoryEvent($this));
169			$this->reorderBeforeDelete(
170			array(
171			"parent" => $this->getParent(),
172			)
173			);
174			$this->deleteProducts($con);
175
176			return true;
177			}
178
179			/**
180			* {@inheritDoc}
181			*/
182			public function postDelete(ConnectionInterface $con = null)
183			{
184			$this->markRewrittenUrlObsolete();
185
186			//delete all subcategories
187			$subCategories = CategoryQuery::findAllChild($this->getId());
188
189			foreach ($subCategories as $category) {
190			if (!is_null($this->dispatcher)) {
191			$category->setDispatcher($this->getDispatcher());
192			}
193
194			$category->delete();
195			}
196
197			$this->dispatchEvent(TheliaEvents::AFTER_DELETECATEGORY, new CategoryEvent($this));
198			}
199
200			/**
201			* Overload for the position management
202			* @param Base\ProductCategory $productCategory
203			* @inheritdoc
204			*/
205			protected function doAddProductCategory($productCategory)
206			{
207			parent::doAddProductCategory($productCategory);
208
209			$productCategoryPosition = ProductCategoryQuery::create()
210			->filterByCategoryId($productCategory->getCategoryId())
211			->orderByPosition(Criteria::DESC)
212			->findOne();
213
214			$productCategory->setPosition($productCategoryPosition !== null ? $productCategoryPosition->getPosition() + 1 : 1);
215			}
216			}
217

thelia / thelia

Pull Request — master (#2356)

Category::countAllProductsVisibleOnly() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like