WellCommerce\Bundle\CatalogBundle\Helper\VariantHelper

Complexity

Total Complexity

12

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getVariants()	0	12	2
A	getAttributes()	0	12	2
A	extractAttributesData()	0	9	1
A	extractVariantData()	0	20	1
A	getPhoto()	0	8	2
A	getVariantOptionsKey()	0	15	1
A	getVariantOptions()	0	12	1
A	sortOptions()	0	4	1

<?php
/*
 * WellCommerce Open-Source E-Commerce Platform
 * 
 * This file is part of the WellCommerce package.
 *
 * (c) Adam Piotrowski <adam@wellcommerce.org>
 * 
 * For the full copyright and license information,
 * please view the LICENSE file that was distributed with this source code.
 */

namespace WellCommerce\Bundle\CatalogBundle\Helper;

use WellCommerce\Bundle\AppBundle\Entity\Media;
use WellCommerce\Bundle\AppBundle\Helper\CurrencyHelperInterface;
use WellCommerce\Bundle\CatalogBundle\Entity\Product;
use WellCommerce\Bundle\CatalogBundle\Entity\Variant;
use WellCommerce\Bundle\CatalogBundle\Entity\VariantOption;

/**
 * Class VariantHelper
 *
 * @author  Adam Piotrowski <adam@wellcommerce.org>
 */
class VariantHelper implements VariantHelperInterface
{
    /**
     * @var CurrencyHelperInterface
     */
    protected $currencyHelper;
    
    /**
     * VariantHelper constructor.
     *
     * @param CurrencyHelperInterface $currencyHelper
     */
    public function __construct(CurrencyHelperInterface $currencyHelper)
    {
        $this->currencyHelper = $currencyHelper;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getVariants(Product $product): array
    {
        $variants = [];
        
        $product->getVariants()->map(function (Variant $variant) use (&$variants) {
            if ($variant->isEnabled()) {
                $this->extractVariantData($variant, $variants);
            }
        });
        
        return $variants;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getAttributes(Product $product): array
    {
        $attributes = [];
        
        $product->getVariants()->map(function (Variant $variant) use (&$attributes) {
            if ($variant->isEnabled()) {
                $this->extractAttributesData($variant, $attributes);
            }
        });
        
        return $attributes;
    }
    
    protected function extractAttributesData(Variant $variant, &$attributes)
    {
        $variant->getOptions()->map(function (VariantOption $variantOption) use (&$attributes) {
            $attribute                                                           = $variantOption->getAttribute();
            $attributeValue                                                      = $variantOption->getAttributeValue();
            $attributes[$attribute->getId()]['name']                             = $attribute->translate()->getName();
            $attributes[$attribute->getId()]['values'][$attributeValue->getId()] = $attributeValue->translate()->getName();
        });
    }
    
    protected function extractVariantData(Variant $variant, array &$variants)
    {
        $sellPrice    = $variant->getSellPrice();
        $baseCurrency = $sellPrice->getCurrency();
        $key          = $this->getVariantOptionsKey($variant);
        
        $variants[$key] = [
            'id'                 => $variant->getId(),
            'finalPriceGross'    => $this->currencyHelper->convertAndFormat($sellPrice->getFinalGrossAmount(), $baseCurrency),
            'sellPriceGross'     => $this->currencyHelper->convertAndFormat($sellPrice->getGrossAmount(), $baseCurrency),
            'discountPriceGross' => $this->currencyHelper->convertAndFormat($sellPrice->getDiscountedGrossAmount(), $baseCurrency),
            'finalPriceNet'      => $this->currencyHelper->convertAndFormat($sellPrice->getFinalNetAmount(), $baseCurrency),
            'sellPriceNet'       => $this->currencyHelper->convertAndFormat($sellPrice->getNetAmount(), $baseCurrency),
            'discountPriceNet'   => $this->currencyHelper->convertAndFormat($sellPrice->getDiscountedNetAmount(), $baseCurrency),
            'stock'              => $variant->getStock(),
            'symbol'             => $variant->getSymbol(),
            'options'            => $this->getVariantOptions($variant),
            'photo'              => $this->getPhoto($variant->getPhoto()),
        ];
    }
    
    protected function getPhoto(Media $media = null): string
    {
        if ($media instanceof Media) {
            return $media->getPath();
        }
        
        return '';
    }
    
    protected function getVariantOptionsKey(Variant $variant): string
    {
        $options = [];
        
        $variant->getOptions()->map(function (VariantOption $variantOption) use (&$options) {
            $attribute      = $variantOption->getAttribute();
            $attributeValue = $variantOption->getAttributeValue();
            $key            = sprintf('%s:%s', $attribute->getId(), $attributeValue->getId());
            $options[$key]  = $key;
        });
        
        ksort($options);
        
        return implode(',', $options);
    }
    
    public function getVariantOptions(Variant $variant): array
    {
        $options = [];
        
        $variant->getOptions()->map(function (VariantOption $variantOption) use (&$options) {
            $attribute                                   = $variantOption->getAttribute();
            $attributeValue                              = $variantOption->getAttributeValue();
            $options[$attribute->translate()->getName()] = $attributeValue->translate()->getName();
        });
        
        return $options;
    }
    
    public function sortOptions(array &$options)
    {
        ksort($options);
    }
}