hiqdev\php\billing\price\AbstractPrice

Complexity

Total Complexity

18

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	6

Test Coverage

Coverage

62.79%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getId()	0	4	1
A	getType()	0	4	1
A	getTarget()	0	4	1
A	getPlan()	0	4	1
A	hasPlan()	0	4	1
A	setPlan()	0	7	2
A	calculateSum()	0	15	3
A	create()	0	4	1
A	jsonSerialize()	0	8	1
A	isApplicable()	0	14	2
A	calculateCharges()	0	9	3

<?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\price;

use hiqdev\php\billing\action\ActionInterface;
use hiqdev\php\billing\charge\ChargeModifier;
use hiqdev\php\billing\EntityInterface;
use hiqdev\php\billing\plan\PlanInterface;
use hiqdev\php\billing\target\TargetInterface;
use hiqdev\php\billing\type\TypeInterface;
use hiqdev\php\units\QuantityInterface;
use Money\Money;

/**
 * Price.
 * @see PriceInterface
 * By default Price is applicable when same target and same type as Action.
 * But it can be different e.g. same price for all targets when certain type.
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
abstract class AbstractPrice implements PriceInterface, EntityInterface
{
    /**
     * @var integer
     */
    protected $id;

    /**
     * @var TypeInterface
     */
    protected $type;

    /**
     * @var TargetInterface
     */
    protected $target;

    /**
     * @var PlanInterface
     */
    protected $plan;

    public function __construct(
                            $id,
        TypeInterface       $type,
        TargetInterface     $target,
        PlanInterface       $plan = null
    ) {
        $this->id = $id;
        $this->type = $type;
        $this->target = $target;
        $this->plan = $plan;
    }

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function hasPlan()
    {
        return $this->plan !== null;
    }

    /**
     * {@inheritdoc}
     */
    public function setPlan(PlanInterface $plan)
    {
        if ($this->hasPlan()) {
            throw new \Exception('cannot reassign plan for price');
        }
        $this->plan = $plan;
    }

    /**
     * {@inheritdoc}
     * Default sum calculation method: sum = price * usage.
     */
    public function calculateSum(QuantityInterface $quantity): ?Money
    {
        $usage = $this->calculateUsage($quantity);
        if ($usage === null) {
            return null;
        }

        $price = $this->calculatePrice($quantity);
        if ($price === null) {
            return null;
        }

        /// TODO add configurable rounding mode later
        return $price->multiply($usage->getQuantity(), Money::ROUND_UP);
    }

    public static function create(array $data)
    {
        return new SinglePrice($data['id'], $data['target']);
    }

    public function jsonSerialize()
    {
        return [
            'id' => $this->id,
            'type' => $this->type,
            'target' => $this->target,
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function isApplicable(ActionInterface $action): bool
    {
        /* sorry, debugging facility

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

         * var_dump([
            'action.target'     => $action->getTarget(),
            'this.target'       => $this->getTarget(),
            'action.type'       => $action->getType(),
            'this.type'         => $this->getType(),
            'target matches'    => $action->getTarget()->matches($this->getTarget()),
            'type matches'      => $action->getType()->matches($this->getType()),
        ]);*/
        return $action->getTarget()->matches($this->getTarget()) &&
               $action->getType()->matches($this->getType());
    }

    /** {@inheritdoc} */
    public function calculateCharges(ActionInterface $action): array
    {
        $charge = $action->calculateCharge($this);
        if ($this instanceof ChargeModifier) {
            return $this->modifyCharge($charge, $action);
        }

        return $charge ? [$charge] : [];
    }
}