EventEspresso\core\entities\money\Money

Complexity

Total Complexity

37

Size/Duplication

Total Lines	420
Duplicated Lines	10.95 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	forSite()	0	8	3
A	forCountry()	0	4	1
A	forCurrency()	0	4	1
A	__callStatic()	0	4	1
B	parseAmount()	0	23	4
A	precision()	0	5	2
A	amount()	0	9	1
B	format()	0	16	5
A	currency()	0	4	1
A	add()	11	11	1
A	subtract()	11	11	1
A	multiply()	12	12	1
A	divide()	12	12	1
A	verifySameCurrency()	0	11	2
A	calculator()	0	5	1
B	initializeCalculators()	0	22	6
A	formatters()	0	5	1
A	initializeFormatters()	0	15	2
A	__toString()	0	4	1

<?php

namespace EventEspresso\core\entities\money;

use EE_Error;
use EE_Organization_Config;
use EE_Registry;
use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\services\currency\Calculator;
use EventEspresso\core\services\currency\CurrencySignMoneyFormatter;
use EventEspresso\core\services\currency\DecimalMoneyFormatter;
use EventEspresso\core\services\currency\InternationalMoneyFormatter;
use EventEspresso\core\services\currency\MoneyFormatter;
use EventEspresso\core\services\currency\ThousandsMoneyFormatter;
use InvalidArgumentException;

defined('EVENT_ESPRESSO_VERSION') || exit;



/**
 * Class Money
 * Immutable object representing an amount of money for a particular currency
 *
 * @package       Event Espresso
 * @author        Brent Christensen
 * @since         $VID:$
 */
class Money
{

    /**
     * number of decimal places to be added to currencies for internal computations,
     * but removed before any output or formatting is applied.
     * This allows us to avoid rounding errors during calculations.
     */
    const EXTRA_PRECISION = 3;

    /**
     * @var int $amount
     */
    private $amount;

    /**
     * @var Currency $currency
     */
    private $currency;

    /**
     * @var Calculator $calculator
     */
    protected static $calculator;

    /**
     * @var MoneyFormatter[] $formatters
     */
    protected static $formatters;



    /**
     * Money constructor.
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @param Currency         $currency
     * @throws InvalidDataTypeException
     */
    public function __construct($amount, Currency $currency)
    {
        $this->currency = $currency;
        $this->amount = (string)$this->parseAmount($amount);

The property $amount was declared of type integer, but (string) $this->parseAmount($amount) is of type string. Maybe add a type cast?

    }



    /**
     * factory method that returns a Money object using the currency corresponding to the site's country
     * example: Money::forSite(12.5)
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @return Money
     * @throws InvalidArgumentException
     */
    public static function forSite($amount)
    {
        $CNT_ISO = isset(EE_Registry::instance()->CFG->organization)
                   && EE_Registry::instance()->CFG->organization instanceof EE_Organization_Config
            ? EE_Registry::instance()->CFG->organization->CNT_ISO
            : 'US';
        return new self($amount, Currency::createFromCountryCode($CNT_ISO));
    }



    /**
     * factory method that returns a Money object using the currency as specified by the supplied ISO country code
     * example: Money::forCountry(12.5,'US')
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @param string           $CNT_ISO
     * @return Money
     * @throws InvalidArgumentException
     */
    public static function forCountry($amount, $CNT_ISO)
    {
        return new self($amount, Currency::createFromCountryCode($CNT_ISO));
    }



    /**
     * factory method that returns a Money object using the currency as specified by the supplied currency code
     * example: Money::forCurrency(12.5, 'USD')
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @param string           $currency_code
     * @return Money
     * @throws InvalidDataTypeException
     * @throws EE_Error
     * @throws InvalidArgumentException
     */
    public static function forCurrency($amount, $currency_code)
    {
        return new self($amount, Currency::createFromCode($currency_code));
    }



    /**
     * factory method that returns a Money object for the currency specified as if it were a class method
     * example: Money::USD(12.5);
     * money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     * example: $12.5 USD would equate to a value amount of 12.50
     *
     * @param string $currency_code
     * @param array  $arguments
     * @return Money
     * @throws InvalidDataTypeException
     * @throws EE_Error
     * @throws InvalidArgumentException
     */
    public static function __callStatic($currency_code, $arguments)
    {
        return new self($arguments[0], Currency::createFromCode($currency_code));
    }



    /**
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @return float|int|number|string
     * @throws InvalidDataTypeException
     */
    private function parseAmount($amount)
    {
        $type = gettype($amount);
        switch ($type) {
            case 'integer' :
            case 'double' :
            case 'string' :
                // shift the decimal position by the number of decimal places used internally
                // ex: 12.5 for a currency using 2 decimal places, would become 1250
                // then if our extra internal precision was 3, it would become 1250000
                $amount *= pow(10, $this->precision());
                // then round up the remaining value if there is still a fractional amount left
                $amount = round($amount, 0, PHP_ROUND_HALF_UP);
            break;
            default  :
                throw new InvalidDataTypeException(
                    '$amount',
                    $amount,
                    'integer (or float or string)'
                );
        }
        return $amount;
    }



    /**
     * adds or subtracts additional decimal places based on the value of the Money::EXTRA_PRECISION constant
     *
     * @param bool $positive
     * @return int
     */
    private function precision($positive = true)
    {
        $sign = $positive ? 1 : -1;
        return ((int)$this->currency->decimalPlaces() + Money::EXTRA_PRECISION) * $sign;
    }



    /**
     * Returns the money amount as an unformatted string
     * IF YOU REQUIRE A FORMATTED STRING, THEN USE Money::format()
     *
     * @return string
     */
    public function amount()
    {
        // shift the decimal position BACK by the number of decimal places used internally
        // ex: 1250 for a currency using 2 decimal places, would become 12.5
        $amount = (string)$this->amount * pow(10, $this->precision(false));
        // then shave off our extra internal precision using the number of decimal places for the currency
        $amount = round($amount, $this->currency->decimalPlaces());
        return $amount;
    }



    /**
     * applies formatting based on the specified formatting level
     * corresponding to one of the constants on \EventEspresso\core\services\currency\MoneyFormatter
     *
     * @param int $formatting_level
     * @return string
     */
    public function format($formatting_level = MoneyFormatter::ADD_THOUSANDS)
    {
        $formatted_amount = $this->amount();
        $formatters = $this->formatters();
        // if we are applying thousands formatting...
        if ($formatting_level >= MoneyFormatter::ADD_THOUSANDS) {
            // then let's remove decimal formatting since it's included in thousands formatting
            unset($formatters[MoneyFormatter::DECIMAL_ONLY]);
        }
        for ($x = 1; $x <= $formatting_level; $x++) {
            if (isset($formatters[$x]) && $formatters[$x] instanceof MoneyFormatter) {
                $formatted_amount = $formatters[$x]->format($formatted_amount, $this->currency);
            }
        }
        return $formatted_amount;
    }



    /**
     * Returns the Currency object for this money
     *
     * @return Currency
     */
    public function currency()
    {
        return $this->currency;
    }



    /**
     * adds the supplied Money amount to this Money amount
     * and returns a new Money object
     *
     * @param Money $other
     * @return Money
     * @throws InvalidArgumentException
     */
    public function add(Money $other)

This method seems to be duplicated in your project.

    {
        $this->verifySameCurrency($other->currency());
        return new Money(
            $this->calculator()->add(
                $this->amount(),
                $other->amount()
            ),
            $this->currency()
        );
    }



    /**
     * subtracts the supplied Money amount from this Money amount
     * and returns a new Money object
     *
     * @param Money $other
     * @return Money
     * @throws InvalidArgumentException
     */
    public function subtract(Money $other)

This method seems to be duplicated in your project.

    {
        $this->verifySameCurrency($other->currency());
        return new Money(
            $this->calculator()->subtract(
                $this->amount(),
                $other->amount()
            ),
            $this->currency()
        );
    }



    /**
     * multiplies this Money amount by the supplied $multiplier
     * and returns a new Money object
     *
     * @param float|int|string $multiplier
     * @param int              $rounding_mode
     * @return Money
     * @throws InvalidDataTypeException
     */
    public function multiply($multiplier, $rounding_mode = Calculator::ROUND_HALF_UP)

This method seems to be duplicated in your project.

    {
        return new Money(
            $this->calculator()->multiply(
                $this->amount(),
                $multiplier,
                $this->precision(),
                $rounding_mode
            ),
            $this->currency()
        );
    }



    /**
     * divides this Money amount by the supplied $divisor
     * and returns a new Money object
     *
     * @param float|int|string $divisor
     * @param int              $rounding_mode
     * @return Money
     * @throws InvalidDataTypeException
     */
    public function divide($divisor, $rounding_mode = Calculator::ROUND_HALF_UP)

This method seems to be duplicated in your project.

    {
        return new Money(
            $this->calculator()->divide(
                $this->amount(),
                $divisor,
                $this->precision(),
                $rounding_mode
            ),
            $this->currency()
        );
    }



    /**
     * @param Currency $other_currency
     * @throws InvalidArgumentException
     */
    public function verifySameCurrency(Currency $other_currency)
    {
        if ($this->currency()->equals($other_currency) !== true) {
            throw new InvalidArgumentException(
                esc_html__(
                    'Currencies must be the same in order to add or subtract their values.',
                    'event_espresso'
                )
            );
        }
    }



    /**
     * @return Calculator
     */
    protected function calculator()
    {
        $this->initializeCalculators();
        return self::$calculator;
    }



    /**
     * loops through a filterable array of Calculator services
     * and selects the first one that is supported by the current server
     */
    protected function initializeCalculators()
    {
        if (self::$calculator instanceof Calculator) {
            return;
        }
        $calculators = apply_filters(
            'FHEE__EventEspresso\core\entities\money\Money__initializeCalculators__Calculator_array',
            array(
                '\EventEspresso\core\services\currency\DefaultCalculator',
            )
        );
        foreach ($calculators as $calculator) {
            if (! class_exists($calculator)) {
                continue;
            }
            $calculator = new $calculator();
            if ($calculator instanceof Calculator && $calculator->isSupported()) {
                self::$calculator = $calculator;
                break;
            }
        }
    }



    /**
     * @return MoneyFormatter[]
     */
    protected function formatters()
    {
        $this->initializeFormatters();
        return self::$formatters;
    }



    /**
     * initializes a filterable array of MoneyFormatter services
     */
    protected function initializeFormatters()
    {
        if (! empty(self::$formatters)) {
            return;
        }
        self::$formatters = apply_filters(
            'FHEE__EventEspresso\core\entities\money\Money__initializeFormatters__MoneyFormatters_array',
            array(
                1 => new DecimalMoneyFormatter(),
                2 => new ThousandsMoneyFormatter(),
                3 => new CurrencySignMoneyFormatter(),
                4 => new InternationalMoneyFormatter(),
            )
        );
    }



    /**
     * @return string
     */
    public function __toString()
    {
        return $this->format(MoneyFormatter::DECIMAL_ONLY);
    }




}
// End of file Money.php
// Location: core/entities/money/Money.php