Issues in Product.php - New Issues - Inspection of "Merge pull request #9382 from pamil/1.2-commands" - Sylius/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d81c19...f57266 )

by Kamil

created 2018-05-01 12:50 UTC

src/Sylius/Component/Core/Model/Product.php (4 issues)

Labels

Severity

Major 4

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Sylius\Component\Core\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Sylius\Component\Channel\Model\ChannelInterface as BaseChannelInterface;
use Sylius\Component\Product\Model\Product as BaseProduct;
use Sylius\Component\Product\Model\ProductTranslationInterface as BaseProductTranslationInterface;
use Sylius\Component\Resource\Model\TranslationInterface;
use Sylius\Component\Review\Model\ReviewInterface;
use Sylius\Component\Taxonomy\Model\TaxonInterface as BaseTaxonInterface;
use Webmozart\Assert\Assert;

class Product extends BaseProduct implements ProductInterface, ReviewableProductInterface
{
    /**
     * @var string
     */
    protected $variantSelectionMethod = self::VARIANT_SELECTION_CHOICE;

    /**
     * @var Collection|ProductTaxonInterface[]
     */
    protected $productTaxons;

    /**
     * @var Collection|ChannelInterface[]
     */
    protected $channels;

    /**
     * @var BaseTaxonInterface
     */
    protected $mainTaxon;

    /**
     * @var Collection|ReviewInterface[]
     */
    protected $reviews;

    /**
     * @var float
     */
    protected $averageRating = 0;

    /**
     * @var Collection|ImageInterface[]
     */
    protected $images;

    public function __construct()
    {
        parent::__construct();

        $this->productTaxons = new ArrayCollection();

        $this->channels = new ArrayCollection();

        $this->reviews = new ArrayCollection();

        $this->images = new ArrayCollection();

    }

    /**
     * {@inheritdoc}
     */
    public function getVariantSelectionMethod(): string
    {
        return $this->variantSelectionMethod;
    }

    /**
     * {@inheritdoc}
     */
    public function setVariantSelectionMethod(?string $variantSelectionMethod): void
    {
        Assert::oneOf(
            $variantSelectionMethod,
            [self::VARIANT_SELECTION_CHOICE, self::VARIANT_SELECTION_MATCH],
            sprintf('Wrong variant selection method "%s" given.', $variantSelectionMethod)
        );

        $this->variantSelectionMethod = $variantSelectionMethod;
    }

    /**
     * {@inheritdoc}
     */
    public function isVariantSelectionMethodChoice(): bool
    {
        return self::VARIANT_SELECTION_CHOICE === $this->variantSelectionMethod;
    }

    /**
     * {@inheritdoc}
     */
    public function getVariantSelectionMethodLabel(): string
    {
        $labels = self::getVariantSelectionMethodLabels();

        return $labels[$this->variantSelectionMethod];
    }

    /**
     * {@inheritdoc}
     */
    public function getProductTaxons(): Collection
    {
        return $this->productTaxons;
    }

    /**
     * {@inheritdoc}
     */
    public function addProductTaxon(ProductTaxonInterface $productTaxon): void
    {
        if (!$this->hasProductTaxon($productTaxon)) {
            $this->productTaxons->add($productTaxon);
            $productTaxon->setProduct($this);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeProductTaxon(ProductTaxonInterface $productTaxon): void
    {
        if ($this->hasProductTaxon($productTaxon)) {
            $this->productTaxons->removeElement($productTaxon);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasProductTaxon(ProductTaxonInterface $productTaxon): bool
    {
        return $this->productTaxons->contains($productTaxon);
    }

    /**
     * {@inheritdoc}
     */
    public function getTaxons(): Collection
    {
        return $this->productTaxons->map(function (ProductTaxonInterface $productTaxon): TaxonInterface {
            return $productTaxon->getTaxon();
        });
    }

    /**
     * {@inheritdoc}
     */
    public function hasTaxon(TaxonInterface $taxon): bool
    {
        return $this->getTaxons()->contains($taxon);
    }

    /**
     * {@inheritdoc}
     */
    public function getChannels(): Collection
    {
        return $this->channels;
    }

    /**
     * {@inheritdoc}
     */
    public function addChannel(BaseChannelInterface $channel): void
    {
        if (!$this->hasChannel($channel)) {
            $this->channels->add($channel);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeChannel(BaseChannelInterface $channel): void
    {
        if ($this->hasChannel($channel)) {
            $this->channels->removeElement($channel);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasChannel(BaseChannelInterface $channel): bool
    {
        return $this->channels->contains($channel);
    }

    /**
     * {@inheritdoc}
     */
    public function getShortDescription(): ?string
    {
        return $this->getTranslation()->getShortDescription();
    }

    /**
     * {@inheritdoc}
     */
    public function setShortDescription(?string $shortDescription): void
    {
        $this->getTranslation()->setShortDescription($shortDescription);
    }

    /**
     * {@inheritdoc}
     */
    public function getMainTaxon(): ?TaxonInterface
    {
        return $this->mainTaxon;
    }

    /**
     * {@inheritdoc}
     */
    public function setMainTaxon(?TaxonInterface $mainTaxon): void
    {
        $this->mainTaxon = $mainTaxon;
    }

    /**
     * {@inheritdoc}
     */
    public function getReviews(): Collection
    {
        return $this->reviews;
    }

    /**
     * {@inheritdoc}
     */
    public function getAcceptedReviews(): Collection
    {
        return $this->reviews->filter(function (ReviewInterface $review): bool {
            return ReviewInterface::STATUS_ACCEPTED === $review->getStatus();
        });
    }

    /**
     * {@inheritdoc}
     */
    public function addReview(ReviewInterface $review): void
    {
        $this->reviews->add($review);
    }

    /**
     * {@inheritdoc}
     */
    public function removeReview(ReviewInterface $review): void
    {
        $this->reviews->removeElement($review);
    }

    /**
     * {@inheritdoc}
     */
    public function getAverageRating(): ?float
    {
        return $this->averageRating;
    }

    /**
     * {@inheritdoc}
     */
    public function setAverageRating(float $averageRating): void
    {
        $this->averageRating = $averageRating;
    }

    /**
     * {@inheritdoc}
     */
    public function getImages(): Collection
    {
        return $this->images;
    }

    /**
     * {@inheritdoc}
     */
    public function getImagesByType(string $type): Collection
    {
        return $this->images->filter(function (ImageInterface $image) use ($type): bool {
            return $type === $image->getType();
        });
    }

    /**
     * {@inheritdoc}
     */
    public function hasImages(): bool
    {
        return !$this->images->isEmpty();
    }

    /**
     * {@inheritdoc}
     */
    public function hasImage(ImageInterface $image): bool
    {
        return $this->images->contains($image);
    }

    /**
     * {@inheritdoc}
     */
    public function addImage(ImageInterface $image): void
    {
        $image->setOwner($this);
        $this->images->add($image);
    }

    /**
     * {@inheritdoc}
     */
    public function removeImage(ImageInterface $image): void
    {
        if ($this->hasImage($image)) {
            $image->setOwner(null);
            $this->images->removeElement($image);
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getVariantSelectionMethodLabels(): array
    {
        return [
            self::VARIANT_SELECTION_CHOICE => 'sylius.ui.variant_choice',
            self::VARIANT_SELECTION_MATCH => 'sylius.ui.options_matching',
        ];
    }

    /**
     * @param string|null $locale
     *
     * @return ProductTranslationInterface
     */
    public function getTranslation(?string $locale = null): TranslationInterface
    {
        return parent::getTranslation($locale);
    }

    /**
     * {@inheritdoc}
     */
    protected function createTranslation(): BaseProductTranslationInterface
    {
        return new ProductTranslation();
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
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			declare(strict_types=1);
13
14			namespace Sylius\Component\Core\Model;
15
16			use Doctrine\Common\Collections\ArrayCollection;
17			use Doctrine\Common\Collections\Collection;
18			use Sylius\Component\Channel\Model\ChannelInterface as BaseChannelInterface;
19			use Sylius\Component\Product\Model\Product as BaseProduct;
20			use Sylius\Component\Product\Model\ProductTranslationInterface as BaseProductTranslationInterface;
21			use Sylius\Component\Resource\Model\TranslationInterface;
22			use Sylius\Component\Review\Model\ReviewInterface;
23			use Sylius\Component\Taxonomy\Model\TaxonInterface as BaseTaxonInterface;
24			use Webmozart\Assert\Assert;
25
26			class Product extends BaseProduct implements ProductInterface, ReviewableProductInterface
27			{
28			/**
29			* @var string
30			*/
31			protected $variantSelectionMethod = self::VARIANT_SELECTION_CHOICE;
32
33			/**
34			* @var Collection\|ProductTaxonInterface[]
35			*/
36			protected $productTaxons;
37
38			/**
39			* @var Collection\|ChannelInterface[]
40			*/
41			protected $channels;
42
43			/**
44			* @var BaseTaxonInterface
45			*/
46			protected $mainTaxon;
47
48			/**
49			* @var Collection\|ReviewInterface[]
50			*/
51			protected $reviews;
52
53			/**
54			* @var float
55			*/
56			protected $averageRating = 0;
57
58			/**
59			* @var Collection\|ImageInterface[]
60			*/
61			protected $images;
62
63			public function __construct()
64			{
65			parent::__construct();
66
67			$this->productTaxons = new ArrayCollection();
			0 ignored issues – show Documentation Bug introduced 2018-03-11 19:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `new \Doctrine\Common\Collections\ArrayCollection()` of type `object<Doctrine\Common\C...ctions\ArrayCollection>` is incompatible with the declared type `object<Doctrine\Common\C...ProductTaxonInterface>>` of property `$productTaxons`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
68			$this->channels = new ArrayCollection();
			0 ignored issues – show Documentation Bug introduced 2018-03-11 19:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `new \Doctrine\Common\Collections\ArrayCollection()` of type `object<Doctrine\Common\C...ctions\ArrayCollection>` is incompatible with the declared type `object<Doctrine\Common\C...odel\ChannelInterface>>` of property `$channels`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
69			$this->reviews = new ArrayCollection();
			0 ignored issues – show Documentation Bug introduced 2018-03-11 19:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `new \Doctrine\Common\Collections\ArrayCollection()` of type `object<Doctrine\Common\C...ctions\ArrayCollection>` is incompatible with the declared type `object<Doctrine\Common\C...Model\ReviewInterface>>` of property `$reviews`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
70			$this->images = new ArrayCollection();
			0 ignored issues – show Documentation Bug introduced 2018-03-11 19:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `new \Doctrine\Common\Collections\ArrayCollection()` of type `object<Doctrine\Common\C...ctions\ArrayCollection>` is incompatible with the declared type `object<Doctrine\Common\C...\Model\ImageInterface>>` of property `$images`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
71			}
72
73			/**
74			* {@inheritdoc}
75			*/
76			public function getVariantSelectionMethod(): string
77			{
78			return $this->variantSelectionMethod;
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84			public function setVariantSelectionMethod(?string $variantSelectionMethod): void
85			{
86			Assert::oneOf(
87			$variantSelectionMethod,
88			[self::VARIANT_SELECTION_CHOICE, self::VARIANT_SELECTION_MATCH],
89			sprintf('Wrong variant selection method "%s" given.', $variantSelectionMethod)
90			);
91
92			$this->variantSelectionMethod = $variantSelectionMethod;
93			}
94
95			/**
96			* {@inheritdoc}
97			*/
98			public function isVariantSelectionMethodChoice(): bool
99			{
100			return self::VARIANT_SELECTION_CHOICE === $this->variantSelectionMethod;
101			}
102
103			/**
104			* {@inheritdoc}
105			*/
106			public function getVariantSelectionMethodLabel(): string
107			{
108			$labels = self::getVariantSelectionMethodLabels();
109
110			return $labels[$this->variantSelectionMethod];
111			}
112
113			/**
114			* {@inheritdoc}
115			*/
116			public function getProductTaxons(): Collection
117			{
118			return $this->productTaxons;
119			}
120
121			/**
122			* {@inheritdoc}
123			*/
124			public function addProductTaxon(ProductTaxonInterface $productTaxon): void
125			{
126			if (!$this->hasProductTaxon($productTaxon)) {
127			$this->productTaxons->add($productTaxon);
128			$productTaxon->setProduct($this);
129			}
130			}
131
132			/**
133			* {@inheritdoc}
134			*/
135			public function removeProductTaxon(ProductTaxonInterface $productTaxon): void
136			{
137			if ($this->hasProductTaxon($productTaxon)) {
138			$this->productTaxons->removeElement($productTaxon);
139			}
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public function hasProductTaxon(ProductTaxonInterface $productTaxon): bool
146			{
147			return $this->productTaxons->contains($productTaxon);
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153			public function getTaxons(): Collection
154			{
155			return $this->productTaxons->map(function (ProductTaxonInterface $productTaxon): TaxonInterface {
156			return $productTaxon->getTaxon();
157			});
158			}
159
160			/**
161			* {@inheritdoc}
162			*/
163			public function hasTaxon(TaxonInterface $taxon): bool
164			{
165			return $this->getTaxons()->contains($taxon);
166			}
167
168			/**
169			* {@inheritdoc}
170			*/
171			public function getChannels(): Collection
172			{
173			return $this->channels;
174			}
175
176			/**
177			* {@inheritdoc}
178			*/
179			public function addChannel(BaseChannelInterface $channel): void
180			{
181			if (!$this->hasChannel($channel)) {
182			$this->channels->add($channel);
183			}
184			}
185
186			/**
187			* {@inheritdoc}
188			*/
189			public function removeChannel(BaseChannelInterface $channel): void
190			{
191			if ($this->hasChannel($channel)) {
192			$this->channels->removeElement($channel);
193			}
194			}
195
196			/**
197			* {@inheritdoc}
198			*/
199			public function hasChannel(BaseChannelInterface $channel): bool
200			{
201			return $this->channels->contains($channel);
202			}
203
204			/**
205			* {@inheritdoc}
206			*/
207			public function getShortDescription(): ?string
208			{
209			return $this->getTranslation()->getShortDescription();
210			}
211
212			/**
213			* {@inheritdoc}
214			*/
215			public function setShortDescription(?string $shortDescription): void
216			{
217			$this->getTranslation()->setShortDescription($shortDescription);
218			}
219
220			/**
221			* {@inheritdoc}
222			*/
223			public function getMainTaxon(): ?TaxonInterface
224			{
225			return $this->mainTaxon;
226			}
227
228			/**
229			* {@inheritdoc}
230			*/
231			public function setMainTaxon(?TaxonInterface $mainTaxon): void
232			{
233			$this->mainTaxon = $mainTaxon;
234			}
235
236			/**
237			* {@inheritdoc}
238			*/
239			public function getReviews(): Collection
240			{
241			return $this->reviews;
242			}
243
244			/**
245			* {@inheritdoc}
246			*/
247			public function getAcceptedReviews(): Collection
248			{
249			return $this->reviews->filter(function (ReviewInterface $review): bool {
250			return ReviewInterface::STATUS_ACCEPTED === $review->getStatus();
251			});
252			}
253
254			/**
255			* {@inheritdoc}
256			*/
257			public function addReview(ReviewInterface $review): void
258			{
259			$this->reviews->add($review);
260			}
261
262			/**
263			* {@inheritdoc}
264			*/
265			public function removeReview(ReviewInterface $review): void
266			{
267			$this->reviews->removeElement($review);
268			}
269
270			/**
271			* {@inheritdoc}
272			*/
273			public function getAverageRating(): ?float
274			{
275			return $this->averageRating;
276			}
277
278			/**
279			* {@inheritdoc}
280			*/
281			public function setAverageRating(float $averageRating): void
282			{
283			$this->averageRating = $averageRating;
284			}
285
286			/**
287			* {@inheritdoc}
288			*/
289			public function getImages(): Collection
290			{
291			return $this->images;
292			}
293
294			/**
295			* {@inheritdoc}
296			*/
297			public function getImagesByType(string $type): Collection
298			{
299			return $this->images->filter(function (ImageInterface $image) use ($type): bool {
300			return $type === $image->getType();
301			});
302			}
303
304			/**
305			* {@inheritdoc}
306			*/
307			public function hasImages(): bool
308			{
309			return !$this->images->isEmpty();
310			}
311
312			/**
313			* {@inheritdoc}
314			*/
315			public function hasImage(ImageInterface $image): bool
316			{
317			return $this->images->contains($image);
318			}
319
320			/**
321			* {@inheritdoc}
322			*/
323			public function addImage(ImageInterface $image): void
324			{
325			$image->setOwner($this);
326			$this->images->add($image);
327			}
328
329			/**
330			* {@inheritdoc}
331			*/
332			public function removeImage(ImageInterface $image): void
333			{
334			if ($this->hasImage($image)) {
335			$image->setOwner(null);
336			$this->images->removeElement($image);
337			}
338			}
339
340			/**
341			* {@inheritdoc}
342			*/
343			public static function getVariantSelectionMethodLabels(): array
344			{
345			return [
346			self::VARIANT_SELECTION_CHOICE => 'sylius.ui.variant_choice',
347			self::VARIANT_SELECTION_MATCH => 'sylius.ui.options_matching',
348			];
349			}
350
351			/**
352			* @param string\|null $locale
353			*
354			* @return ProductTranslationInterface
355			*/
356			public function getTranslation(?string $locale = null): TranslationInterface
357			{
358			return parent::getTranslation($locale);
359			}
360
361			/**
362			* {@inheritdoc}
363			*/
364			protected function createTranslation(): BaseProductTranslationInterface
365			{
366			return new ProductTranslation();
367			}
368			}
369

Sylius / Sylius

Push — master ( d81c19...f57266 )

src/Sylius/Component/Core/Model/Product.php (4 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like