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

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