SprykerEco\Zed\Payone\Business\Distributor\OrderPriceDistributor

Complexity

Total Complexity

16

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	distributeOrderExpensesPrices()	0	19	4
A	findPayonePayment()	0	11	3
A	distributeOrderItemsPrices()	0	23	4
A	calculatePriceRatio()	0	3	1
A	distributeOrderPrice()	0	20	3
A	calculateRoundedPrice()	0	7	1

<?php

/**
 * MIT License
 * Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
 */

namespace SprykerEco\Zed\Payone\Business\Distributor;

use Generated\Shared\Transfer\OrderTransfer;

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

use Generated\Shared\Transfer\PaymentTransfer;

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

use SprykerEco\Zed\Payone\PayoneConfig;

class OrderPriceDistributor implements OrderPriceDistributorInterface
{
    /**
     * @param \Generated\Shared\Transfer\OrderTransfer $orderTransfer
     *
     * @return \Generated\Shared\Transfer\OrderTransfer
     */
    public function distributeOrderPrice(OrderTransfer $orderTransfer): OrderTransfer
    {
        if ($orderTransfer->getPayments()->count() <= 1) {
            return $orderTransfer;
        }

        $payonePayment = $this->findPayonePayment($orderTransfer);
        if (!$payonePayment) {
            return $orderTransfer;
        }

        $totalsTransfer = $orderTransfer->getTotals();
        $priceRatio = $this->calculatePriceRatio($payonePayment->getAmount(), $totalsTransfer->getGrandTotal());

        $this->distributeOrderItemsPrices($orderTransfer, $priceRatio);
        $this->distributeOrderExpensesPrices($orderTransfer, $priceRatio);

        $orderTransfer->setTotals($totalsTransfer->setGrandTotal($payonePayment->getAmount()));

        return $orderTransfer;
    }

    /**
     * @param int $paymentAmount
     * @param int $grandTotalAmount
     *
     * @return float
     */
    protected function calculatePriceRatio(int $paymentAmount, int $grandTotalAmount): float
    {
        return $paymentAmount / $grandTotalAmount;
    }

    /**
     * @param \Generated\Shared\Transfer\OrderTransfer $orderTransfer
     *
     * @return \Generated\Shared\Transfer\PaymentTransfer|null
     */
    protected function findPayonePayment(OrderTransfer $orderTransfer): ?PaymentTransfer
    {
        $paymentTransfers = $orderTransfer->getPayments();

        foreach ($paymentTransfers as $paymentTransfer) {
            if ($paymentTransfer->getPaymentProvider() === PayoneConfig::PROVIDER_NAME) {
                return $paymentTransfer;
            }
        }

        return null;
    }

    /**
     * @param int $unitPrice
     * @param float $priceRatio
     * @param float $roundingError
     *
     * @return int
     */
    protected function calculateRoundedPrice(int $unitPrice, float $priceRatio, float &$roundingError): int
    {
        $priceBeforeRound = ($unitPrice * $priceRatio) + $roundingError;
        $priceRounded = (int)round($priceBeforeRound);
        $roundingError = $priceBeforeRound - $priceRounded;

        return $priceRounded;
    }

    /**
     * @param \Generated\Shared\Transfer\OrderTransfer $orderTransfer
     * @param float $priceRatio
     *
     * @return void
     */
    protected function distributeOrderItemsPrices(OrderTransfer $orderTransfer, float $priceRatio): void
    {
        $lastItemTransfer = null;
        $roundingError = 0;

        foreach ($orderTransfer->getItems() as $itemTransfer) {
            $unitPrice = $this->calculateRoundedPrice(
                $itemTransfer->getUnitGrossPrice(),
                $priceRatio,
                $roundingError
            );

            $itemTransfer->setSumPriceToPayAggregation($unitPrice)
                ->setUnitPriceToPayAggregation($unitPrice)
                ->setUnitGrossPrice($unitPrice);
            $lastItemTransfer = $itemTransfer;
        }

        if ($lastItemTransfer && $roundingError) {
            $lastItemUnitPrice = (int)round($lastItemTransfer->getUnitGrossPrice() + $roundingError);
            $lastItemTransfer->setSumPriceToPayAggregation($lastItemUnitPrice)
                ->setUnitPriceToPayAggregation($lastItemUnitPrice)
                ->setUnitGrossPrice($lastItemUnitPrice);
        }
    }

    /**
     * @param \Generated\Shared\Transfer\OrderTransfer $orderTransfer
     * @param float $priceRatio
     *
     * @return void
     */
    protected function distributeOrderExpensesPrices(OrderTransfer $orderTransfer, float $priceRatio): void
    {
        $lastExpenseTransfer = null;
        $roundingError = 0;

        foreach ($orderTransfer->getExpenses() as $expenseTransfer) {
            $roundedPrice = $this->calculateRoundedPrice(
                $expenseTransfer->getSumGrossPrice(),
                $priceRatio,
                $roundingError
            );

            $expenseTransfer->setSumGrossPrice($roundedPrice);
            $lastExpenseTransfer = $expenseTransfer;
        }

        if ($lastExpenseTransfer && $roundingError) {
            $lastExpenseSumGrossPrice = (int)round($lastExpenseTransfer->getSumGrossPrice() + $roundingError);
            $lastExpenseTransfer->setSumGrossPrice($lastExpenseSumGrossPrice);
        }
    }
}