modules/CDev/Coupons/src/Model/Coupon.php line 55

Open in your IDE?
  1. <?php
  3. /**
  4.  * Copyright (c) 2011-present Qualiteam software Ltd. All rights reserved.
  5.  * See https://www.x-cart.com/license-agreement.html for license details.
  6.  */
  8. namespace CDev\Coupons\Model;
  10. use ApiPlatform\Core\Annotation as ApiPlatform;
  11. use CDev\Coupons\API\Endpoint\Coupon\DTO\CouponInput;
  12. use CDev\Coupons\API\Endpoint\Coupon\DTO\CouponOutput;
  13. use Doctrine\ORM\Mapping as ORM;
  15. /**
  16.  * Coupon
  17.  *
  18.  * @ORM\Entity
  19.  * @ORM\Table  (name="coupons",
  20.  *      indexes={
  21.  *          @ORM\Index (name="ce", columns={"code", "enabled"})
  22.  *      }
  23.  * )
  24.  *
  25.  * @ApiPlatform\ApiResource(
  26.  *     input=CouponInput::class,
  27.  *     output=CouponOutput::class,
  28.  *     itemOperations={
  29.  *          "get"={
  30.  *              "method"="GET",
  31.  *              "path"="/coupons/{id}.{_format}",
  32.  *              "identifiers"={"id"},
  33.  *              "requirements"={"id"="\d+"}
  34.  *          },
  35.  *          "put"={
  36.  *              "method"="PUT",
  37.  *              "path"="/coupons/{id}.{_format}",
  38.  *              "identifiers"={"id"},
  39.  *              "requirements"={"id"="\d+"}
  40.  *          },
  41.  *          "delete"={
  42.  *              "method"="DELETE",
  43.  *              "path"="/coupons/{id}.{_format}",
  44.  *              "identifiers"={"id"},
  45.  *              "requirements"={"id"="\d+"}
  46.  *          }
  47.  *     },
  48.  *     collectionOperations={
  49.  *          "get"={
  50.  *              "method"="GET",
  51.  *              "identifiers"={},
  52.  *              "path"="/coupons.{_format}"
  53.  *          },
  54.  *          "post"={
  55.  *              "method"="POST",
  56.  *              "identifiers"={},
  57.  *              "path"="/coupons.{_format}"
  58.  *          }
  59.  *     }
  60.  * )
  61.  */
  62. class Coupon extends \XLite\Model\AEntity
  63. {
  64.     /**
  65.      * Coupon types
  66.      */
  67.     public const TYPE_PERCENT  = '%';
  68.     public const TYPE_ABSOLUTE = '$';
  70.     /**
  71.      * Coupon validation error codes
  72.      */
  73.     public const ERROR_DISABLED      = 'disabled';
  74.     public const ERROR_EXPIRED       = 'expired';
  75.     public const ERROR_USES          = 'uses';
  76.     public const ERROR_TOTAL         = 'total';
  77.     public const ERROR_PRODUCT_CLASS = 'product_class';
  78.     public const ERROR_MEMBERSHIP    = 'membership';
  79.     public const ERROR_SINGLE_USE    = 'singleUse';
  80.     public const ERROR_SINGLE_USE2   = 'singleUse2';
  81.     public const ERROR_CATEGORY      = 'category';
  83.     public const TYPE_FREESHIP                 = 'S';
  84.     public const APPLY_FREESHIP_TO_CHEAPEST    = 'C';
  85.     public const APPLY_FREESHIP_TO_FREE_METHOD = 'F';
  87.     /**
  88.      * Product unique ID
  89.      *
  90.      * @var   integer
  91.      *
  92.      * @ORM\Id
  93.      * @ORM\GeneratedValue (strategy="AUTO")
  94.      * @ORM\Column         (type="integer", options={ "unsigned": true })
  95.      */
  96.     protected $id;
  98.     /**
  99.      * Code
  100.      *
  101.      * @var   string
  102.      *
  103.      * @ORM\Column (type="string", options={ "fixed": true }, length=16)
  104.      */
  105.     protected $code;
  107.     /**
  108.      * Enabled status
  109.      *
  110.      * @var   boolean
  111.      *
  112.      * @ORM\Column (type="boolean")
  113.      */
  114.     protected $enabled = true;
  116.     /**
  117.      * Value
  118.      *
  119.      * @var   float
  120.      *
  121.      * @ORM\Column (type="decimal", precision=14, scale=4)
  122.      */
  123.     protected $value = 0.0000;
  125.     /**
  126.      * Type
  127.      *
  128.      * @var   string
  129.      *
  130.      * @ORM\Column (type="string", options={ "fixed": true }, length=1)
  131.      */
  132.     protected $type = self::TYPE_PERCENT;
  134.     /**
  135.      * Comment
  136.      *
  137.      * @var   string
  138.      *
  139.      * @ORM\Column (type="string", length=64)
  140.      */
  141.     protected $comment = '';
  143.     /**
  144.      * Uses count
  145.      *
  146.      * @var   integer
  147.      *
  148.      * @ORM\Column (type="integer", options={ "unsigned": true })
  149.      */
  150.     protected $uses = 0;
  152.     /**
  153.      * Date range (begin)
  154.      *
  155.      * @var   integer
  156.      *
  157.      * @ORM\Column (type="integer", options={ "unsigned": true })
  158.      */
  159.     protected $dateRangeBegin = 0;
  161.     /**
  162.      * Date range (end)
  163.      *
  164.      * @var   integer
  165.      *
  166.      * @ORM\Column (type="integer", options={ "unsigned": true })
  167.      */
  168.     protected $dateRangeEnd = 0;
  170.     /**
  171.      * Total range (begin)
  172.      *
  173.      * @var   float
  174.      *
  175.      * @ORM\Column (type="decimal", precision=14, scale=4)
  176.      */
  177.     protected $totalRangeBegin = 0;
  179.     /**
  180.      * Total range (end)
  181.      *
  182.      * @var   float
  183.      *
  184.      * @ORM\Column (type="decimal", precision=14, scale=4)
  185.      */
  186.     protected $totalRangeEnd = 0;
  188.     /**
  189.      * Uses limit
  190.      *
  191.      * @var   integer
  192.      *
  193.      * @ORM\Column (type="integer", options={ "unsigned": true })
  194.      */
  195.     protected $usesLimit = 0;
  197.     /**
  198.      * Uses limit per user
  199.      *
  200.      * @var   integer
  201.      *
  202.      * @ORM\Column (type="integer", options={ "unsigned": true })
  203.      */
  204.     protected $usesLimitPerUser = 0;
  206.     /**
  207.      * Flag: Can a coupon be used together with other coupons (false) or no (true)
  208.      *
  209.      * @var boolean
  210.      *
  211.      * @ORM\Column (type="boolean")
  212.      */
  213.     protected $singleUse = false;
  215.     /**
  216.      * Flag: Coupon is used for specific products or not
  217.      *
  218.      * @var boolean
  219.      *
  220.      * @ORM\Column (type="boolean")
  221.      */
  222.     protected $specificProducts = false;
  224.     /**
  225.      * Product classes
  226.      *
  227.      * @var   \Doctrine\Common\Collections\ArrayCollection
  228.      *
  229.      * @ORM\ManyToMany (targetEntity="XLite\Model\ProductClass", inversedBy="coupons")
  230.      * @ORM\JoinTable (name="product_class_coupons",
  231.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  232.      *      inverseJoinColumns={@ORM\JoinColumn (name="class_id", referencedColumnName="id", onDelete="CASCADE")}
  233.      * )
  234.      */
  235.     protected $productClasses;
  237.     /**
  238.      * Memberships
  239.      *
  240.      * @var   \Doctrine\Common\Collections\ArrayCollection
  241.      *
  242.      * @ORM\ManyToMany (targetEntity="XLite\Model\Membership", inversedBy="coupons")
  243.      * @ORM\JoinTable (name="membership_coupons",
  244.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  245.      *      inverseJoinColumns={@ORM\JoinColumn (name="membership_id", referencedColumnName="membership_id", onDelete="CASCADE")}
  246.      * )
  247.      */
  248.     protected $memberships;
  250.     /**
  251.      * Zones
  252.      *
  253.      * @var   \Doctrine\Common\Collections\ArrayCollection
  254.      *
  255.      * @ORM\ManyToMany (targetEntity="XLite\Model\Zone", inversedBy="coupons")
  256.      * @ORM\JoinTable (name="zone_coupons",
  257.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  258.      *      inverseJoinColumns={@ORM\JoinColumn (name="zone_id", referencedColumnName="zone_id", onDelete="CASCADE")}
  259.      * )
  260.      */
  261.     protected $zones;
  263.     /**
  264.      * Coupon products
  265.      *
  266.      * @var   \Doctrine\Common\Collections\ArrayCollection
  267.      *
  268.      * @ORM\OneToMany (targetEntity="CDev\Coupons\Model\CouponProduct", mappedBy="coupon", cascade={"persist"})
  269.      */
  270.     protected $couponProducts;
  272.     /**
  273.      * Used coupons
  274.      *
  275.      * @var   \Doctrine\Common\Collections\Collection
  276.      *
  277.      * @ORM\OneToMany (targetEntity="CDev\Coupons\Model\UsedCoupon", mappedBy="coupon")
  278.      */
  279.     protected $usedCoupons;
  281.     /**
  282.      * Categories
  283.      *
  284.      * @var   \Doctrine\Common\Collections\ArrayCollection
  285.      *
  286.      * @ORM\ManyToMany (targetEntity="XLite\Model\Category", inversedBy="coupons")
  287.      * @ORM\JoinTable (name="coupon_categories",
  288.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  289.      *      inverseJoinColumns={@ORM\JoinColumn (name="category_id", referencedColumnName="category_id", onDelete="CASCADE")}
  290.      * )
  291.      */
  292.     protected $categories;
  294.     /**
  295.      * @ORM\Column (type="string", options={ "fixed": true }, length=1)
  296.      */
  297.     protected string $applyFreeShippingTo = self::APPLY_FREESHIP_TO_CHEAPEST;
  299.     protected static $runtimeCacheForUsedCouponsCount = [];
  301.     /**
  302.      * Constructor
  303.      *
  304.      * @param array $data Entity properties OPTIONAL
  305.      */
  306.     public function __construct(array $data = [])
  307.     {
  308.         $this->productClasses = new \Doctrine\Common\Collections\ArrayCollection();
  309.         $this->memberships    = new \Doctrine\Common\Collections\ArrayCollection();
  310.         $this->zones    = new \Doctrine\Common\Collections\ArrayCollection();
  311.         $this->couponProducts    = new \Doctrine\Common\Collections\ArrayCollection();
  312.         $this->usedCoupons    = new \Doctrine\Common\Collections\ArrayCollection();
  313.         $this->categories     = new \Doctrine\Common\Collections\ArrayCollection();
  315.         parent::__construct($data);
  316.     }
  318.     /**
  319.      * Check - discount is absolute or not
  320.      *
  321.      * @return boolean
  322.      */
  323.     public function isAbsolute()
  324.     {
  325.         return $this->getType() === static::TYPE_ABSOLUTE;
  326.     }
  328.     /**
  329.      * Check - coupon is started
  330.      *
  331.      * @return boolean
  332.      */
  333.     public function isStarted()
  334.     {
  335.         return $this->getDateRangeBegin() === 0 || $this->getDateRangeBegin() < \XLite\Core\Converter::time();
  336.     }
  338.     /**
  339.      * Check - coupon is expired or not
  340.      *
  341.      * @return boolean
  342.      */
  343.     public function isExpired()
  344.     {
  345.         return 0 < $this->getDateRangeEnd() && $this->getDateRangeEnd() < \XLite\Core\Converter::time();
  346.     }
  348.     /**
  349.      * Check coupon activity
  350.      *
  351.      * @param \XLite\Model\Order $order Order OPTIONAL
  352.      *
  353.      * @return boolean
  354.      */
  355.     public function isActive(\XLite\Model\Order $order = null)
  356.     {
  357.         try {
  358.             $result = $this->checkCompatibility($order);
  359.         } catch (\CDev\Coupons\Core\CompatibilityException $exception) {
  360.             $result = false;
  361.         }
  363.         return $result;
  364.     }
  366.     /**
  367.      * Get public code
  368.      *
  369.      * @return string
  370.      */
  371.     public function getPublicCode()
  372.     {
  373.         $code = $this->getCode();
  375.         if ($this->isFreeShipping()) {
  376.             $code = sprintf('%s (%s)', $code, static::t('[coupons] Free shipping'));
  377.         }
  379.         return $code;
  380.     }
  382.     /**
  383.      * Get coupon public name
  384.      *
  385.      * @return string
  386.      */
  387.     public function getPublicName()
  388.     {
  389.         $suffix = '';
  391.         if ($this->getType() === \CDev\Coupons\Model\Coupon::TYPE_PERCENT) {
  392.             $suffix = sprintf('(%s%%)', $this->getValue());
  393.         }
  395.         return $this->getPublicCode() . ' ' . $suffix;
  396.     }
  398.     // {{{ Amount
  400.     /**
  401.      * Get amount
  402.      *
  403.      * @param \XLite\Model\Order $order Order
  404.      *
  405.      * @return float
  406.      */
  407.     public function getAmount(\XLite\Model\Order $order)
  408.     {
  409.         if ($this->isFreeShipping()) {
  410.             return 0;
  411.         }
  413.         $total = $this->getOrderTotal($order);
  415.         return $this->isAbsolute()
  416.             ? min($total, $this->getValue())
  417.             : ($total * $this->getValue() / 100);
  418.     }
  420.     /**
  421.      * Get order total
  422.      *
  423.      * @param \XLite\Model\Order $order Order
  424.      *
  425.      * @return float
  426.      */
  427.     protected function getOrderTotal(\XLite\Model\Order $order)
  428.     {
  429.         return array_reduce($this->getValidOrderItems($order), static function ($carry, $item) {
  430.             return $carry + $item->getSubtotal();
  431.         }, 0);
  432.     }
  434.     /**
  435.      * Get order items which are valid for the coupon
  436.      *
  437.      * @param \XLite\Model\Order $order Order
  438.      *
  439.      * @return array
  440.      */
  441.     protected function getValidOrderItems($order)
  442.     {
  443.         return $order->getValidItemsByCoupon($this);
  444.     }
  446.     /**
  447.      * Is coupon valid for product
  448.      *
  449.      * @param \XLite\Model\Product $product Product
  450.      *
  451.      * @return boolean
  452.      */
  453.     public function isValidForProduct(\XLite\Model\Product $product)
  454.     {
  455.         $result = true;
  457.         if (0 < count($this->getProductClasses())) {
  458.             // Check product class
  459.             $result = $product->getProductClass()
  460.                 && $this->getProductClasses()->contains($product->getProductClass());
  461.         }
  463.         if ($result && 0 < count($this->getCategories())) {
  464.             // Check categories
  465.             $result = false;
  466.             foreach ($product->getCategories() as $category) {
  467.                 if ($this->getCategories()->contains($category)) {
  468.                     $result = true;
  469.                     break;
  470.                 }
  471.             }
  472.         }
  474.         if ($result && $this->getSpecificProducts()) {
  475.             // Check product
  476.             $result = in_array($product->getProductId(), $this->getApplicableProductIds());
  477.         }
  479.         return $result;
  480.     }
  482.     // }}}
  484.     /**
  485.      * Check coupon compatibility
  486.      *
  487.      * @param \XLite\Model\Order $order Order
  488.      *
  489.      * @throws \CDev\Coupons\Core\CompatibilityException
  490.      *
  491.      * @return boolean
  492.      */
  493.     public function checkCompatibility(\XLite\Model\Order $order = null)
  494.     {
  495.         if (!$this->getEnabled()) {
  496.             $this->throwCompatibilityException(
  497.                 '',
  498.                 'Sorry, the coupon you entered is invalid. Make sure the coupon code is spelled correctly'
  499.             );
  500.         }
  502.         $this->checkDate();
  503.         $this->checkUsage();
  505.         if ($order) {
  506.             if ($order->getProfile()) {
  507.                 $this->checkPerUserUsage($order->getProfile(), $order->containsCoupon($this));
  508.             }
  509.             $this->checkConflictsWithCoupons($order);
  510.             $this->checkMembership($order);
  511.             if ($this->isFreeShipping()) {
  512.                 $this->checkAllItemsForCategory($order);
  513.                 $this->checkAllItemsForProducts($order);
  514.                 $this->checkAllItemForProductClass($order);
  515.             } else {
  516.                 $this->checkCategory($order);
  517.                 $this->checkProductClass($order);
  518.                 $this->checkProducts($order);
  519.             }
  520.             $this->checkOrderTotal($order);
  521.             $this->checkZone($order);
  522.         }
  524.         return true;
  525.     }
  527.     // {{{ Date
  529.     /**
  530.      * Check coupon dates
  531.      *
  532.      * @throws \CDev\Coupons\Core\CompatibilityException
  533.      *
  534.      * @return void
  535.      */
  536.     protected function checkDate()
  537.     {
  538.         if (!$this->isStarted()) {
  539.             $this->throwCompatibilityException(
  540.                 '',
  541.                 'Sorry, the coupon you entered is invalid. Make sure the coupon code is spelled correctly'
  542.             );
  543.         }
  544.         if ($this->isExpired()) {
  545.             $this->throwCompatibilityException(
  546.                 '',
  547.                 'Sorry, the coupon has expired'
  548.             );
  549.         }
  550.     }
  552.     // }}}
  554.     // {{{ Usage
  556.     /**
  557.      * Check coupon usages
  558.      *
  559.      * @throws \CDev\Coupons\Core\CompatibilityException
  560.      *
  561.      * @return void
  562.      */
  563.     protected function checkUsage()
  564.     {
  565.         if (0 < $this->getUsesLimit() && $this->getUsesLimit() <= $this->getUses()) {
  566.             $this->throwCompatibilityException(
  567.                 '',
  568.                 'Sorry, the coupon use limit has been reached'
  569.             );
  570.         }
  571.     }
  573.     /**
  574.      * Check coupon usages per user
  575.      *
  576.      * @throws \CDev\Coupons\Core\CompatibilityException
  577.      *
  578.      * @return void
  579.      */
  580.     protected function checkPerUserUsage(\XLite\Model\Profile $profile, $inOrder)
  581.     {
  582.         if (0 >= $this->getUsesLimitPerUser()) {
  583.             return;
  584.         }
  586.         $profileUsesCount = null;
  588.         if (array_key_exists($profile->getLogin(), static::$runtimeCacheForUsedCouponsCount)) {
  589.             $profileUsesCount = static::$runtimeCacheForUsedCouponsCount[$profile->getLogin()];
  590.         } else {
  591.             $profileUsesCount = $this->calculatePerUserUsage($profile);
  593.             static::$runtimeCacheForUsedCouponsCount[$profile->getLogin()] = $profileUsesCount;
  594.         }
  596.         if ($inOrder) {
  597.             $profileUsesCount -= 1;
  598.         }
  600.         if ($this->getUsesLimitPerUser() <= $profileUsesCount) {
  601.             $this->throwCompatibilityException(
  602.                 '',
  603.                 'Sorry, the coupon use limit has been reached'
  604.             );
  605.         }
  606.     }
  608.     /**
  609.      * @param \XLite\Model\Profile $profile
  610.      *
  611.      * @return int
  612.      */
  613.     protected function calculatePerUserUsage(\XLite\Model\Profile $profile)
  614.     {
  615.         return $this->getUsedCoupons()->filter(
  616.             static function ($usedCoupon) use ($profile) {
  617.                 /** @var \CDev\Coupons\Model\UsedCoupon $usedCoupon */
  618.                 $orderProfileIdentificator = $usedCoupon->getOrder()->getProfile()
  619.                     ? $usedCoupon->getOrder()->getProfile()->getLogin()
  620.                     : null;
  622.                 $currentProfileIdentificator = $profile->getLogin();
  624.                 return $orderProfileIdentificator
  625.                     && $currentProfileIdentificator
  626.                     && $orderProfileIdentificator === $currentProfileIdentificator;
  627.             }
  628.         )->count();
  629.     }
  631.     // }}}
  633.     // {{{ Coupons conflicts
  635.     /**
  636.      * Check if coupon is unique within an order
  637.      *
  638.      * @param \XLite\Model\Order $order Order
  639.      *
  640.      * @throws \CDev\Coupons\Core\CompatibilityException
  641.      *
  642.      * @return boolean
  643.      */
  644.     public function checkUnique(\XLite\Model\Order $order)
  645.     {
  646.         if ($order->containsCoupon($this)) {
  647.             $this->throwCompatibilityException(
  648.                 '',
  649.                 'You have already used the coupon'
  650.             );
  651.         }
  653.         return true;
  654.     }
  656.     /**
  657.      * Check coupon usages
  658.      *
  659.      * @param \XLite\Model\Order $order Order
  660.      *
  661.      * @throws \CDev\Coupons\Core\CompatibilityException
  662.      *
  663.      * @return void
  664.      */
  665.     protected function checkConflictsWithCoupons(\XLite\Model\Order $order)
  666.     {
  667.         if (!$order->containsCoupon($this)) {
  668.             if ($this->getSingleUse() && count($this->getOrderUsedCoupons($order))) {
  669.                 $this->throwCompatibilityException(
  670.                     static::ERROR_SINGLE_USE,
  671.                     'This coupon cannot be combined with other coupons'
  672.                 );
  673.             }
  675.             if (!$this->getSingleUse() && $this->hasOrderSingleCoupon($order)) {
  676.                 $this->throwCompatibilityException(
  677.                     static::ERROR_SINGLE_USE2,
  678.                     'Sorry, this coupon cannot be combined with the coupon already applied. Revome the previously applied coupon and try again.'
  679.                 );
  680.             }
  681.         }
  682.     }
  684.     /**
  685.      * @param \XLite\Model\Order $order
  686.      *
  687.      * @return array
  688.      */
  689.     protected function getOrderUsedCoupons($order)
  690.     {
  691.         return $order->getUsedCoupons();
  692.     }
  694.     /**
  695.      * @param \XLite\Model\Order $order
  696.      *
  697.      * @return bool
  698.      */
  699.     protected function hasOrderSingleCoupon($order)
  700.     {
  701.         return $order->hasSingleUseCoupon();
  702.     }
  704.     // }}}
  706.     // {{{ Total
  708.     /**
  709.      * Check order total
  710.      *
  711.      * @param \XLite\Model\Order $order Order
  712.      *
  713.      * @throws \CDev\Coupons\Core\CompatibilityException
  714.      *
  715.      * @return void
  716.      */
  717.     protected function checkOrderTotal(\XLite\Model\Order $order)
  718.     {
  719.         $total = $this->getOrderTotal($order);
  720.         $currency = $order->getCurrency();
  722.         $rangeBegin = $this->getTotalRangeBegin();
  723.         $rangeEnd = $this->getTotalRangeEnd();
  725.         $betweenTotalCoupon = $rangeBegin > 0 && $rangeEnd > 0;
  726.         $rangeBeginValid = $rangeBegin === 0.0 || $rangeBegin <= $total;
  727.         $rangeEndValid = $rangeEnd === 0.0 || $rangeEnd >= $total;
  729.         $hasProductsConditions = $this->getSpecificProducts()
  730.             || count($this->getCategories()) > 0
  731.             || count($this->getProductClasses()) > 0;
  733.         if ($betweenTotalCoupon && (!$rangeBeginValid || !$rangeEndValid)) {
  734.             $text = $hasProductsConditions
  735.                 ? $this->getBetweenSubtotalConditionalExceptionText()
  736.                 : $this->getBetweenSubtotalExceptionText();
  737.             $this->throwCompatibilityException(
  738.                 static::ERROR_TOTAL,
  739.                 $text,
  740.                 [
  741.                     'min' => implode('', $currency->formatParts($rangeBegin)),
  742.                     'max' => implode('', $currency->formatParts($rangeEnd)),
  743.                 ]
  744.             );
  745.         } elseif (!$rangeBeginValid) {
  746.             $text = $hasProductsConditions
  747.                 ? $this->getLeastSubtotalConditionalExceptionText()
  748.                 : $this->getLeastSubtotalExceptionText();
  749.             $this->throwCompatibilityException(
  750.                 static::ERROR_TOTAL,
  751.                 $text,
  752.                 [
  753.                     'min' => implode('', $currency->formatParts($rangeBegin))
  754.                 ]
  755.             );
  756.         } elseif (!$rangeEndValid) {
  757.             $text = $hasProductsConditions
  758.                 ? $this->getExceedSubtotalConditionalExceptionText()
  759.                 : $this->getExceedSubtotalExceptionText();
  760.             $this->throwCompatibilityException(
  761.                 static::ERROR_TOTAL,
  762.                 $text,
  763.                 [
  764.                     'max' => implode('', $currency->formatParts($rangeEnd))
  765.                 ]
  766.             );
  767.         }
  768.     }
  770.     /**
  771.      * Return text of exception
  772.      *
  773.      * @return void
  774.      */
  775.     protected function getBetweenSubtotalExceptionText()
  776.     {
  777.         return 'To use the coupon, your order subtotal must be between X and Y';
  778.     }
  780.     /**
  781.      * Return text of exception
  782.      *
  783.      * @return void
  784.      */
  785.     protected function getLeastSubtotalExceptionText()
  786.     {
  787.         return 'To use the coupon, your order subtotal must be at least X';
  788.     }
  790.     /**
  791.      * Return text of exception
  792.      *
  793.      * @return void
  794.      */
  795.     protected function getExceedSubtotalExceptionText()
  796.     {
  797.         return 'To use the coupon, your order subtotal must not exceed Y';
  798.     }
  800.     /**
  801.      * Return text of exception
  802.      *
  803.      * @return void
  804.      */
  805.     protected function getBetweenSubtotalConditionalExceptionText()
  806.     {
  807.         return 'To use the coupon, your order subtotal must be between X and Y for specific products';
  808.     }
  810.     /**
  811.      * Return text of exception
  812.      *
  813.      * @return void
  814.      */
  815.     protected function getLeastSubtotalConditionalExceptionText()
  816.     {
  817.         return 'To use the coupon, your order subtotal must be at least X for specific products';
  818.     }
  820.     /**
  821.      * Return text of exception
  822.      *
  823.      * @return void
  824.      */
  825.     protected function getExceedSubtotalConditionalExceptionText()
  826.     {
  827.         return 'To use the coupon, your order subtotal must not exceed Y for specific products';
  828.     }
  830.     // }}}
  832.     // {{{ Category
  834.     /**
  835.      * Check coupon category
  836.      *
  837.      * @param \XLite\Model\Order $order Order
  838.      *
  839.      * @throws \CDev\Coupons\Core\CompatibilityException
  840.      *
  841.      * @return void
  842.      */
  843.     protected function checkCategory(\XLite\Model\Order $order)
  844.     {
  845.         if ($this->getCategories()->count()) {
  846.             $found = false;
  848.             foreach ($order->getItems() as $item) {
  849.                 foreach ($item->getProduct()->getCategories() as $category) {
  850.                     if ($this->getCategories()->contains($category)) {
  851.                         $found = true;
  853.                         break;
  854.                     }
  855.                 }
  857.                 if ($found) {
  858.                     break;
  859.                 }
  860.             }
  862.             if (!$found) {
  863.                 $this->throwCompatibilityException(
  864.                     '',
  865.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  866.                 );
  867.             }
  868.         }
  869.     }
  871.     // }}}
  873.     // {{{ Products
  875.     /**
  876.      * Check coupon products
  877.      *
  878.      * @param \XLite\Model\Order $order Order
  879.      *
  880.      * @throws \CDev\Coupons\Core\CompatibilityException
  881.      *
  882.      * @return void
  883.      */
  884.     protected function checkProducts(\XLite\Model\Order $order)
  885.     {
  886.         if ($this->getSpecificProducts()) {
  887.             $applicableProductIds = $this->getApplicableProductIds();
  889.             $found = false;
  891.             foreach ($order->getItems() as $item) {
  892.                 if (in_array($item->getProduct()->getProductId(), $applicableProductIds)) {
  893.                     $found = true;
  894.                     break;
  895.                 }
  896.             }
  898.             if (!$found) {
  899.                 $this->throwCompatibilityException(
  900.                     '',
  901.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  902.                 );
  903.             }
  904.         }
  905.     }
  907.     // }}}
  909.     // {{{ Membership
  911.     /**
  912.      * Check coupon membership
  913.      *
  914.      * @param \XLite\Model\Order $order Order
  915.      *
  916.      * @throws \CDev\Coupons\Core\CompatibilityException
  917.      *
  918.      * @return void
  919.      */
  920.     protected function checkMembership(\XLite\Model\Order $order)
  921.     {
  922.         if (
  923.             $this->getMemberships()->count()
  924.             && (!$order->getProfile()
  925.                 || !$this->getMemberships()->contains($order->getProfile()->getMembership())
  926.             )
  927.         ) {
  928.             $this->throwCompatibilityException(
  929.                 '',
  930.                 'Sorry, the coupon you entered is not valid for your membership level. Contact the administrator'
  931.             );
  932.         }
  933.     }
  935.     // }}}
  937.     // {{{ Zone
  939.     /**
  940.      * Check coupon zone
  941.      *
  942.      * @param \XLite\Model\Order $order Order
  943.      *
  944.      * @throws \CDev\Coupons\Core\CompatibilityException
  945.      *
  946.      * @return void
  947.      */
  948.     protected function checkZone(\XLite\Model\Order $order)
  949.     {
  950.         $profile = $order->getProfile();
  951.         $shippingAddress = $profile ? $profile->getShippingAddress() : null;
  953.         if (!$shippingAddress) {
  954.             $shippingAddress = \XLite\Model\Address::createDefaultShippingAddress();
  955.         }
  957.         if ($shippingAddress && !$this->getZones()->isEmpty()) {
  958.             $applicableZones = \XLite\Core\Database::getRepo('XLite\Model\Zone')->findApplicableZones($shippingAddress->toArray());
  959.             $couponZoneIds = array_map(static function ($zone) {
  960.                 return $zone->getZoneId();
  961.             }, $this->getZones()->toArray());
  963.             $isApplicable = false;
  964.             foreach ($applicableZones as $zone) {
  965.                 if (in_array($zone->getZoneId(), $couponZoneIds)) {
  966.                     $isApplicable = true;
  967.                     break;
  968.                 }
  969.             }
  971.             if (!$isApplicable) {
  972.                 $this->throwCompatibilityException(
  973.                     '',
  974.                     'Sorry, the coupon you entered cannot be applied to this delivery address'
  975.                 );
  976.             }
  977.         }
  978.     }
  980.     // }}}
  982.     // {{{ Product class
  984.     /**
  985.      * Check coupon product class
  986.      *
  987.      * @param \XLite\Model\Order $order Order
  988.      *
  989.      * @throws \CDev\Coupons\Core\CompatibilityException
  990.      *
  991.      * @return void
  992.      */
  993.     protected function checkProductClass(\XLite\Model\Order $order)
  994.     {
  995.         if ($this->getProductClasses()->count()) {
  996.             $found = false;
  997.             foreach ($order->getItems() as $item) {
  998.                 if (
  999.                     $item->getProduct()->getProductClass()
  1000.                     && $this->getProductClasses()->contains($item->getProduct()->getProductClass())
  1001.                 ) {
  1002.                     $found = true;
  1004.                     break;
  1005.                 }
  1006.             }
  1008.             if (!$found) {
  1009.                 $this->throwCompatibilityException(
  1010.                     '',
  1011.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  1012.                 );
  1013.             }
  1014.         }
  1015.     }
  1017.     // }}}
  1019.     /**
  1020.      * @throws \CDev\Coupons\Core\CompatibilityException
  1021.      * @return void
  1022.      */
  1023.     protected function checkAllItemsForCategory(\XLite\Model\Order $order)
  1024.     {
  1025.         if ($this->getCategories()->count()) {
  1026.             $isAll = true;
  1028.             foreach ($order->getItems() as $item) {
  1029.                 if (!$this->isItemApplyCategoryCondition($item)) {
  1030.                     $isAll = false;
  1031.                     break;
  1032.                 }
  1033.             }
  1035.             if (!$isAll) {
  1036.                 $this->throwCompatibilityException(
  1037.                     '',
  1038.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  1039.                 );
  1040.             }
  1041.         }
  1042.     }
  1044.     protected function isItemApplyCategoryCondition(\XLite\Model\OrderItem $item): bool
  1045.     {
  1046.         $found = false;
  1047.         foreach ($item->getProduct()->getCategories() as $category) {
  1048.             if ($this->getCategories()->contains($category)) {
  1049.                 $found = true;
  1050.                 break;
  1051.             }
  1052.         }
  1054.         return $found;
  1055.     }
  1057.     /**
  1058.      * @throws \CDev\Coupons\Core\CompatibilityException
  1059.      * @return void
  1060.      */
  1061.     protected function checkAllItemsForProducts(\XLite\Model\Order $order)
  1062.     {
  1063.         if ($this->getSpecificProducts()) {
  1064.             $applicableProductIds = $this->getApplicableProductIds();
  1066.             $isAll = true;
  1068.             foreach ($order->getItems() as $item) {
  1069.                 if (!in_array($item->getProduct()->getProductId(), $applicableProductIds)) {
  1070.                     $isAll = false;
  1071.                     break;
  1072.                 }
  1073.             }
  1075.             if (!$isAll) {
  1076.                 $this->throwCompatibilityException(
  1077.                     '',
  1078.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  1079.                 );
  1080.             }
  1081.         }
  1082.     }
  1084.     /**
  1085.      * @throws \CDev\Coupons\Core\CompatibilityException
  1086.      * @return void
  1087.      */
  1088.     protected function checkAllItemForProductClass(\XLite\Model\Order $order)
  1089.     {
  1090.         if ($this->getProductClasses()->count()) {
  1091.             $isAll = true;
  1092.             foreach ($order->getItems() as $item) {
  1093.                 $itemProductClass = $item->getProduct()->getProductClass();
  1094.                 if (
  1095.                     !$itemProductClass
  1096.                     || !$this->getProductClasses()->contains($itemProductClass)
  1097.                 ) {
  1098.                     $isAll = false;
  1099.                     break;
  1100.                 }
  1101.             }
  1103.             if (!$isAll) {
  1104.                 $this->throwCompatibilityException(
  1105.                     '',
  1106.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  1107.                 );
  1108.             }
  1109.         }
  1110.     }
  1112.     /**
  1113.      * Throws exception
  1114.      *
  1115.      * @param string $code    Message params
  1116.      * @param string $message Message text
  1117.      * @param array  $params  Message params
  1118.      *
  1119.      * @throws \CDev\Coupons\Core\CompatibilityException
  1120.      *
  1121.      * @return void
  1122.      */
  1123.     protected function throwCompatibilityException($code = '', $message = null, array $params = [])
  1124.     {
  1125.         throw new \CDev\Coupons\Core\CompatibilityException($message, $params, $this, $code);
  1126.     }
  1128.     /**
  1129.      * Get id
  1130.      *
  1131.      * @return integer
  1132.      */
  1133.     public function getId()
  1134.     {
  1135.         return $this->id;
  1136.     }
  1138.     /**
  1139.      * Set code
  1140.      *
  1141.      * @param string $code
  1142.      * @return Coupon
  1143.      */
  1144.     public function setCode($code)
  1145.     {
  1146.         $this->code = $code;
  1147.         return $this;
  1148.     }
  1150.     /**
  1151.      * Get code
  1152.      *
  1153.      * @return string
  1154.      */
  1155.     public function getCode()
  1156.     {
  1157.         return $this->code;
  1158.     }
  1160.     /**
  1161.      * Set enabled
  1162.      *
  1163.      * @param boolean $enabled
  1164.      * @return Coupon
  1165.      */
  1166.     public function setEnabled($enabled)
  1167.     {
  1168.         $this->enabled = (bool)$enabled;
  1169.         return $this;
  1170.     }
  1172.     /**
  1173.      * Get enabled
  1174.      *
  1175.      * @return boolean
  1176.      */
  1177.     public function getEnabled()
  1178.     {
  1179.         return $this->enabled;
  1180.     }
  1182.     /**
  1183.      * Set value
  1184.      *
  1185.      * @param float $value
  1186.      * @return Coupon
  1187.      */
  1188.     public function setValue($value)
  1189.     {
  1190.         $this->value = $value;
  1191.         return $this;
  1192.     }
  1194.     /**
  1195.      * Get value
  1196.      *
  1197.      * @return float
  1198.      */
  1199.     public function getValue()
  1200.     {
  1201.         return $this->value;
  1202.     }
  1204.     /**
  1205.      * Set type
  1206.      *
  1207.      * @param string $type
  1208.      * @return Coupon
  1209.      */
  1210.     public function setType($type)
  1211.     {
  1212.         $this->type = $type;
  1213.         return $this;
  1214.     }
  1216.     /**
  1217.      * Get type
  1218.      *
  1219.      * @return string
  1220.      */
  1221.     public function getType()
  1222.     {
  1223.         return $this->type;
  1224.     }
  1226.     /**
  1227.      * Set comment
  1228.      *
  1229.      * @param string $comment
  1230.      * @return Coupon
  1231.      */
  1232.     public function setComment($comment)
  1233.     {
  1234.         $this->comment = $comment;
  1235.         return $this;
  1236.     }
  1238.     /**
  1239.      * Get comment
  1240.      *
  1241.      * @return string
  1242.      */
  1243.     public function getComment()
  1244.     {
  1245.         return $this->comment;
  1246.     }
  1248.     /**
  1249.      * Set uses
  1250.      *
  1251.      * @param integer $uses
  1252.      * @return Coupon
  1253.      */
  1254.     public function setUses($uses)
  1255.     {
  1256.         $this->uses = $uses;
  1257.         return $this;
  1258.     }
  1260.     /**
  1261.      * Get uses
  1262.      *
  1263.      * @return integer
  1264.      */
  1265.     public function getUses()
  1266.     {
  1267.         return $this->uses;
  1268.     }
  1270.     /**
  1271.      * Set dateRangeBegin
  1272.      *
  1273.      * @param integer $dateRangeBegin
  1274.      * @return Coupon
  1275.      */
  1276.     public function setDateRangeBegin($dateRangeBegin)
  1277.     {
  1278.         $this->dateRangeBegin = $dateRangeBegin;
  1279.         return $this;
  1280.     }
  1282.     /**
  1283.      * Get dateRangeBegin
  1284.      *
  1285.      * @return integer
  1286.      */
  1287.     public function getDateRangeBegin()
  1288.     {
  1289.         return $this->dateRangeBegin;
  1290.     }
  1292.     /**
  1293.      * Set dateRangeEnd
  1294.      *
  1295.      * @param integer $dateRangeEnd
  1296.      * @return Coupon
  1297.      */
  1298.     public function setDateRangeEnd($dateRangeEnd)
  1299.     {
  1300.         $this->dateRangeEnd = $dateRangeEnd;
  1301.         return $this;
  1302.     }
  1304.     /**
  1305.      * Get dateRangeEnd
  1306.      *
  1307.      * @return integer
  1308.      */
  1309.     public function getDateRangeEnd()
  1310.     {
  1311.         return $this->dateRangeEnd;
  1312.     }
  1314.     /**
  1315.      * Set totalRangeBegin
  1316.      *
  1317.      * @param float $totalRangeBegin
  1318.      * @return Coupon
  1319.      */
  1320.     public function setTotalRangeBegin($totalRangeBegin)
  1321.     {
  1322.         $this->totalRangeBegin = $totalRangeBegin;
  1323.         return $this;
  1324.     }
  1326.     /**
  1327.      * Get totalRangeBegin
  1328.      *
  1329.      * @return float
  1330.      */
  1331.     public function getTotalRangeBegin()
  1332.     {
  1333.         return $this->totalRangeBegin;
  1334.     }
  1336.     /**
  1337.      * Set totalRangeEnd
  1338.      *
  1339.      * @param float $totalRangeEnd
  1340.      * @return Coupon
  1341.      */
  1342.     public function setTotalRangeEnd($totalRangeEnd)
  1343.     {
  1344.         $this->totalRangeEnd = $totalRangeEnd;
  1345.         return $this;
  1346.     }
  1348.     /**
  1349.      * Get totalRangeEnd
  1350.      *
  1351.      * @return float
  1352.      */
  1353.     public function getTotalRangeEnd()
  1354.     {
  1355.         return $this->totalRangeEnd;
  1356.     }
  1358.     /**
  1359.      * Set usesLimit
  1360.      *
  1361.      * @param integer $usesLimit
  1362.      * @return Coupon
  1363.      */
  1364.     public function setUsesLimit($usesLimit)
  1365.     {
  1366.         $this->usesLimit = $usesLimit;
  1367.         return $this;
  1368.     }
  1370.     /**
  1371.      * Get usesLimit
  1372.      *
  1373.      * @return integer
  1374.      */
  1375.     public function getUsesLimit()
  1376.     {
  1377.         return $this->usesLimit;
  1378.     }
  1380.     /**
  1381.      * Set usesLimitPerUser
  1382.      *
  1383.      * @param integer $usesLimitPerUser
  1384.      * @return Coupon
  1385.      */
  1386.     public function setUsesLimitPerUser($usesLimitPerUser)
  1387.     {
  1388.         $this->usesLimitPerUser = $usesLimitPerUser;
  1389.         return $this;
  1390.     }
  1392.     /**
  1393.      * Get usesLimitPerUser
  1394.      *
  1395.      * @return integer
  1396.      */
  1397.     public function getUsesLimitPerUser()
  1398.     {
  1399.         return $this->usesLimitPerUser;
  1400.     }
  1402.     /**
  1403.      * Set singleUse
  1404.      *
  1405.      * @param boolean $singleUse
  1406.      * @return Coupon
  1407.      */
  1408.     public function setSingleUse($singleUse)
  1409.     {
  1410.         $this->singleUse = $singleUse;
  1411.         return $this;
  1412.     }
  1414.     /**
  1415.      * Get singleUse
  1416.      *
  1417.      * @return boolean
  1418.      */
  1419.     public function getSingleUse()
  1420.     {
  1421.         return $this->singleUse;
  1422.     }
  1424.     /**
  1425.      * Set specificProducts
  1426.      *
  1427.      * @param boolean $specificProducts
  1428.      * @return Coupon
  1429.      */
  1430.     public function setSpecificProducts($specificProducts)
  1431.     {
  1432.         $this->specificProducts = $specificProducts;
  1433.         return $this;
  1434.     }
  1436.     /**
  1437.      * Get specificProducts
  1438.      *
  1439.      * @return boolean
  1440.      */
  1441.     public function getSpecificProducts()
  1442.     {
  1443.         return $this->specificProducts;
  1444.     }
  1446.     /**
  1447.      * Add productClasses
  1448.      *
  1449.      * @param \XLite\Model\ProductClass $productClasses
  1450.      * @return Coupon
  1451.      */
  1452.     public function addProductClasses(\XLite\Model\ProductClass $productClasses)
  1453.     {
  1454.         $this->productClasses[] = $productClasses;
  1455.         return $this;
  1456.     }
  1458.     /**
  1459.      * Get productClasses
  1460.      *
  1461.      * @return \Doctrine\Common\Collections\Collection
  1462.      */
  1463.     public function getProductClasses()
  1464.     {
  1465.         return $this->productClasses;
  1466.     }
  1468.     /**
  1469.      * Clear product classes
  1470.      */
  1471.     public function clearProductClasses()
  1472.     {
  1473.         foreach ($this->getProductClasses()->getKeys() as $key) {
  1474.             $this->getProductClasses()->remove($key);
  1475.         }
  1476.     }
  1478.     /**
  1479.      * Add memberships
  1480.      *
  1481.      * @param \XLite\Model\Membership $memberships
  1482.      * @return Coupon
  1483.      */
  1484.     public function addMemberships(\XLite\Model\Membership $memberships)
  1485.     {
  1486.         $this->memberships[] = $memberships;
  1487.         return $this;
  1488.     }
  1490.     /**
  1491.      * Get memberships
  1492.      *
  1493.      * @return \Doctrine\Common\Collections\Collection
  1494.      */
  1495.     public function getMemberships()
  1496.     {
  1497.         return $this->memberships;
  1498.     }
  1500.     /**
  1501.      * Add coupon products
  1502.      *
  1503.      * @param \CDev\Coupons\Model\CouponProduct $couponProduct
  1504.      * @return Coupon
  1505.      */
  1506.     public function addCouponProducts(\CDev\Coupons\Model\CouponProduct $couponProduct)
  1507.     {
  1508.         $this->couponProducts[] = $couponProduct;
  1509.         return $this;
  1510.     }
  1512.     /**
  1513.      * Get product ids if coupon is specificProducts
  1514.      *
  1515.      * @return array
  1516.      */
  1517.     public function getApplicableProductIds()
  1518.     {
  1519.         $ids = [];
  1520.         if ($this->isPersistent() && $this->getSpecificProducts()) {
  1521.             $ids = \XLite\Core\Database::getRepo('CDev\Coupons\Model\CouponProduct')
  1522.                 ->getCouponProductIds($this->getId());
  1523.         }
  1525.         return $ids;
  1526.     }
  1528.     /**
  1529.      * Get coupon products
  1530.      *
  1531.      * @return \Doctrine\Common\Collections\Collection
  1532.      */
  1533.     public function getCouponProducts()
  1534.     {
  1535.         return $this->couponProducts;
  1536.     }
  1538.     /**
  1539.      * Clear memberships
  1540.      */
  1541.     public function clearMemberships()
  1542.     {
  1543.         foreach ($this->getMemberships()->getKeys() as $key) {
  1544.             $this->getMemberships()->remove($key);
  1545.         }
  1546.     }
  1548.     /**
  1549.      * Add zones
  1550.      *
  1551.      * @param \XLite\Model\Zone $zone
  1552.      * @return Coupon
  1553.      */
  1554.     public function addZones(\XLite\Model\Zone $zone)
  1555.     {
  1556.         $this->zones[] = $zone;
  1557.         return $this;
  1558.     }
  1560.     /**
  1561.      * Get zones
  1562.      *
  1563.      * @return \Doctrine\Common\Collections\ArrayCollection
  1564.      */
  1565.     public function getZones()
  1566.     {
  1567.         return $this->zones;
  1568.     }
  1570.     /**
  1571.      * Clear zones
  1572.      */
  1573.     public function clearZones()
  1574.     {
  1575.         foreach ($this->getZones()->getKeys() as $key) {
  1576.             $this->getZones()->remove($key);
  1577.         }
  1578.     }
  1580.     /**
  1581.      * Add usedCoupons
  1582.      *
  1583.      * @param \CDev\Coupons\Model\UsedCoupon $usedCoupons
  1584.      * @return Coupon
  1585.      */
  1586.     public function addUsedCoupons(\CDev\Coupons\Model\UsedCoupon $usedCoupons)
  1587.     {
  1588.         $this->usedCoupons[] = $usedCoupons;
  1589.         return $this;
  1590.     }
  1592.     /**
  1593.      * Get usedCoupons
  1594.      *
  1595.      * @return \Doctrine\Common\Collections\Collection|\CDev\Coupons\Model\UsedCoupon[]
  1596.      */
  1597.     public function getUsedCoupons()
  1598.     {
  1599.         return $this->usedCoupons;
  1600.     }
  1602.     /**
  1603.      * Add categories
  1604.      *
  1605.      * @param \XLite\Model\Category $categories
  1606.      * @return Coupon
  1607.      */
  1608.     public function addCategories(\XLite\Model\Category $categories)
  1609.     {
  1610.         $this->getCategories()->add($categories);
  1611.         return $this;
  1612.     }
  1614.     /**
  1615.      * Get categories
  1616.      *
  1617.      * @return \Doctrine\Common\Collections\Collection
  1618.      */
  1619.     public function getCategories()
  1620.     {
  1621.         return $this->categories;
  1622.     }
  1624.     /**
  1625.      * Clear categories
  1626.      */
  1627.     public function clearCategories()
  1628.     {
  1629.         foreach ($this->getCategories()->getKeys() as $key) {
  1630.             $this->getCategories()->remove($key);
  1631.         }
  1632.     }
  1634.     public function getApplyFreeShippingTo(): string
  1635.     {
  1636.         return $this->applyFreeShippingTo;
  1637.     }
  1639.     public function setApplyFreeShippingTo(string $applyFreeShippingTo): void
  1640.     {
  1641.         $this->applyFreeShippingTo = $applyFreeShippingTo;
  1642.     }
  1644.     public static function getReadableApplyFreeShippingTo(): array
  1645.     {
  1646.         return [
  1647.             static::APPLY_FREESHIP_TO_CHEAPEST    => static::t('[coupons] The cheapest shipping option'),
  1648.             static::APPLY_FREESHIP_TO_FREE_METHOD => static::t('[coupons] Free shipping method'),
  1649.         ];
  1650.     }
  1652.     public function isFreeShippingCheapestType(): bool
  1653.     {
  1654.         return $this->isFreeShipping()
  1655.             && $this->applyFreeShippingTo === static::APPLY_FREESHIP_TO_CHEAPEST;
  1656.     }
  1658.     public function isFreeShippingFreeMethodType(): bool
  1659.     {
  1660.         return $this->isFreeShipping()
  1661.             && $this->applyFreeShippingTo === static::APPLY_FREESHIP_TO_FREE_METHOD;
  1662.     }
  1664.     public function isFreeShipping(): bool
  1665.     {
  1666.         return $this->getType() === static::TYPE_FREESHIP;
  1667.     }
  1668. }