PyzTest\Zed\Calculation\CalculationBusinessTester

Complexity

Total Complexity

32

Size/Duplication

Total Lines	305
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	createAbstractProduct()	0	9	1
A	createProductOptionTransfer()	0	18	3
A	createAbstractProductWithTaxExemption()	0	12	1
A	recalculateCanceledAmount()	0	20	3
A	createCurrencyTransfer()	0	4	1
A	getCurrentStoreTransfer()	0	5	1
A	getCurrentShippingAddress()	0	3	1
A	createExpenseTransfer()	0	15	3
A	isCanceledAmount()	0	9	3
A	resetCurrentDiscounts()	0	8	2
A	createItemTransfer()	0	20	3
A	getCurrency()	0	3	1
A	createCalculationFacade()	0	22	2
A	createTaxSetTax()	0	7	1
A	getIncrementNumber()	0	3	1
A	createTaxSet()	0	7	1
A	createDiscountTransfer()	0	6	1
A	createProductOptionValue()	0	25	1
A	createDiscounts()	0	43	1
A	createAbstractProductWithTaxSet()	0	15	1

<?php

/**
 * This file is part of the Spryker Commerce OS.
 * For full license information, please view the LICENSE file that was distributed with this source code.
 */

declare(strict_types = 1);

namespace PyzTest\Zed\Calculation;

use Codeception\Actor;
use DateTime;
use Generated\Shared\Transfer\AddressTransfer;

The type Generated\Shared\Transfer\AddressTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\CurrencyTransfer;

The type Generated\Shared\Transfer\CurrencyTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\DiscountTransfer;

The type Generated\Shared\Transfer\DiscountTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\ExpenseTransfer;

The type Generated\Shared\Transfer\ExpenseTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\ItemTransfer;

The type Generated\Shared\Transfer\ItemTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\ProductOptionTransfer;

The type Generated\Shared\Transfer\ProductOptionTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\QuoteTransfer;

The type Generated\Shared\Transfer\QuoteTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Generated\Shared\Transfer\StoreTransfer;

The type Generated\Shared\Transfer\StoreTransfer was not found. Maybe you did not declare it correctly or list all dependencies?

use Orm\Zed\Country\Persistence\SpyCountryQuery;
use Orm\Zed\Currency\Persistence\SpyCurrency;
use Orm\Zed\Currency\Persistence\SpyCurrencyQuery;
use Orm\Zed\Discount\Persistence\SpyDiscount;
use Orm\Zed\Discount\Persistence\SpyDiscountAmount;
use Orm\Zed\Discount\Persistence\SpyDiscountQuery;
use Orm\Zed\Discount\Persistence\SpyDiscountStore;
use Orm\Zed\Discount\Persistence\SpyDiscountVoucher;
use Orm\Zed\Discount\Persistence\SpyDiscountVoucherPool;
use Orm\Zed\Product\Persistence\SpyProductAbstract;
use Orm\Zed\ProductOption\Persistence\SpyProductOptionGroup;
use Orm\Zed\ProductOption\Persistence\SpyProductOptionValue;
use Orm\Zed\Tax\Persistence\SpyTaxRate;
use Orm\Zed\Tax\Persistence\SpyTaxSet;
use Orm\Zed\Tax\Persistence\SpyTaxSetTax;
use Pyz\Zed\Calculation\CalculationDependencyProvider;
use Pyz\Zed\Discount\DiscountDependencyProvider;
use Spryker\Shared\Calculation\CalculationPriceMode;
use Spryker\Shared\Tax\TaxConstants;
use Spryker\Zed\Calculation\Business\CalculationBusinessFactory;
use Spryker\Zed\Calculation\Business\CalculationFacade;
use Spryker\Zed\Calculation\Communication\Plugin\Calculator\GrandTotalCalculatorPlugin;
use Spryker\Zed\Calculation\Communication\Plugin\Calculator\RefundableAmountCalculatorPlugin;
use Spryker\Zed\Calculation\Communication\Plugin\Calculator\RefundTotalCalculatorPlugin;
use Spryker\Zed\Calculation\Dependency\Service\CalculationToUtilTextBridge;
use Spryker\Zed\Kernel\Container;

/**
 * Inherited Methods
 *
 * @method void wantToTest($text)
 * @method void wantTo($text)
 * @method void execute($callable)
 * @method void expectTo($prediction)
 * @method void expect($prediction)
 * @method void amGoingTo($argumentation)
 * @method void am($role)
 * @method void lookForwardTo($achieveValue)
 * @method void comment($description)
 * @method \Codeception\Lib\Friend haveFriend($name, $actorClass = NULL)
 *
 * @SuppressWarnings(\PyzTest\Zed\Calculation\PHPMD)
 */
class CalculationBusinessTester extends Actor
{
    use _generated\CalculationBusinessTesterActions;

The type PyzTest\Zed\Calculation\_generated\CalculationBusinessTesterActions was not found. Maybe you did not declare it correctly or list all dependencies?

    protected int $incrementNumber = 0;

    protected const COUNTRY_DE = 'DE';

    public function createDiscounts(int $discountAmount, string $calculatorType, string $sku = '*'): SpyDiscountVoucher
    {
        $discountVoucherPoolEntity = new SpyDiscountVoucherPool();
        $discountVoucherPoolEntity->setName('test-pool' . $this->getIncrementNumber());
        $discountVoucherPoolEntity->setIsActive(true);
        $discountVoucherPoolEntity->save();

        $discountVoucherEntity = new SpyDiscountVoucher();
        $discountVoucherEntity->setCode('spryker-test' . $this->getIncrementNumber());
        $discountVoucherEntity->setIsActive(true);
        $discountVoucherEntity->setFkDiscountVoucherPool($discountVoucherPoolEntity->getIdDiscountVoucherPool());
        $discountVoucherEntity->save();

        $discountEntity = new SpyDiscount();
        $discountEntity->setAmount($discountAmount);
        $discountEntity->setDisplayName('test1' . $this->getIncrementNumber());
        $discountEntity->setIsActive(1);
        $discountEntity->setValidFrom(new DateTime('1985-07-01'));
        $discountEntity->setValidTo(new DateTime('2030-07-01'));
        $discountEntity->setCalculatorPlugin($calculatorType);
        $discountEntity->setCollectorQueryString('sku = "' . $sku . '"');

        $discountEntity->setFkDiscountVoucherPool($discountVoucherPoolEntity->getIdDiscountVoucherPool());
        $discountEntity->save();

        (new SpyDiscountStore())
            ->setFkDiscount($discountEntity->getIdDiscount())
            ->setFkStore($this->getCurrentStoreTransfer()->getIdStore())
            ->save();

        $discountAmountEntity = new SpyDiscountAmount();
        $currencyEntity = $this->getCurrency();
        $discountAmountEntity->setFkCurrency($currencyEntity->getIdCurrency());
        $discountAmountEntity->setNetAmount($discountAmount);
        $discountAmountEntity->setGrossAmount($discountAmount);
        $discountAmountEntity->setFkDiscount($discountEntity->getIdDiscount());
        $discountAmountEntity->save();

        $discountEntity->reload(true);
        $pool = $discountEntity->getVoucherPool();
        $pool->getDiscountVouchers();

        return $discountVoucherEntity;
    }

    public function createExpenseTransfer(int $price, string $priceMode, float $taxRate, int $quantity): ExpenseTransfer
    {
        $expenseTransfer = new ExpenseTransfer();
        $expenseTransfer->setTaxRate($taxRate);
        $expenseTransfer->setQuantity($quantity);

        if ($priceMode === CalculationPriceMode::PRICE_MODE_GROSS) {
            $expenseTransfer->setUnitGrossPrice($price);
        }

        if ($priceMode === CalculationPriceMode::PRICE_MODE_NET) {
            $expenseTransfer->setUnitNetPrice($price);
        }

        return $expenseTransfer;
    }

    public function createCalculationFacade(array $calculatorPlugins = []): CalculationFacade
    {
        if (!$calculatorPlugins) {

The expression $calculatorPlugins of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return new CalculationFacade();
        }

        $calculationFacade = new CalculationFacade();

        $calculationBusinessFactory = new CalculationBusinessFactory();

        $container = new Container();
        $container[CalculationDependencyProvider::QUOTE_CALCULATOR_PLUGIN_STACK] = $calculatorPlugins;
        $container[CalculationDependencyProvider::PLUGINS_QUOTE_POST_RECALCULATE] = [];

        $container->set(CalculationDependencyProvider::SERVICE_UTIL_TEXT, function (Container $container) {
            return new CalculationToUtilTextBridge($container->getLocator()->utilText()->service());
        });

        $calculationBusinessFactory->setContainer($container);
        $calculationFacade->setFactory($calculationBusinessFactory);

        return $calculationFacade;
    }

    public function resetCurrentDiscounts(): void
    {
        $discounts = SpyDiscountQuery::create()->find();

        foreach ($discounts as $discountEntity) {
            $discountEntity->setIsActive(false);

            $discountEntity->save();
        }
    }

    /**
     * @param array<\Generated\Shared\Transfer\ItemTransfer> $items
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     */
    public function recalculateCanceledAmount(array $items, QuoteTransfer $quoteTransfer): QuoteTransfer
    {
        if (!$this->isCanceledAmount($items)) {
            return $quoteTransfer;
        }

        foreach ($quoteTransfer->getItems() as $itemTransferIndex => $itemTransfer) {
            $itemTransfer->setCanceledAmount($items[$itemTransferIndex][5]);
            $itemTransfer->setRefundableAmount($items[$itemTransferIndex][5]);
        }

        $calculationFacade = $this->createCalculationFacade(
            [
                new RefundableAmountCalculatorPlugin(),
                new RefundTotalCalculatorPlugin(),
                new GrandTotalCalculatorPlugin(),
            ],
        );

        return $calculationFacade->recalculateQuote($quoteTransfer);
    }

    public function createDiscountTransfer(int $discountAmount, string $sku): DiscountTransfer
    {
        $voucherEntity = $this->createDiscounts($discountAmount, DiscountDependencyProvider::PLUGIN_CALCULATOR_FIXED, $sku);

        return (new DiscountTransfer())
            ->setVoucherCode($voucherEntity->getCode());
    }

    public function getCurrentStoreTransfer(): StoreTransfer
    {
        return (new StoreTransfer())
            ->setIdStore(1)
            ->setName(static::COUNTRY_DE);
    }

    public function getCurrentShippingAddress(): AddressTransfer
    {
        return (new AddressTransfer())->setIso2Code(static::COUNTRY_DE);
    }

    public function createCurrencyTransfer(): CurrencyTransfer
    {
        return (new CurrencyTransfer())
            ->setCode('EUR');
    }

    public function createItemTransfer(int $price, string $priceMode, float $taxRate, int $quantity): ItemTransfer
    {
        $abstractProductEntity = $this->createAbstractProductWithTaxSet($taxRate);

        $itemTransfer = (new ItemTransfer())
            ->setName('test' . $this->getIncrementNumber())
            ->setIdProductAbstract($abstractProductEntity->getIdProductAbstract())
            ->setSku('test' . $this->getIncrementNumber())
            ->setQuantity($quantity)
            ->setTaxRate($taxRate);

        if ($priceMode === CalculationPriceMode::PRICE_MODE_GROSS) {
            $itemTransfer->setUnitGrossPrice($price);
        }

        if ($priceMode === CalculationPriceMode::PRICE_MODE_NET) {
            $itemTransfer->setUnitNetPrice($price);
        }

        return $itemTransfer;
    }

    public function createProductOptionTransfer(int $price, string $priceMode, float $taxRate, int $quantity): ProductOptionTransfer
    {
        $productOptionValueEntity = $this->createProductOptionValue($taxRate);

        $productOptionTransfer = (new ProductOptionTransfer())
            ->setTaxRate($taxRate)
            ->setQuantity($quantity)
            ->setIdProductOptionValue($productOptionValueEntity->getIdProductOptionValue());

        if ($priceMode === CalculationPriceMode::PRICE_MODE_GROSS) {
            $productOptionTransfer->setUnitGrossPrice($price);
        }

        if ($priceMode === CalculationPriceMode::PRICE_MODE_NET) {
            $productOptionTransfer->setUnitNetPrice($price);
        }

        return $productOptionTransfer;
    }

    public function createAbstractProductWithTaxSet(float $taxRate): SpyProductAbstract
    {
        $countryEntity = SpyCountryQuery::create()->findOneByIso2Code(static::COUNTRY_DE);

        $taxRateEntity = new SpyTaxRate();
        $taxRateEntity->setRate($taxRate);
        $taxRateEntity->setName('test rate');
        $taxRateEntity->setFkCountry($countryEntity->getIdCountry());
        $taxRateEntity->save();

        $taxSetEntity = $this->createTaxSet();

        $this->createTaxSetTax($taxSetEntity, $taxRateEntity);

        return $this->createAbstractProduct($taxSetEntity);
    }

    public function createAbstractProductWithTaxExemption(): SpyProductAbstract
    {
        $taxRateEntity = new SpyTaxRate();
        $taxRateEntity->setRate(0);
        $taxRateEntity->setName(TaxConstants::TAX_EXEMPT_PLACEHOLDER);
        $taxRateEntity->save();

        $taxSetEntity = $this->createTaxSet();

        $this->createTaxSetTax($taxSetEntity, $taxRateEntity);

        return $this->createAbstractProduct($taxSetEntity);
    }

    protected function getIncrementNumber(): int
    {
        return ++$this->incrementNumber;
    }

    protected function getCurrency(): SpyCurrency
    {
        return SpyCurrencyQuery::create()->findOneByCode('EUR');
    }

    protected function createProductOptionValue(float $taxRate): SpyProductOptionValue
    {
        $countryEntity = SpyCountryQuery::create()->findOneByIso2Code('DE');

        $taxRateEntity = new SpyTaxRate();
        $taxRateEntity->setRate($taxRate);
        $taxRateEntity->setName('test rate');
        $taxRateEntity->setFkCountry($countryEntity->getIdCountry());
        $taxRateEntity->save();

        $taxSetEntity = $this->createTaxSet();
        $this->createTaxSetTax($taxSetEntity, $taxRateEntity);

        $productOptionGroupEntity = new SpyProductOptionGroup();
        $productOptionGroupEntity->setName('group.name.translation.key.edit');
        $productOptionGroupEntity->setFkTaxSet($taxSetEntity->getIdTaxSet());
        $productOptionGroupEntity->save();

        $productOptionValueEntity = new SpyProductOptionValue();
        $productOptionValueEntity->setSku('product-' . $this->getIncrementNumber());
        $productOptionValueEntity->setFkProductOptionGroup($productOptionGroupEntity->getIdProductOptionGroup());
        $productOptionValueEntity->setValue('product.option.test');
        $productOptionValueEntity->save();

        return $productOptionValueEntity;
    }

    protected function createTaxSet(): SpyTaxSet
    {
        $taxSetEntity = new SpyTaxSet();
        $taxSetEntity->setName('name of tax set');
        $taxSetEntity->save();

        return $taxSetEntity;
    }

    protected function createTaxSetTax(SpyTaxSet $taxSetEntity, SpyTaxRate $taxRateEntity): void
    {
        $taxSetTaxRateEntity = new SpyTaxSetTax();
        $taxSetTaxRateEntity->setFkTaxSet($taxSetEntity->getIdTaxSet());
        $taxSetTaxRateEntity->setFkTaxRate($taxRateEntity->getIdTaxRate());

        $taxSetTaxRateEntity->save();
    }

    protected function createAbstractProduct(SpyTaxSet $taxSetEntity): SpyProductAbstract
    {
        $abstractProductEntity = new SpyProductAbstract();
        $abstractProductEntity->setSku('test-abstract-sku_' . $this->getIncrementNumber());
        $abstractProductEntity->setAttributes('');
        $abstractProductEntity->setFkTaxSet($taxSetEntity->getIdTaxSet());
        $abstractProductEntity->save();

        return $abstractProductEntity;
    }

    protected function isCanceledAmount(array $items): bool
    {
        foreach ($items as $item) {
            if ($item[5]) {
                return true;
            }
        }

        return false;
    }
}