DiscountHelper::getFoxyDiscountType() - Code Metrics - Inspection of "REFACTOR improve usage of DiscountHelper for more..." - dynamic/silverstripe-foxy-discounts - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#49)

by Nic

created 2020-09-20 16:12 UTC

DiscountHelper::getFoxyDiscountType() A

↳ Parent: DiscountHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0

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

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

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

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

    /**
     * @var Variation
     */
    private $variation;


    /**
     * @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}'",
            ]);

            $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();
        }

        return $this;
    }

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

    /**
     * @param Variation $variation
     * @return $this
     */
    public function setVariation($variation): self
    {
        $this->variation = ($variation instanceof Variation)

            ? $variation
            : $this->getProduct()->Variations()->filter('', $variation)->first();//TODO fix this string thing, is it needed?

        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;
    }
}


1			<?php
2
3			namespace Dynamic\Foxy\Discounts;
4
5			use Dynamic\Foxy\Discounts\Model\Discount;
6			use Dynamic\Foxy\Discounts\Model\DiscountTier;
7			use Dynamic\Foxy\Model\Variation;
8			use SilverStripe\Core\Injector\Injectable;
9			use SilverStripe\ORM\ArrayList;
10			use SilverStripe\ORM\DataList;
11			use SilverStripe\ORM\FieldType\DBCurrency;
12			use SilverStripe\ORM\FieldType\DBField;
13
14			/**
15			* Class DiscountHelper
16			* @package Dynamic\Foxy\Discounts
17			*/
18			class DiscountHelper
19			{
20			use Injectable;
21
22			/**
23			* @var
24			*/
25			private $product;
26
27			/**
28			* @var DataList\|null
29			*/
30			private $available_discounts = null;
31
32			/**
33			* @var Variation
34			*/
35			private $variation;
36
37
38			/**
39			* @var DiscountTier
40			*/
41			private $discount_tier;
42
43			/**
44			* @var int
45			*/
46			private $quantity;
47
48			/**
49			* @var DBField\|DBCurrency
50			*/
51			private $discounted_price;
52
53			/**
54			* DiscountHelper constructor.
55			* @param $product
56			* @param int $quantity
57			* @param Variation\|null $variation
58			*/
59			public function __construct($product, $quantity = 1, $variation = null)
60			{
61			$this->setProduct($product);
62			$this->setQuantity($quantity);
63			$this->setDiscountTier();
64
65			if ($variation instanceof Variation) {
66			$this->setVariation($variation);
67			}
68			}
69
70			/**
71			* @return mixed
72			*/
73			public function getProduct()
74			{
75			return $this->product;
76			}
77
78			/**
79			* @param $product
80			* @return $this
81			*/
82			public function setProduct($product): self
83			{
84			$this->product = $product;
85
86			$this->setAvailableDiscounts();
87
88			return $this;
89			}
90
91			/**
92			* Set the available discounts based on DiscountHelper::product
93			*
94			* @return $this
95			*/
96			public function setAvailableDiscounts()
97			{
98			if (!$this->getProduct()->ExcludeFromDiscounts) {
99			$now = date("Y-m-d H:i:s", strtotime('now'));
100			//don't get discounts the product is excluded from
101			$list = Discount::get()->exclude([
102			'ExcludeProducts.ID' => $this->getProduct()->ID,
103			])->whereAny([
104			"`StartTime` <= '{$now}' AND `EndTime` >= '{$now}'",
105			"(`StartTime` = '' OR `StartTime` IS NULL) AND (`EndTime` = '' OR `EndTime` IS NULL)",
106			"`StartTime` <= '{$now}' AND (`EndTime` = '' OR `EndTime` IS NULL)",
107			"(`StartTime` = '' OR `StartTime` IS NULL) AND `EndTime` >= '{$now}'",
108			]);
109
110			$strict = $list->filter([
111			'Products.Count():GreaterThan' => 0,
112			'Products.ID' => $this->getProduct()->ID,
113			]);
114
115			$global = $list->filter('Products.Count()', 0);
116
117			$merge = array_merge(array_values($strict->column()), array_values($global->column()));
118
119			$this->available_discounts = count($merge) ? Discount::get()->byIDs($merge) : ArrayList::create();
120			}
121
122			return $this;
123			}
124
125			/**
126			* @return DataList\|null
127			*/
128			public function getAvailableDiscounts()
129			{
130			return $this->available_discounts;
131			}
132
133			/**
134			* @param Variation $variation
135			* @return $this
136			*/
137			public function setVariation($variation): self
138			{
139			$this->variation = ($variation instanceof Variation)
			0 ignored issues – show introduced 2020-09-20 16:15 UTC by Report Bug Copy Issue Report `$variation` is always a sub-type of `Dynamic\Foxy\Model\Variation`. Loading history...
140			? $variation
141			: $this->getProduct()->Variations()->filter('', $variation)->first();//TODO fix this string thing, is it needed?
142
143			return $this;
144			}
145
146			/**
147			* @return mixed
148			*/
149			public function getVariation()
150			{
151			return $this->variation;
152			}
153
154			/**
155			* @param $quantity
156			* @return $this
157			*/
158			public function setQuantity($quantity)
159			{
160			if ($quantity < 1) {
161			user_error("\$quantity must be at least 1");
162			}
163
164			$this->quantity = $quantity;
165
166			$this->setDiscountTier();
167
168			return $this;
169			}
170
171			/**
172			* @return int
173			*/
174			public function getQuantity()
175			{
176			return $this->quantity;
177			}
178
179			/**
180			* @return $this
181			*/
182			public function setDiscountTier()
183			{
184			$this->discount_tier = $this->findBestDiscount();
185
186			return $this;
187			}
188
189			/**
190			* @return DiscountTier
191			*/
192			public function getDiscountTier()
193			{
194			if (!$this->discount_tier) {
195			$this->setDiscountTier();
196			}
197
198			return $this->discount_tier;
199			}
200
201			/**
202			* @return mixed
203			*/
204			protected function findBestDiscount()
205			{
206			$appropriateTiers = ArrayList::create();
207
208			/** @var Discount $discount */
209			foreach ($this->getAvailableDiscounts() as $discount) {
210			if ($tier = $discount->getTierByQuantity($this->getQuantity())) {
211			$appropriateTiers->push($tier);
212			}
213			}
214
215			return $this->resolveDiscountTiers($appropriateTiers);
216			}
217
218			/**
219			* @param $discountTiers
220			* @return DiscountTier\|null
221			*/
222			protected function resolveDiscountTiers($discountTiers)
223			{
224			if (!$discountTiers->count()) {
225			return null;
226			}
227
228			$basePrice = $this->getProduct()->Price;
229			$bestTier = null;
230			$calculatePrice = function (DiscountTier $tier) use ($basePrice) {
231			if ($tier->ParentType == 'Percent') {
232			return $basePrice - ($basePrice * ($tier->Percentage / 100));
233			} else {
234			return $basePrice - $tier->Amount;
235			}
236			};
237
238			/** @var DiscountTier $tier */
239			foreach ($discountTiers as $tier) {
240			if ($bestTier == null) {
241			$bestTier = [
242			'price' => $calculatePrice($tier),
243			'discountTier' => $tier,
244			];
245			continue;
246			}
247
248			if ($calculatePrice($tier) < $bestTier['price']) {
249			$bestTier['price'] = $calculatePrice($tier);
250			$bestTier['discountTier'] = $tier;
251			}
252			}
253
254			return is_array($bestTier) && isset($bestTier['discountTier']) ? $bestTier['discountTier'] : null;
255			}
256
257			/**
258			* @return DBCurrency
259			*/
260			public function getDiscountedPrice()
261			{
262			$price = ($this->getVariation())
263			? $this->getVariation()->FinalPrice
264			: $this->getProduct()->Price;
265
266			$tier = $this->getDiscountTier();
267
268			$price = ($this->getDiscountTier()->ParentType == 'Percent')
269			? $price - ($price * ($tier->Percentage / 100))
270			: $price - $tier->Amount;
271
272			return DBField::create_field(DBCurrency::class, $price);
273			}
274
275			/**
276			* @return string
277			*/
278			public function getFoxyDiscountType()
279			{
280			return $this->getDiscountTier()->ParentType == 'Percent'
281			? 'discount_quantity_percentage'
282			: 'discount_quantity_amount';
283			}
284
285			/**
286			* @return false\|string
287			*/
288			public function getDiscountFieldValue()
289			{
290			if ($this->getDiscountTier()) {
291			$discount = $this->getDiscountTier()->Discount();
292			$field = $discount->Type == 'Percent' ? 'Percentage' : 'Amount';
293			$discountString = $discount->Title . '{allunits';
294
295			foreach (DiscountTier::get()->filter('DiscountID', $this->getDiscountTier()->DiscountID) as $tier) {
296			$discountString .= "\|{$tier->Quantity}-{$tier->{$field}}";
297			}
298
299			$discountString .= '}';
300			return $discountString;
301			}
302
303			return false;
304			}
305			}
306

dynamic / silverstripe-foxy-discounts

Pull Request — master (#49)

DiscountHelper::getFoxyDiscountType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like