Sylius\Component\Product\Model\Product

Complexity

Total Complexity

68

Size/Duplication

Total Lines	469
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	11

Importance

Changes

0

41 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	__toString()	0	4	1
A	getId()	0	4	1
A	getCode()	0	4	1
A	setCode()	0	4	1
A	getName()	0	4	1
A	setName()	0	4	1
A	getSlug()	0	4	1
A	setSlug()	0	4	1
A	getDescription()	0	4	1
A	setDescription()	0	4	1
A	getMetaKeywords()	0	4	1
A	setMetaKeywords()	0	4	1
A	getMetaDescription()	0	4	1
A	setMetaDescription()	0	4	1
A	getAttributes()	0	4	1
B	getAttributesByLocale()	0	23	4
A	addAttribute()	0	13	2
A	removeAttribute()	0	13	2
A	hasAttribute()	0	4	1
B	hasAttributeByCodeAndLocale()	0	13	5
B	getAttributeByCodeAndLocale()	0	15	5
A	hasVariants()	0	4	1
A	getVariants()	0	4	1
A	addVariant()	0	7	2
A	removeVariant()	0	7	2
A	hasVariant()	0	4	1
A	hasOptions()	0	4	1
A	getOptions()	0	4	1
A	addOption()	0	6	2
A	removeOption()	0	6	2
A	hasOption()	0	4	1
A	getAssociations()	0	4	1
A	addAssociation()	0	7	2
A	removeAssociation()	0	7	2
A	hasAssociation()	0	4	1
A	isSimple()	0	4	2
A	isConfigurable()	0	4	1
A	createTranslation()	0	4	1
A	getAttributeInDifferentLocale()	0	18	4
B	hasNotEmptyAttributeByCodeAndLocale()	0	14	5

<?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\Product\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Sylius\Component\Attribute\Model\AttributeValueInterface;
use Sylius\Component\Resource\Model\TimestampableTrait;
use Sylius\Component\Resource\Model\ToggleableTrait;
use Sylius\Component\Resource\Model\TranslatableTrait;
use Webmozart\Assert\Assert;

/**
 * @author Paweł Jędrzejewski <pawel@sylius.org>
 * @author Gonzalo Vilaseca <gvilaseca@reiss.co.uk>
 */
class Product implements ProductInterface
{
    use TimestampableTrait, ToggleableTrait;
    use TranslatableTrait {
        __construct as private initializeTranslationsCollection;
    }

    /**
     * @var mixed
     */
    protected $id;

    /**
     * @var string
     */
    protected $code;

    /**
     * @var Collection|AttributeValueInterface[]
     */
    protected $attributes;

    /**
     * @var Collection|ProductVariantInterface[]
     */
    protected $variants;

    /**
     * @var Collection|ProductOptionInterface[]
     */
    protected $options;

    /**
     * @var Collection|ProductAssociationInterface[]
     */
    protected $associations;

    public function __construct()
    {
        $this->initializeTranslationsCollection();

        $this->createdAt = new \DateTime();
        $this->attributes = new ArrayCollection();
        $this->associations = new ArrayCollection();
        $this->variants = new ArrayCollection();
        $this->options = new ArrayCollection();
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return (string) $this->getName();
    }

    /**
     * {@inheritdoc}
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return string
     */
    public function getCode(): ?string
    {
        return $this->code;
    }

    /**
     * @param string $code
     */
    public function setCode(?string $code): void
    {
        $this->code = $code;
    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method getName() does only exist in the following implementations of said interface: Sylius\Component\Attribute\Model\AttributeTranslation, Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Payment\Model\PaymentMethodTranslation, Sylius\Component\Product\Model\ProductAssociationTypeTranslation, Sylius\Component\Product\Model\ProductAttributeTranslation, Sylius\Component\Product\Model\ProductOptionTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Product\Model\ProductVariantTranslation, Sylius\Component\Shipping\Model\ShippingMethodTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method setName() does only exist in the following implementations of said interface: Sylius\Component\Attribute\Model\AttributeTranslation, Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Payment\Model\PaymentMethodTranslation, Sylius\Component\Product\Model\ProductAssociationTypeTranslation, Sylius\Component\Product\Model\ProductAttributeTranslation, Sylius\Component\Product\Model\ProductOptionTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Product\Model\ProductVariantTranslation, Sylius\Component\Shipping\Model\ShippingMethodTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method getSlug() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method setSlug() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method getDescription() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Payment\Model\PaymentMethodTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Shipping\Model\ShippingMethodTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method setDescription() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Payment\Model\PaymentMethodTranslation, Sylius\Component\Product\Model\ProductTranslation, Sylius\Component\Shipping\Model\ShippingMethodTranslation, Sylius\Component\Taxonomy\Model\TaxonTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method getMetaKeywords() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method setMetaKeywords() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method getMetaDescription() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation.

    }

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

It seems like you code against a concrete implementation and not the interface Sylius\Component\Resource\Model\TranslationInterface as the method setMetaDescription() does only exist in the following implementations of said interface: Sylius\Component\Core\Model\ProductTranslation, Sylius\Component\Product\Model\ProductTranslation.

    }

    public function getAttributes(): Collection
    {
        return $this->attributes;
    }

    /**
     * {@inheritdoc}
     */
    public function getAttributesByLocale(
        string $localeCode,
        string $fallbackLocaleCode,
        ?string $baseLocaleCode = null
    ): Collection {
        if (null === $baseLocaleCode || $baseLocaleCode === $fallbackLocaleCode) {
            $baseLocaleCode = $fallbackLocaleCode;
            $fallbackLocaleCode = null;
        }

        $attributes = $this->attributes->filter(
            function (ProductAttributeValueInterface $attribute) use ($baseLocaleCode) {
                return $attribute->getLocaleCode() === $baseLocaleCode;
            }
        );

        $attributesWithFallback = [];
        foreach ($attributes as $attribute) {
            $attributesWithFallback[] = $this->getAttributeInDifferentLocale($attribute, $localeCode, $fallbackLocaleCode);
        }

        return new ArrayCollection($attributesWithFallback);
    }

    /**
     * {@inheritdoc}
     */
    public function addAttribute(?AttributeValueInterface $attribute): void
    {
        Assert::isInstanceOf(
            $attribute,
            ProductAttributeValueInterface::class,
            'Attribute objects added to a Product object have to implement ProductAttributeValueInterface'
        );

        if (!$this->hasAttribute($attribute)) {
            $attribute->setProduct($this);

It seems like you code against a concrete implementation and not the interface Sylius\Component\Attribute\Model\AttributeValueInterface as the method setProduct() does only exist in the following implementations of said interface: Sylius\Component\Product\Model\ProductAttributeValue.

            $this->attributes->add($attribute);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeAttribute(?AttributeValueInterface $attribute): void
    {
        Assert::isInstanceOf(
            $attribute,
            ProductAttributeValueInterface::class,
            'Attribute objects removed from a Product object have to implement ProductAttributeValueInterface'
        );

        if ($this->hasAttribute($attribute)) {
            $this->attributes->removeElement($attribute);
            $attribute->setProduct(null);

It seems like you code against a concrete implementation and not the interface Sylius\Component\Attribute\Model\AttributeValueInterface as the method setProduct() does only exist in the following implementations of said interface: Sylius\Component\Product\Model\ProductAttributeValue.

        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasAttribute(AttributeValueInterface $attribute): bool
    {
        return $this->attributes->contains($attribute);
    }

    /**
     * {@inheritdoc}
     */
    public function hasAttributeByCodeAndLocale(string $attributeCode, ?string $localeCode = null): bool
    {
        $localeCode = $localeCode ?: $this->getTranslation()->getLocale();

        foreach ($this->attributes as $attribute) {
            if ($attribute->getAttribute()->getCode() === $attributeCode
                && $attribute->getLocaleCode() === $localeCode) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getAttributeByCodeAndLocale(string $attributeCode, ?string $localeCode = null): ?AttributeValueInterface
    {
        if (null === $localeCode) {
            $localeCode = $this->getTranslation()->getLocale();
        }

        foreach ($this->attributes as $attribute) {
            if ($attribute->getAttribute()->getCode() === $attributeCode &&
                $attribute->getLocaleCode() === $localeCode) {
                return $attribute;
            }
        }

        return null;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function addVariant(ProductVariantInterface $variant): void
    {
        if (!$this->hasVariant($variant)) {
            $variant->setProduct($this);
            $this->variants->add($variant);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeVariant(ProductVariantInterface $variant): void
    {
        if ($this->hasVariant($variant)) {
            $variant->setProduct(null);
            $this->variants->removeElement($variant);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasVariant(ProductVariantInterface $variant): bool
    {
        return $this->variants->contains($variant);
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function addOption(ProductOptionInterface $option): void
    {
        if (!$this->hasOption($option)) {
            $this->options->add($option);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeOption(ProductOptionInterface $option): void
    {
        if ($this->hasOption($option)) {
            $this->options->removeElement($option);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasOption(ProductOptionInterface $option): bool
    {
        return $this->options->contains($option);
    }

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

    /**
     * {@inheritdoc}
     */
    public function addAssociation(ProductAssociationInterface $association): void
    {
        if (!$this->hasAssociation($association)) {
            $this->associations->add($association);
            $association->setOwner($this);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeAssociation(ProductAssociationInterface $association): void
    {
        if ($this->hasAssociation($association)) {
            $association->setOwner(null);
            $this->associations->removeElement($association);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasAssociation(ProductAssociationInterface $association): bool
    {
        return $this->associations->contains($association);
    }

    /**
     * {@inheritdoc}
     */
    public function isSimple(): bool
    {
        return 1 === $this->variants->count() && !$this->hasOptions();
    }

    /**
     * {@inheritdoc}
     */
    public function isConfigurable(): bool
    {
        return !$this->isSimple();
    }

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

    /**
     * @param ProductAttributeValueInterface $attributeValue
     * @param string $localeCode
     * @param string|null $fallbackLocaleCode
     *
     * @return AttributeValueInterface
     */
    private function getAttributeInDifferentLocale(
        ProductAttributeValueInterface $attributeValue,
        string $localeCode,
        ?string $fallbackLocaleCode = null
    ): AttributeValueInterface {
        if (!$this->hasNotEmptyAttributeByCodeAndLocale($attributeValue->getCode(), $localeCode)) {
            if (
                null !== $fallbackLocaleCode &&
                $this->hasNotEmptyAttributeByCodeAndLocale($attributeValue->getCode(), $fallbackLocaleCode))
            {
                return $this->getAttributeByCodeAndLocale($attributeValue->getCode(), $fallbackLocaleCode);
            }

            return $attributeValue;
        }

        return $this->getAttributeByCodeAndLocale($attributeValue->getCode(), $localeCode);
    }

    /**
     * @param string $attributeCode
     * @param string $localeCode
     *
     * @return bool
     */
    private function hasNotEmptyAttributeByCodeAndLocale(string $attributeCode, string $localeCode): bool
    {
        $attributeValue = $this->getAttributeByCodeAndLocale($attributeCode, $localeCode);
        if (null === $attributeValue) {
            return false;
        }

        $value = $attributeValue->getValue();
        if ('' === $value || null === $value || [] === $value) {

This if statement, and the following return statement can be replaced with return !('' === $value || null === $value || array() === $value);.

            return false;
        }

        return true;
    }
}