hiqdev\php\billing\action\AbstractAction

Complexity

Total Complexity

23

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	2

Test Coverage

Coverage

50%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	1
A	createSubaction()	0	4	1
A	getId()	0	4	1
A	getCustomer()	0	4	1
A	getTarget()	0	4	1
A	getType()	0	4	1
A	getQuantity()	0	4	1
A	getTime()	0	4	1
A	getParent()	0	4	1
A	hasParent()	0	4	1
A	getSale()	0	4	1
A	hasId()	0	4	1
A	setId()	0	10	3
A	hasSale()	0	4	1
A	setSale()	0	7	2
A	jsonSerialize()	0	4	1
B	calculateCharge()	0	26	4

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

use DateTimeImmutable;
use hiqdev\php\billing\charge\Charge;
use hiqdev\php\billing\charge\ChargeInterface;
use hiqdev\php\billing\customer\CustomerInterface;
use hiqdev\php\billing\EntityInterface;
use hiqdev\php\billing\price\PriceInterface;
use hiqdev\php\billing\sale\SaleInterface;
use hiqdev\php\billing\target\TargetInterface;
use hiqdev\php\billing\type\TypeInterface;
use hiqdev\php\units\QuantityInterface;

/**
 * Chargeable Action.
 *
 * @see ActionInterface
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
abstract class AbstractAction implements ActionInterface, EntityInterface
{
    /**
     * @var int
     */
    protected $id;

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

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

    /**
     * @var QuantityInterface
     */
    protected $quantity;

    /**
     * @var CustomerInterface
     */
    protected $customer;

    /**
     * @var SaleInterface
     */
    protected $sale;

    /**
     * @var DateTimeImmutable
     */
    protected $time;

    /**
     * @var ActionInterface
     */
    protected $parent;

    /**
     * @param TypeInterface $type
     * @param TargetInterface $target
     * @param QuantityInterface $quantity
     * @param CustomerInterface $customer
     * @param SaleInterface $sale
     * @param DateTimeImmutable $time
     * @param ActionInterface $parent
     */
    public function __construct(
        $id,
        TypeInterface $type,
        TargetInterface $target,
        QuantityInterface $quantity,
        CustomerInterface $customer,
        SaleInterface $sale = null,
        DateTimeImmutable $time = null,
        ActionInterface $parent = null
    ) {
        $this->id       = $id;
        $this->type     = $type;
        $this->target   = $target;
        $this->quantity = $quantity;
        $this->customer = $customer;
        $this->sale     = $sale;
        $this->time     = $time;
        $this->parent   = $parent;
    }

    public function createSubaction(CustomerInterface $customer)
    {
        return new static(null, $this->type, $this->target, $this->quantity, $customer, $this->sale, $this->time, $this);
    }

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

    /**
     * {@inheritdoc}
     */
    public function getCustomer(): CustomerInterface
    {
        return $this->customer;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function getQuantity(): QuantityInterface
    {
        return $this->quantity;
    }

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

    /**
     * {@inheritdoc}
     */
    public function getTime(): DateTimeImmutable
    {
        return $this->time;
    }

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

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

    public function hasId()
    {
        return $this->id !== null;
    }

    public function setId($id)
    {
        if ($this->id === $id) {
            return;
        }
        if ($this->hasId()) {
            throw new \Exception('cannot reassign action id');
        }
        $this->id = $id;
    }

    public function hasSale()
    {
        return $this->sale !== null;
    }

    public function setSale(SaleInterface $sale)
    {
        if ($this->hasSale()) {
            throw new \Exception('cannot reassign sale for action');
        }
        $this->sale = $sale;
    }

    /**
     * {@inheritdoc}
     */
    public function jsonSerialize()
    {
        return get_object_vars($this);
    }

    /**
     * @param PriceInterface $price
     * @return ChargeInterface|Charge|null
     */
    public function calculateCharge(PriceInterface $price): ?ChargeInterface
    {
        if (!$this->isApplicable($price)) {
            return null;
        }

        $usage = $price->calculateUsage($this->getQuantity());
        if ($usage === null) {
            return null;
        }

        $sum = $price->calculateSum($this->getQuantity());
        if ($sum === null) {
            return null;
        }

        /* sorry, debugging facility

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

         * var_dump([
            'unit'      => $usage->getUnit()->getName(),
            'quantity'  => $usage->getQuantity(),
            'price'     => $price->calculatePrice($usage)->getAmount(),
            'sum'       => $sum->getAmount(),
        ]);*/

        return new Charge(null, $this, $price, $this->getTarget(), $usage, $sum);
    }
}