Dynamic\Foxy\Discounts\DiscountHelper

Complexity

Total Complexity

41

Size/Duplication

Total Lines	304
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getProduct()	0	3	1
A	setProduct()	0	7	1
A	__construct()	0	8	2
A	setVariation()	0	11	4
A	setQuantity()	0	11	2
A	getQuantity()	0	3	1
A	getDiscountTier()	0	7	2
A	getDiscountedPrice()	0	13	3
A	setAvailableDiscounts()	0	41	5
A	getAvailableDiscounts()	0	3	1
A	getFoxyDiscountType()	0	5	2
A	setDiscountTier()	0	5	1
B	resolveDiscountTiers()	0	33	8
A	getDiscountFieldValue()	0	16	4
A	getVariation()	0	3	1
A	findBestDiscount()	0	12	3

<?php

namespace Dynamic\Foxy\Discounts;

use Dynamic\Foxy\Discounts\Model\Discount;
use Dynamic\Foxy\Discounts\Model\DiscountTier;
use Dynamic\Foxy\Model\Variation;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\FieldType\DBCurrency;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\Security\Member;
use SilverStripe\Security\Security;

/**
 * Class DiscountHelper
 * @package Dynamic\Foxy\Discounts
 */
class DiscountHelper
{
    use Injectable;

    /**
     * @var
     */
    private $product;

    /**
     * @var DataList|null
     */
    private $available_discounts = null;

    /**
     * @var Variation|null
     */
    private $variation = null;


    /**
     * @var DiscountTier
     */
    private $discount_tier;

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

    /**
     * @var DBField|DBCurrency
     */
    private $discounted_price;

    /**
     * DiscountHelper constructor.
     * @param $product
     * @param int $quantity
     * @param Variation|null $variation
     */
    public function __construct($product, $quantity = 1, $variation = null)
    {
        $this->setProduct($product);
        $this->setQuantity($quantity);
        $this->setDiscountTier();

        if ($variation instanceof Variation) {
            $this->setVariation($variation);
        }
    }

    /**
     * @return mixed
     */
    public function getProduct()
    {
        return $this->product;
    }

    /**
     * @param $product
     * @return $this
     */
    public function setProduct($product): self
    {
        $this->product = $product;

        $this->setAvailableDiscounts();

        return $this;
    }

    /**
     * Set the available discounts based on DiscountHelper::product
     *
     * @return $this
     */
    public function setAvailableDiscounts()
    {
        if (!$this->getProduct()->ExcludeFromDiscounts) {
            $now = date("Y-m-d H:i:s", strtotime('now'));
            //don't get discounts the product is excluded from
            $list = Discount::get()->exclude([
                'ExcludeProducts.ID' => $this->getProduct()->ID,
            ])->whereAny([
                "`StartTime` <= '{$now}' AND `EndTime` >= '{$now}'",
                "(`StartTime` = '' OR `StartTime` IS NULL) AND (`EndTime` = '' OR `EndTime` IS NULL)",
                "`StartTime` <= '{$now}' AND (`EndTime` = '' OR `EndTime` IS NULL)",
                "(`StartTime` = '' OR `StartTime` IS NULL) AND `EndTime` >= '{$now}'",
            ]);

            $customerDiscountIDs = Member::get()->filter('DiscountID:GreaterThan', 0);

            if ($member = Security::getCurrentUser()) {
                $customerDiscountIDs = $customerDiscountIDs->exclude('ID', $member->ID);
            }

            $customerDiscountIDs = $customerDiscountIDs->column('DiscountID');

            if (count($customerDiscountIDs)) {
                $list = $list->exclude('ID', $customerDiscountIDs);
            }

            $strict = $list->filter([
                'Products.Count():GreaterThan' => 0,
                'Products.ID' => $this->getProduct()->ID,
            ]);

            $global = $list->filter('Products.Count()', 0);

            $merge = array_merge(array_values($strict->column()), array_values($global->column()));

            $this->available_discounts = count($merge) ? Discount::get()->byIDs($merge) : ArrayList::create();
        } else {
            $this->available_discounts = ArrayList::create();
        }

        return $this;
    }

    /**
     * @return DataList|null
     */
    public function getAvailableDiscounts()
    {
        return $this->available_discounts;
    }

    /**
     * @param Variation $variation
     * @return $this
     */
    public function setVariation($variation): self
    {
        if (!$variation instanceof Variation) {

$variation is always a sub-type of Dynamic\Foxy\Model\Variation.

            if (is_int($variation) && ($variation = $this->getProduct()->Variations()->byID($variation))) {
                $this->variation = $variation;
            }
        } else {
            $this->variation = $variation;
        }

        return $this;
    }

    /**
     * @return mixed
     */
    public function getVariation()
    {
        return $this->variation;
    }

    /**
     * @param $quantity
     * @return $this
     */
    public function setQuantity($quantity)
    {
        if ($quantity < 1) {
            user_error("\$quantity must be at least 1");
        }

        $this->quantity = $quantity;

        $this->setDiscountTier();

        return $this;
    }

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

    /**
     * @return $this
     */
    public function setDiscountTier()
    {
        $this->discount_tier = $this->findBestDiscount();

        return $this;
    }

    /**
     * @return DiscountTier
     */
    public function getDiscountTier()
    {
        if (!$this->discount_tier) {
            $this->setDiscountTier();
        }

        return $this->discount_tier;
    }

    /**
     * @return mixed
     */
    protected function findBestDiscount()
    {
        $appropriateTiers = ArrayList::create();

        /** @var Discount $discount */
        foreach ($this->getAvailableDiscounts() as $discount) {
            if ($tier = $discount->getTierByQuantity($this->getQuantity())) {
                $appropriateTiers->push($tier);
            }
        }

        return $this->resolveDiscountTiers($appropriateTiers);
    }

    /**
     * @param $discountTiers
     * @return DiscountTier|null
     */
    protected function resolveDiscountTiers($discountTiers)
    {
        if (!$discountTiers->count()) {
            return null;
        }

        $basePrice = $this->getProduct()->Price;
        $bestTier = null;
        $calculatePrice = function (DiscountTier $tier) use ($basePrice) {
            if ($tier->ParentType == 'Percent') {
                return $basePrice - ($basePrice * ($tier->Percentage / 100));
            } else {
                return $basePrice - $tier->Amount;
            }
        };

        /** @var DiscountTier $tier */
        foreach ($discountTiers as $tier) {
            if ($bestTier == null) {
                $bestTier = [
                    'price' => $calculatePrice($tier),
                    'discountTier' => $tier,
                ];
                continue;
            }

            if ($calculatePrice($tier) < $bestTier['price']) {
                $bestTier['price'] = $calculatePrice($tier);
                $bestTier['discountTier'] = $tier;
            }
        }

        return is_array($bestTier) && isset($bestTier['discountTier']) ? $bestTier['discountTier'] : null;
    }

    /**
     * @return DBCurrency
     */
    public function getDiscountedPrice()
    {
        $price = ($this->getVariation())
            ? $this->getVariation()->FinalPrice
            : $this->getProduct()->Price;

        $tier = $this->getDiscountTier();

        $price = ($this->getDiscountTier()->ParentType == 'Percent')
            ? $price - ($price * ($tier->Percentage / 100))
            : $price - $tier->Amount;

        return DBField::create_field(DBCurrency::class, $price);
    }

    /**
     * @return string
     */
    public function getFoxyDiscountType()
    {
        return $this->getDiscountTier()->ParentType == 'Percent'
            ? 'discount_quantity_percentage'
            : 'discount_quantity_amount';
    }

    /**
     * @return false|string
     */
    public function getDiscountFieldValue()
    {
        if ($this->getDiscountTier()) {
            $discount = $this->getDiscountTier()->Discount();
            $field = $discount->Type == 'Percent' ? 'Percentage' : 'Amount';
            $discountString = $discount->Title . '{allunits';

            foreach (DiscountTier::get()->filter('DiscountID', $this->getDiscountTier()->DiscountID) as $tier) {
                $discountString .= "|{$tier->Quantity}-{$tier->{$field}}";
            }

            $discountString .= '}';
            return $discountString;
        }

        return false;
    }
}