Yabacon\Paystack\Fee

Complexity

Total Complexity

17

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__flatlinePlusCharge()	0	3	1
A	__chargeDivider()	0	3	1
A	calculateFor()	0	10	3
A	__construct()	0	7	1
A	withCap()	0	4	1
A	__flatline()	0	3	1
A	resetDefaults()	0	6	1
A	addFor()	0	8	3
A	withAdditionalCharge()	0	4	1
A	__setup()	0	6	1
A	__crossover()	0	3	1
A	withPercentage()	0	4	1
A	withThreshold()	0	4	1

<?php
namespace Yabacon\Paystack;

class Fee
{
    const DEFAULT_PERCENTAGE = 0.015;
    const DEFAULT_ADDITIONAL_CHARGE = 10000;
    const DEFAULT_THRESHOLD = 250000;
    const DEFAULT_CAP = 200000;

    public static $default_percentage = Fee::DEFAULT_PERCENTAGE;
    public static $default_additional_charge = Fee::DEFAULT_ADDITIONAL_CHARGE;
    public static $default_threshold = Fee::DEFAULT_THRESHOLD;
    public static $default_cap = Fee::DEFAULT_CAP;

    private $percentage;
    private $additional_charge;
    private $threshold;
    private $cap;

    private $chargeDivider;
    private $crossover;
    private $flatlinePlusCharge;
    private $flatline;

    public function __construct()
    {
        $this->percentage = Fee::$default_percentage;
        $this->additional_charge = Fee::$default_additional_charge;
        $this->threshold = Fee::$default_threshold;
        $this->cap = Fee::$default_cap;
        $this->__setup();
    }

    public function withPercentage($percentage)
    {
        $this->percentage = $percentage;
        $this->__setup();
    }

    public static function resetDefaults()
    {
        Fee::$default_percentage = Fee::DEFAULT_PERCENTAGE;
        Fee::$default_additional_charge = Fee::DEFAULT_ADDITIONAL_CHARGE;
        Fee::$default_threshold = Fee::DEFAULT_THRESHOLD;
        Fee::$default_cap = Fee::DEFAULT_CAP;
    }

    public function withAdditionalCharge($additional_charge)
    {
        $this->additional_charge = $additional_charge;
        $this->__setup();
    }

    public function withThreshold($threshold)
    {
        $this->threshold = $threshold;
        $this->__setup();
    }

    public function withCap($cap)
    {
        $this->cap = $cap;
        $this->__setup();
    }

    private function __setup()
    {
        $this->chargeDivider = $this->__chargeDivider();
        $this->crossover = $this->__crossover();
        $this->flatlinePlusCharge = $this->__flatlinePlusCharge();
        $this->flatline = $this->__flatline();
    }

    private function __chargeDivider()
    {
        return 1 - $this->percentage;
    }

    private function __crossover()
    {
        return ($this->threshold * $this->chargeDivider) - $this->additional_charge;
    }

    private function __flatlinePlusCharge()
    {
        return ($this->cap - $this->additional_charge) / $this->percentage;
    }

    private function __flatline()
    {
        return $this->flatlinePlusCharge - $this->cap;
    }

    public function addFor($amountinkobo)
    {
        if ($amountinkobo > $this->flatline) {
            return intval(ceil($amountinkobo + $this->cap));
        } elseif ($amountinkobo > $this->crossover) {
            return intval(ceil(($amountinkobo + $this->additional_charge) / $this->chargeDivider));
        } else {
            return intval(ceil($amountinkobo / $this->chargeDivider));
        }
    }

    public function calculateFor($amountinkobo)
    {
        $fee = $this->percentage * $amountinkobo;
        if ($amountinkobo >= $this->threshold) {
            $fee += $this->additional_charge;
        }
        if ($fee > $this->cap) {
            $fee = $this->cap;
        }
        return intval(ceil($fee));

It seems like $fee can also be of type mixed; however, parameter $value of ceil() does only seem to accept double, maybe add an additional type check?

    }
}