hiqdev\php\billing\order\Calculator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	104
Duplicated Lines	8.65 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

78.72%

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	calculateCharges()	9	16	3
B	findSales()	0	23	5
C	findPlans()	0	36	8

<?php
/**
 * PHP Billing Library
 *
 * @link      https://github.com/hiqdev/php-billing
 * @package   php-billing
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017-2018, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\billing\order;

use hiqdev\php\billing\plan\PlanRepositoryInterface;
use hiqdev\php\billing\sale\SaleRepositoryInterface;

/**
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class Calculator implements CalculatorInterface
{
    /**
     * @var SaleRepositoryInterface
     */
    private $saleRepository;

    /**
     * @var PlanRepositoryInterface
     */
    private $planRepository;

    /**
     * @param PlanRepositoryInterface $planRepository
     */
    public function __construct(
        SaleRepositoryInterface $saleRepository,
        PlanRepositoryInterface $planRepository = null
    ) {
        $this->saleRepository = $saleRepository;
        $this->planRepository = $planRepository;
    }

    /**
     * {@inheritdoc}
     */
    public function calculateCharges(OrderInterface $order)
    {
        $plans = $this->findPlans($order);
        $charges = [];
        foreach ($order->getActions() as $actionKey => $action) {

This code seems to be duplicated across your project.

            if (empty($plans[$actionKey])) {
                /* XXX not sure... think more
                throw new FailedFindPlan();
                 */
                continue;
            }
            $charges[$actionKey] = $plans[$actionKey]->calculateCharges($action);
        }

        return $charges;
    }

    public function findPlans(OrderInterface $order)
    {
        $sales = $this->findSales($order);
        $plans = [];
        $lookPlanIds = [];
        foreach ($order->getActions() as $actionKey => $action) {
            if (empty($sales[$actionKey])) {
                /// it is ok when no sale found for upper resellers
                /// throw new \Exception('not found sale');

55% of this comment could be valid code. Did you maybe forget this after debugging?

                $plans[$actionKey] = null;
            } else {
                $sale = $sales[$actionKey];
                $plan = $sale->getPlan();
                if ($plan->hasPrices()) {
                    $plans[$actionKey] = $plan;
                } else {
                    $lookPlanIds[$actionKey] = $plan->getId();
                }
            }
        }

        if ($lookPlanIds) {

The expression $lookPlanIds 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.

            $foundPlans = $this->planRepository->findByIds($lookPlanIds);
            foreach ($foundPlans as $actionKey => $plan) {
                $foundPlans[$plan->getId()] = $plan;
            }
            foreach ($lookPlanIds as $actionKey => $planId) {
                if (empty($foundPlans[$planId])) {
                    throw new \Exception('not found plan');
                }
                $plans[$actionKey] = $foundPlans[$planId];
            }
        }

        return $plans;
    }

    public function findSales(OrderInterface $order)
    {
        $sales = [];
        $lookActions = [];
        foreach ($order->getActions() as $actionKey => $action) {
            $sale = $action->getSale();
            if ($sale) {
                $sales[$actionKey] = $sale;
            } else {
                $lookActions[$actionKey] = $action;
            }
        }

        if ($lookActions) {

The expression $lookActions 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.

            $lookOrder = new Order(null, $order->getCustomer(), $lookActions);
            $foundSales = $this->saleRepository->findByOrder($lookOrder);
            foreach ($foundSales as $actionKey => $plan) {
                $sales[$actionKey] = $plan;
            }
        }

        return $sales;
    }
}