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';
  84.     /**
  85.      * Product unique ID
  86.      *
  87.      * @var   integer
  88.      *
  89.      * @ORM\Id
  90.      * @ORM\GeneratedValue (strategy="AUTO")
  91.      * @ORM\Column         (type="integer", options={ "unsigned": true })
  92.      */
  93.     protected $id;
  95.     /**
  96.      * Code
  97.      *
  98.      * @var   string
  99.      *
  100.      * @ORM\Column (type="string", options={ "fixed": true }, length=16)
  101.      */
  102.     protected $code;
  104.     /**
  105.      * Enabled status
  106.      *
  107.      * @var   boolean
  108.      *
  109.      * @ORM\Column (type="boolean")
  110.      */
  111.     protected $enabled = true;
  113.     /**
  114.      * Value
  115.      *
  116.      * @var   float
  117.      *
  118.      * @ORM\Column (type="decimal", precision=14, scale=4)
  119.      */
  120.     protected $value = 0.0000;
  122.     /**
  123.      * Type
  124.      *
  125.      * @var   string
  126.      *
  127.      * @ORM\Column (type="string", options={ "fixed": true }, length=1)
  128.      */
  129.     protected $type = self::TYPE_PERCENT;
  131.     /**
  132.      * Comment
  133.      *
  134.      * @var   string
  135.      *
  136.      * @ORM\Column (type="string", length=64)
  137.      */
  138.     protected $comment = '';
  140.     /**
  141.      * Uses count
  142.      *
  143.      * @var   integer
  144.      *
  145.      * @ORM\Column (type="integer", options={ "unsigned": true })
  146.      */
  147.     protected $uses = 0;
  149.     /**
  150.      * Date range (begin)
  151.      *
  152.      * @var   integer
  153.      *
  154.      * @ORM\Column (type="integer", options={ "unsigned": true })
  155.      */
  156.     protected $dateRangeBegin = 0;
  158.     /**
  159.      * Date range (end)
  160.      *
  161.      * @var   integer
  162.      *
  163.      * @ORM\Column (type="integer", options={ "unsigned": true })
  164.      */
  165.     protected $dateRangeEnd = 0;
  167.     /**
  168.      * Total range (begin)
  169.      *
  170.      * @var   float
  171.      *
  172.      * @ORM\Column (type="decimal", precision=14, scale=4)
  173.      */
  174.     protected $totalRangeBegin = 0;
  176.     /**
  177.      * Total range (end)
  178.      *
  179.      * @var   float
  180.      *
  181.      * @ORM\Column (type="decimal", precision=14, scale=4)
  182.      */
  183.     protected $totalRangeEnd = 0;
  185.     /**
  186.      * Uses limit
  187.      *
  188.      * @var   integer
  189.      *
  190.      * @ORM\Column (type="integer", options={ "unsigned": true })
  191.      */
  192.     protected $usesLimit = 0;
  194.     /**
  195.      * Uses limit per user
  196.      *
  197.      * @var   integer
  198.      *
  199.      * @ORM\Column (type="integer", options={ "unsigned": true })
  200.      */
  201.     protected $usesLimitPerUser = 0;
  203.     /**
  204.      * Flag: Can a coupon be used together with other coupons (false) or no (true)
  205.      *
  206.      * @var boolean
  207.      *
  208.      * @ORM\Column (type="boolean")
  209.      */
  210.     protected $singleUse = false;
  212.     /**
  213.      * Flag: Coupon is used for specific products or not
  214.      *
  215.      * @var boolean
  216.      *
  217.      * @ORM\Column (type="boolean")
  218.      */
  219.     protected $specificProducts = false;
  221.     /**
  222.      * Product classes
  223.      *
  224.      * @var   \Doctrine\Common\Collections\ArrayCollection
  225.      *
  226.      * @ORM\ManyToMany (targetEntity="XLite\Model\ProductClass", inversedBy="coupons")
  227.      * @ORM\JoinTable (name="product_class_coupons",
  228.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  229.      *      inverseJoinColumns={@ORM\JoinColumn (name="class_id", referencedColumnName="id", onDelete="CASCADE")}
  230.      * )
  231.      */
  232.     protected $productClasses;
  234.     /**
  235.      * Memberships
  236.      *
  237.      * @var   \Doctrine\Common\Collections\ArrayCollection
  238.      *
  239.      * @ORM\ManyToMany (targetEntity="XLite\Model\Membership", inversedBy="coupons")
  240.      * @ORM\JoinTable (name="membership_coupons",
  241.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  242.      *      inverseJoinColumns={@ORM\JoinColumn (name="membership_id", referencedColumnName="membership_id", onDelete="CASCADE")}
  243.      * )
  244.      */
  245.     protected $memberships;
  247.     /**
  248.      * Zones
  249.      *
  250.      * @var   \Doctrine\Common\Collections\ArrayCollection
  251.      *
  252.      * @ORM\ManyToMany (targetEntity="XLite\Model\Zone", inversedBy="coupons")
  253.      * @ORM\JoinTable (name="zone_coupons",
  254.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  255.      *      inverseJoinColumns={@ORM\JoinColumn (name="zone_id", referencedColumnName="zone_id", onDelete="CASCADE")}
  256.      * )
  257.      */
  258.     protected $zones;
  260.     /**
  261.      * Coupon products
  262.      *
  263.      * @var   \Doctrine\Common\Collections\ArrayCollection
  264.      *
  265.      * @ORM\OneToMany (targetEntity="CDev\Coupons\Model\CouponProduct", mappedBy="coupon", cascade={"persist"})
  266.      */
  267.     protected $couponProducts;
  269.     /**
  270.      * Used coupons
  271.      *
  272.      * @var   \Doctrine\Common\Collections\Collection
  273.      *
  274.      * @ORM\OneToMany (targetEntity="CDev\Coupons\Model\UsedCoupon", mappedBy="coupon")
  275.      */
  276.     protected $usedCoupons;
  278.     /**
  279.      * Categories
  280.      *
  281.      * @var   \Doctrine\Common\Collections\ArrayCollection
  282.      *
  283.      * @ORM\ManyToMany (targetEntity="XLite\Model\Category", inversedBy="coupons")
  284.      * @ORM\JoinTable (name="coupon_categories",
  285.      *      joinColumns={@ORM\JoinColumn (name="coupon_id", referencedColumnName="id", onDelete="CASCADE")},
  286.      *      inverseJoinColumns={@ORM\JoinColumn (name="category_id", referencedColumnName="category_id", onDelete="CASCADE")}
  287.      * )
  288.      */
  289.     protected $categories;
  291.     protected static $runtimeCacheForUsedCouponsCount = [];
  293.     /**
  294.      * Constructor
  295.      *
  296.      * @param array $data Entity properties OPTIONAL
  297.      */
  298.     public function __construct(array $data = [])
  299.     {
  300.         $this->productClasses = new \Doctrine\Common\Collections\ArrayCollection();
  301.         $this->memberships    = new \Doctrine\Common\Collections\ArrayCollection();
  302.         $this->zones    = new \Doctrine\Common\Collections\ArrayCollection();
  303.         $this->couponProducts    = new \Doctrine\Common\Collections\ArrayCollection();
  304.         $this->usedCoupons    = new \Doctrine\Common\Collections\ArrayCollection();
  305.         $this->categories     = new \Doctrine\Common\Collections\ArrayCollection();
  307.         parent::__construct($data);
  308.     }
  310.     /**
  311.      * Check - discount is absolute or not
  312.      *
  313.      * @return boolean
  314.      */
  315.     public function isAbsolute()
  316.     {
  317.         return $this->getType() === static::TYPE_ABSOLUTE;
  318.     }
  320.     /**
  321.      * Check - coupon is started
  322.      *
  323.      * @return boolean
  324.      */
  325.     public function isStarted()
  326.     {
  327.         return $this->getDateRangeBegin() === 0 || $this->getDateRangeBegin() < \XLite\Core\Converter::time();
  328.     }
  330.     /**
  331.      * Check - coupon is expired or not
  332.      *
  333.      * @return boolean
  334.      */
  335.     public function isExpired()
  336.     {
  337.         return 0 < $this->getDateRangeEnd() && $this->getDateRangeEnd() < \XLite\Core\Converter::time();
  338.     }
  340.     /**
  341.      * Check coupon activity
  342.      *
  343.      * @param \XLite\Model\Order $order Order OPTIONAL
  344.      *
  345.      * @return boolean
  346.      */
  347.     public function isActive(\XLite\Model\Order $order = null)
  348.     {
  349.         try {
  350.             $result = $this->checkCompatibility($order);
  351.         } catch (\CDev\Coupons\Core\CompatibilityException $exception) {
  352.             $result = false;
  353.         }
  355.         return $result;
  356.     }
  358.     /**
  359.      * Get public code
  360.      *
  361.      * @return string
  362.      */
  363.     public function getPublicCode()
  364.     {
  365.         return $this->getCode();
  366.     }
  368.     /**
  369.      * Get coupon public name
  370.      *
  371.      * @return string
  372.      */
  373.     public function getPublicName()
  374.     {
  375.         $suffix = '';
  377.         if ($this->getType() === \CDev\Coupons\Model\Coupon::TYPE_PERCENT) {
  378.             $suffix = sprintf('(%s%%)', $this->getValue());
  379.         }
  381.         return $this->getPublicCode() . ' ' . $suffix;
  382.     }
  384.     // {{{ Amount
  386.     /**
  387.      * Get amount
  388.      *
  389.      * @param \XLite\Model\Order $order Order
  390.      *
  391.      * @return float
  392.      */
  393.     public function getAmount(\XLite\Model\Order $order)
  394.     {
  395.         $total = $this->getOrderTotal($order);
  397.         return $this->isAbsolute()
  398.             ? min($total, $this->getValue())
  399.             : ($total * $this->getValue() / 100);
  400.     }
  402.     /**
  403.      * Get order total
  404.      *
  405.      * @param \XLite\Model\Order $order Order
  406.      *
  407.      * @return float
  408.      */
  409.     protected function getOrderTotal(\XLite\Model\Order $order)
  410.     {
  411.         return array_reduce($this->getValidOrderItems($order), static function ($carry, $item) {
  412.             return $carry + $item->getSubtotal();
  413.         }, 0);
  414.     }
  416.     /**
  417.      * Get order items which are valid for the coupon
  418.      *
  419.      * @param \XLite\Model\Order $order Order
  420.      *
  421.      * @return array
  422.      */
  423.     protected function getValidOrderItems($order)
  424.     {
  425.         return $order->getValidItemsByCoupon($this);
  426.     }
  428.     /**
  429.      * Is coupon valid for product
  430.      *
  431.      * @param \XLite\Model\Product $product Product
  432.      *
  433.      * @return boolean
  434.      */
  435.     public function isValidForProduct(\XLite\Model\Product $product)
  436.     {
  437.         $result = true;
  439.         if (0 < count($this->getProductClasses())) {
  440.             // Check product class
  441.             $result = $product->getProductClass()
  442.                 && $this->getProductClasses()->contains($product->getProductClass());
  443.         }
  445.         if ($result && 0 < count($this->getCategories())) {
  446.             // Check categories
  447.             $result = false;
  448.             foreach ($product->getCategories() as $category) {
  449.                 if ($this->getCategories()->contains($category)) {
  450.                     $result = true;
  451.                     break;
  452.                 }
  453.             }
  454.         }
  456.         if ($result && $this->getSpecificProducts()) {
  457.             // Check product
  458.             $result = in_array($product->getProductId(), $this->getApplicableProductIds());
  459.         }
  461.         return $result;
  462.     }
  464.     // }}}
  466.     /**
  467.      * Check coupon compatibility
  468.      *
  469.      * @param \XLite\Model\Order $order Order
  470.      *
  471.      * @throws \CDev\Coupons\Core\CompatibilityException
  472.      *
  473.      * @return boolean
  474.      */
  475.     public function checkCompatibility(\XLite\Model\Order $order = null)
  476.     {
  477.         if (!$this->getEnabled()) {
  478.             $this->throwCompatibilityException(
  479.                 '',
  480.                 'Sorry, the coupon you entered is invalid. Make sure the coupon code is spelled correctly'
  481.             );
  482.         }
  484.         $this->checkDate();
  485.         $this->checkUsage();
  487.         if ($order) {
  488.             if ($order->getProfile()) {
  489.                 $this->checkPerUserUsage($order->getProfile(), $order->containsCoupon($this));
  490.             }
  491.             $this->checkConflictsWithCoupons($order);
  492.             $this->checkMembership($order);
  493.             $this->checkCategory($order);
  494.             $this->checkProductClass($order);
  495.             $this->checkProducts($order);
  496.             $this->checkOrderTotal($order);
  497.             $this->checkZone($order);
  498.         }
  500.         return true;
  501.     }
  503.     // {{{ Date
  505.     /**
  506.      * Check coupon dates
  507.      *
  508.      * @throws \CDev\Coupons\Core\CompatibilityException
  509.      *
  510.      * @return void
  511.      */
  512.     protected function checkDate()
  513.     {
  514.         if (!$this->isStarted()) {
  515.             $this->throwCompatibilityException(
  516.                 '',
  517.                 'Sorry, the coupon you entered is invalid. Make sure the coupon code is spelled correctly'
  518.             );
  519.         }
  520.         if ($this->isExpired()) {
  521.             $this->throwCompatibilityException(
  522.                 '',
  523.                 'Sorry, the coupon has expired'
  524.             );
  525.         }
  526.     }
  528.     // }}}
  530.     // {{{ Usage
  532.     /**
  533.      * Check coupon usages
  534.      *
  535.      * @throws \CDev\Coupons\Core\CompatibilityException
  536.      *
  537.      * @return void
  538.      */
  539.     protected function checkUsage()
  540.     {
  541.         if (0 < $this->getUsesLimit() && $this->getUsesLimit() <= $this->getUses()) {
  542.             $this->throwCompatibilityException(
  543.                 '',
  544.                 'Sorry, the coupon use limit has been reached'
  545.             );
  546.         }
  547.     }
  549.     /**
  550.      * Check coupon usages per user
  551.      *
  552.      * @throws \CDev\Coupons\Core\CompatibilityException
  553.      *
  554.      * @return void
  555.      */
  556.     protected function checkPerUserUsage(\XLite\Model\Profile $profile, $inOrder)
  557.     {
  558.         if (0 >= $this->getUsesLimitPerUser()) {
  559.             return;
  560.         }
  562.         $profileUsesCount = null;
  564.         if (array_key_exists($profile->getLogin(), static::$runtimeCacheForUsedCouponsCount)) {
  565.             $profileUsesCount = static::$runtimeCacheForUsedCouponsCount[$profile->getLogin()];
  566.         } else {
  567.             $profileUsesCount = $this->calculatePerUserUsage($profile);
  569.             static::$runtimeCacheForUsedCouponsCount[$profile->getLogin()] = $profileUsesCount;
  570.         }
  572.         if ($inOrder) {
  573.             $profileUsesCount -= 1;
  574.         }
  576.         if ($this->getUsesLimitPerUser() <= $profileUsesCount) {
  577.             $this->throwCompatibilityException(
  578.                 '',
  579.                 'Sorry, the coupon use limit has been reached'
  580.             );
  581.         }
  582.     }
  584.     /**
  585.      * @param \XLite\Model\Profile $profile
  586.      *
  587.      * @return int
  588.      */
  589.     protected function calculatePerUserUsage(\XLite\Model\Profile $profile)
  590.     {
  591.         return $this->getUsedCoupons()->filter(
  592.             static function ($usedCoupon) use ($profile) {
  593.                 /** @var \CDev\Coupons\Model\UsedCoupon $usedCoupon */
  594.                 $orderProfileIdentificator = $usedCoupon->getOrder()->getProfile()
  595.                     ? $usedCoupon->getOrder()->getProfile()->getLogin()
  596.                     : null;
  598.                 $currentProfileIdentificator = $profile->getLogin();
  600.                 return $orderProfileIdentificator
  601.                     && $currentProfileIdentificator
  602.                     && $orderProfileIdentificator === $currentProfileIdentificator;
  603.             }
  604.         )->count();
  605.     }
  607.     // }}}
  609.     // {{{ Coupons conflicts
  611.     /**
  612.      * Check if coupon is unique within an order
  613.      *
  614.      * @param \XLite\Model\Order $order Order
  615.      *
  616.      * @throws \CDev\Coupons\Core\CompatibilityException
  617.      *
  618.      * @return boolean
  619.      */
  620.     public function checkUnique(\XLite\Model\Order $order)
  621.     {
  622.         if ($order->containsCoupon($this)) {
  623.             $this->throwCompatibilityException(
  624.                 '',
  625.                 'You have already used the coupon'
  626.             );
  627.         }
  629.         return true;
  630.     }
  632.     /**
  633.      * Check coupon usages
  634.      *
  635.      * @param \XLite\Model\Order $order Order
  636.      *
  637.      * @throws \CDev\Coupons\Core\CompatibilityException
  638.      *
  639.      * @return void
  640.      */
  641.     protected function checkConflictsWithCoupons(\XLite\Model\Order $order)
  642.     {
  643.         if (!$order->containsCoupon($this)) {
  644.             if ($this->getSingleUse() && count($this->getOrderUsedCoupons($order))) {
  645.                 $this->throwCompatibilityException(
  646.                     static::ERROR_SINGLE_USE,
  647.                     'This coupon cannot be combined with other coupons'
  648.                 );
  649.             }
  651.             if (!$this->getSingleUse() && $this->hasOrderSingleCoupon($order)) {
  652.                 $this->throwCompatibilityException(
  653.                     static::ERROR_SINGLE_USE2,
  654.                     'Sorry, this coupon cannot be combined with the coupon already applied. Revome the previously applied coupon and try again.'
  655.                 );
  656.             }
  657.         }
  658.     }
  660.     /**
  661.      * @param \XLite\Model\Order $order
  662.      *
  663.      * @return array
  664.      */
  665.     protected function getOrderUsedCoupons($order)
  666.     {
  667.         return $order->getUsedCoupons();
  668.     }
  670.     /**
  671.      * @param \XLite\Model\Order $order
  672.      *
  673.      * @return bool
  674.      */
  675.     protected function hasOrderSingleCoupon($order)
  676.     {
  677.         return $order->hasSingleUseCoupon();
  678.     }
  680.     // }}}
  682.     // {{{ Total
  684.     /**
  685.      * Check order total
  686.      *
  687.      * @param \XLite\Model\Order $order Order
  688.      *
  689.      * @throws \CDev\Coupons\Core\CompatibilityException
  690.      *
  691.      * @return void
  692.      */
  693.     protected function checkOrderTotal(\XLite\Model\Order $order)
  694.     {
  695.         $total = $this->getOrderTotal($order);
  696.         $currency = $order->getCurrency();
  698.         $rangeBegin = $this->getTotalRangeBegin();
  699.         $rangeEnd = $this->getTotalRangeEnd();
  701.         $betweenTotalCoupon = $rangeBegin > 0 && $rangeEnd > 0;
  702.         $rangeBeginValid = $rangeBegin === 0.0 || $rangeBegin <= $total;
  703.         $rangeEndValid = $rangeEnd === 0.0 || $rangeEnd >= $total;
  705.         $hasProductsConditions = $this->getSpecificProducts()
  706.             || count($this->getCategories()) > 0
  707.             || count($this->getProductClasses()) > 0;
  709.         if ($betweenTotalCoupon && (!$rangeBeginValid || !$rangeEndValid)) {
  710.             $text = $hasProductsConditions
  711.                 ? $this->getBetweenSubtotalConditionalExceptionText()
  712.                 : $this->getBetweenSubtotalExceptionText();
  713.             $this->throwCompatibilityException(
  714.                 static::ERROR_TOTAL,
  715.                 $text,
  716.                 [
  717.                     'min' => implode('', $currency->formatParts($rangeBegin)),
  718.                     'max' => implode('', $currency->formatParts($rangeEnd)),
  719.                 ]
  720.             );
  721.         } elseif (!$rangeBeginValid) {
  722.             $text = $hasProductsConditions
  723.                 ? $this->getLeastSubtotalConditionalExceptionText()
  724.                 : $this->getLeastSubtotalExceptionText();
  725.             $this->throwCompatibilityException(
  726.                 static::ERROR_TOTAL,
  727.                 $text,
  728.                 [
  729.                     'min' => implode('', $currency->formatParts($rangeBegin))
  730.                 ]
  731.             );
  732.         } elseif (!$rangeEndValid) {
  733.             $text = $hasProductsConditions
  734.                 ? $this->getExceedSubtotalConditionalExceptionText()
  735.                 : $this->getExceedSubtotalExceptionText();
  736.             $this->throwCompatibilityException(
  737.                 static::ERROR_TOTAL,
  738.                 $text,
  739.                 [
  740.                     'max' => implode('', $currency->formatParts($rangeEnd))
  741.                 ]
  742.             );
  743.         }
  744.     }
  746.     /**
  747.      * Return text of exception
  748.      *
  749.      * @return void
  750.      */
  751.     protected function getBetweenSubtotalExceptionText()
  752.     {
  753.         return 'To use the coupon, your order subtotal must be between X and Y';
  754.     }
  756.     /**
  757.      * Return text of exception
  758.      *
  759.      * @return void
  760.      */
  761.     protected function getLeastSubtotalExceptionText()
  762.     {
  763.         return 'To use the coupon, your order subtotal must be at least X';
  764.     }
  766.     /**
  767.      * Return text of exception
  768.      *
  769.      * @return void
  770.      */
  771.     protected function getExceedSubtotalExceptionText()
  772.     {
  773.         return 'To use the coupon, your order subtotal must not exceed Y';
  774.     }
  776.     /**
  777.      * Return text of exception
  778.      *
  779.      * @return void
  780.      */
  781.     protected function getBetweenSubtotalConditionalExceptionText()
  782.     {
  783.         return 'To use the coupon, your order subtotal must be between X and Y for specific products';
  784.     }
  786.     /**
  787.      * Return text of exception
  788.      *
  789.      * @return void
  790.      */
  791.     protected function getLeastSubtotalConditionalExceptionText()
  792.     {
  793.         return 'To use the coupon, your order subtotal must be at least X for specific products';
  794.     }
  796.     /**
  797.      * Return text of exception
  798.      *
  799.      * @return void
  800.      */
  801.     protected function getExceedSubtotalConditionalExceptionText()
  802.     {
  803.         return 'To use the coupon, your order subtotal must not exceed Y for specific products';
  804.     }
  806.     // }}}
  808.     // {{{ Category
  810.     /**
  811.      * Check coupon category
  812.      *
  813.      * @param \XLite\Model\Order $order Order
  814.      *
  815.      * @throws \CDev\Coupons\Core\CompatibilityException
  816.      *
  817.      * @return void
  818.      */
  819.     protected function checkCategory(\XLite\Model\Order $order)
  820.     {
  821.         if ($this->getCategories()->count()) {
  822.             $found = false;
  824.             foreach ($order->getItems() as $item) {
  825.                 foreach ($item->getProduct()->getCategories() as $category) {
  826.                     if ($this->getCategories()->contains($category)) {
  827.                         $found = true;
  829.                         break;
  830.                     }
  831.                 }
  833.                 if ($found) {
  834.                     break;
  835.                 }
  836.             }
  838.             if (!$found) {
  839.                 $this->throwCompatibilityException(
  840.                     '',
  841.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  842.                 );
  843.             }
  844.         }
  845.     }
  847.     // }}}
  849.     // {{{ Products
  851.     /**
  852.      * Check coupon products
  853.      *
  854.      * @param \XLite\Model\Order $order Order
  855.      *
  856.      * @throws \CDev\Coupons\Core\CompatibilityException
  857.      *
  858.      * @return void
  859.      */
  860.     protected function checkProducts(\XLite\Model\Order $order)
  861.     {
  862.         if ($this->getSpecificProducts()) {
  863.             $applicableProductIds = $this->getApplicableProductIds();
  865.             $found = false;
  867.             foreach ($order->getItems() as $item) {
  868.                 if (in_array($item->getProduct()->getProductId(), $applicableProductIds)) {
  869.                     $found = true;
  870.                     break;
  871.                 }
  872.             }
  874.             if (!$found) {
  875.                 $this->throwCompatibilityException(
  876.                     '',
  877.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  878.                 );
  879.             }
  880.         }
  881.     }
  883.     // }}}
  885.     // {{{ Membership
  887.     /**
  888.      * Check coupon membership
  889.      *
  890.      * @param \XLite\Model\Order $order Order
  891.      *
  892.      * @throws \CDev\Coupons\Core\CompatibilityException
  893.      *
  894.      * @return void
  895.      */
  896.     protected function checkMembership(\XLite\Model\Order $order)
  897.     {
  898.         if (
  899.             $this->getMemberships()->count()
  900.             && (!$order->getProfile()
  901.                 || !$this->getMemberships()->contains($order->getProfile()->getMembership())
  902.             )
  903.         ) {
  904.             $this->throwCompatibilityException(
  905.                 '',
  906.                 'Sorry, the coupon you entered is not valid for your membership level. Contact the administrator'
  907.             );
  908.         }
  909.     }
  911.     // }}}
  913.     // {{{ Zone
  915.     /**
  916.      * Check coupon zone
  917.      *
  918.      * @param \XLite\Model\Order $order Order
  919.      *
  920.      * @throws \CDev\Coupons\Core\CompatibilityException
  921.      *
  922.      * @return void
  923.      */
  924.     protected function checkZone(\XLite\Model\Order $order)
  925.     {
  926.         $profile = $order->getProfile();
  927.         $shippingAddress = $profile ? $profile->getShippingAddress() : null;
  929.         if (!$shippingAddress) {
  930.             $shippingAddress = \XLite\Model\Address::createDefaultShippingAddress();
  931.         }
  933.         if ($shippingAddress && !$this->getZones()->isEmpty()) {
  934.             $applicableZones = \XLite\Core\Database::getRepo('XLite\Model\Zone')->findApplicableZones($shippingAddress->toArray());
  935.             $couponZoneIds = array_map(static function ($zone) {
  936.                 return $zone->getZoneId();
  937.             }, $this->getZones()->toArray());
  939.             $isApplicable = false;
  940.             foreach ($applicableZones as $zone) {
  941.                 if (in_array($zone->getZoneId(), $couponZoneIds)) {
  942.                     $isApplicable = true;
  943.                     break;
  944.                 }
  945.             }
  947.             if (!$isApplicable) {
  948.                 $this->throwCompatibilityException(
  949.                     '',
  950.                     'Sorry, the coupon you entered cannot be applied to this delivery address'
  951.                 );
  952.             }
  953.         }
  954.     }
  956.     // }}}
  958.     // {{{ Product class
  960.     /**
  961.      * Check coupon product class
  962.      *
  963.      * @param \XLite\Model\Order $order Order
  964.      *
  965.      * @throws \CDev\Coupons\Core\CompatibilityException
  966.      *
  967.      * @return void
  968.      */
  969.     protected function checkProductClass(\XLite\Model\Order $order)
  970.     {
  971.         if ($this->getProductClasses()->count()) {
  972.             $found = false;
  973.             foreach ($order->getItems() as $item) {
  974.                 if (
  975.                     $item->getProduct()->getProductClass()
  976.                     && $this->getProductClasses()->contains($item->getProduct()->getProductClass())
  977.                 ) {
  978.                     $found = true;
  980.                     break;
  981.                 }
  982.             }
  984.             if (!$found) {
  985.                 $this->throwCompatibilityException(
  986.                     '',
  987.                     'Sorry, the coupon you entered cannot be applied to the items in your cart'
  988.                 );
  989.             }
  990.         }
  991.     }
  993.     // }}}
  995.     /**
  996.      * Throws exception
  997.      *
  998.      * @param string $code    Message params
  999.      * @param string $message Message text
  1000.      * @param array  $params  Message params
  1001.      *
  1002.      * @throws \CDev\Coupons\Core\CompatibilityException
  1003.      *
  1004.      * @return void
  1005.      */
  1006.     protected function throwCompatibilityException($code = '', $message = null, array $params = [])
  1007.     {
  1008.         throw new \CDev\Coupons\Core\CompatibilityException($message, $params, $this, $code);
  1009.     }
  1011.     /**
  1012.      * Get id
  1013.      *
  1014.      * @return integer
  1015.      */
  1016.     public function getId()
  1017.     {
  1018.         return $this->id;
  1019.     }
  1021.     /**
  1022.      * Set code
  1023.      *
  1024.      * @param string $code
  1025.      * @return Coupon
  1026.      */
  1027.     public function setCode($code)
  1028.     {
  1029.         $this->code = $code;
  1030.         return $this;
  1031.     }
  1033.     /**
  1034.      * Get code
  1035.      *
  1036.      * @return string
  1037.      */
  1038.     public function getCode()
  1039.     {
  1040.         return $this->code;
  1041.     }
  1043.     /**
  1044.      * Set enabled
  1045.      *
  1046.      * @param boolean $enabled
  1047.      * @return Coupon
  1048.      */
  1049.     public function setEnabled($enabled)
  1050.     {
  1051.         $this->enabled = (bool)$enabled;
  1052.         return $this;
  1053.     }
  1055.     /**
  1056.      * Get enabled
  1057.      *
  1058.      * @return boolean
  1059.      */
  1060.     public function getEnabled()
  1061.     {
  1062.         return $this->enabled;
  1063.     }
  1065.     /**
  1066.      * Set value
  1067.      *
  1068.      * @param float $value
  1069.      * @return Coupon
  1070.      */
  1071.     public function setValue($value)
  1072.     {
  1073.         $this->value = $value;
  1074.         return $this;
  1075.     }
  1077.     /**
  1078.      * Get value
  1079.      *
  1080.      * @return float
  1081.      */
  1082.     public function getValue()
  1083.     {
  1084.         return $this->value;
  1085.     }
  1087.     /**
  1088.      * Set type
  1089.      *
  1090.      * @param string $type
  1091.      * @return Coupon
  1092.      */
  1093.     public function setType($type)
  1094.     {
  1095.         $this->type = $type;
  1096.         return $this;
  1097.     }
  1099.     /**
  1100.      * Get type
  1101.      *
  1102.      * @return string
  1103.      */
  1104.     public function getType()
  1105.     {
  1106.         return $this->type;
  1107.     }
  1109.     /**
  1110.      * Set comment
  1111.      *
  1112.      * @param string $comment
  1113.      * @return Coupon
  1114.      */
  1115.     public function setComment($comment)
  1116.     {
  1117.         $this->comment = $comment;
  1118.         return $this;
  1119.     }
  1121.     /**
  1122.      * Get comment
  1123.      *
  1124.      * @return string
  1125.      */
  1126.     public function getComment()
  1127.     {
  1128.         return $this->comment;
  1129.     }
  1131.     /**
  1132.      * Set uses
  1133.      *
  1134.      * @param integer $uses
  1135.      * @return Coupon
  1136.      */
  1137.     public function setUses($uses)
  1138.     {
  1139.         $this->uses = $uses;
  1140.         return $this;
  1141.     }
  1143.     /**
  1144.      * Get uses
  1145.      *
  1146.      * @return integer
  1147.      */
  1148.     public function getUses()
  1149.     {
  1150.         return $this->uses;
  1151.     }
  1153.     /**
  1154.      * Set dateRangeBegin
  1155.      *
  1156.      * @param integer $dateRangeBegin
  1157.      * @return Coupon
  1158.      */
  1159.     public function setDateRangeBegin($dateRangeBegin)
  1160.     {
  1161.         $this->dateRangeBegin = $dateRangeBegin;
  1162.         return $this;
  1163.     }
  1165.     /**
  1166.      * Get dateRangeBegin
  1167.      *
  1168.      * @return integer
  1169.      */
  1170.     public function getDateRangeBegin()
  1171.     {
  1172.         return $this->dateRangeBegin;
  1173.     }
  1175.     /**
  1176.      * Set dateRangeEnd
  1177.      *
  1178.      * @param integer $dateRangeEnd
  1179.      * @return Coupon
  1180.      */
  1181.     public function setDateRangeEnd($dateRangeEnd)
  1182.     {
  1183.         $this->dateRangeEnd = $dateRangeEnd;
  1184.         return $this;
  1185.     }
  1187.     /**
  1188.      * Get dateRangeEnd
  1189.      *
  1190.      * @return integer
  1191.      */
  1192.     public function getDateRangeEnd()
  1193.     {
  1194.         return $this->dateRangeEnd;
  1195.     }
  1197.     /**
  1198.      * Set totalRangeBegin
  1199.      *
  1200.      * @param float $totalRangeBegin
  1201.      * @return Coupon
  1202.      */
  1203.     public function setTotalRangeBegin($totalRangeBegin)
  1204.     {
  1205.         $this->totalRangeBegin = $totalRangeBegin;
  1206.         return $this;
  1207.     }
  1209.     /**
  1210.      * Get totalRangeBegin
  1211.      *
  1212.      * @return float
  1213.      */
  1214.     public function getTotalRangeBegin()
  1215.     {
  1216.         return $this->totalRangeBegin;
  1217.     }
  1219.     /**
  1220.      * Set totalRangeEnd
  1221.      *
  1222.      * @param float $totalRangeEnd
  1223.      * @return Coupon
  1224.      */
  1225.     public function setTotalRangeEnd($totalRangeEnd)
  1226.     {
  1227.         $this->totalRangeEnd = $totalRangeEnd;
  1228.         return $this;
  1229.     }
  1231.     /**
  1232.      * Get totalRangeEnd
  1233.      *
  1234.      * @return float
  1235.      */
  1236.     public function getTotalRangeEnd()
  1237.     {
  1238.         return $this->totalRangeEnd;
  1239.     }
  1241.     /**
  1242.      * Set usesLimit
  1243.      *
  1244.      * @param integer $usesLimit
  1245.      * @return Coupon
  1246.      */
  1247.     public function setUsesLimit($usesLimit)
  1248.     {
  1249.         $this->usesLimit = $usesLimit;
  1250.         return $this;
  1251.     }
  1253.     /**
  1254.      * Get usesLimit
  1255.      *
  1256.      * @return integer
  1257.      */
  1258.     public function getUsesLimit()
  1259.     {
  1260.         return $this->usesLimit;
  1261.     }
  1263.     /**
  1264.      * Set usesLimitPerUser
  1265.      *
  1266.      * @param integer $usesLimitPerUser
  1267.      * @return Coupon
  1268.      */
  1269.     public function setUsesLimitPerUser($usesLimitPerUser)
  1270.     {
  1271.         $this->usesLimitPerUser = $usesLimitPerUser;
  1272.         return $this;
  1273.     }
  1275.     /**
  1276.      * Get usesLimitPerUser
  1277.      *
  1278.      * @return integer
  1279.      */
  1280.     public function getUsesLimitPerUser()
  1281.     {
  1282.         return $this->usesLimitPerUser;
  1283.     }
  1285.     /**
  1286.      * Set singleUse
  1287.      *
  1288.      * @param boolean $singleUse
  1289.      * @return Coupon
  1290.      */
  1291.     public function setSingleUse($singleUse)
  1292.     {
  1293.         $this->singleUse = $singleUse;
  1294.         return $this;
  1295.     }
  1297.     /**
  1298.      * Get singleUse
  1299.      *
  1300.      * @return boolean
  1301.      */
  1302.     public function getSingleUse()
  1303.     {
  1304.         return $this->singleUse;
  1305.     }
  1307.     /**
  1308.      * Set specificProducts
  1309.      *
  1310.      * @param boolean $specificProducts
  1311.      * @return Coupon
  1312.      */
  1313.     public function setSpecificProducts($specificProducts)
  1314.     {
  1315.         $this->specificProducts = $specificProducts;
  1316.         return $this;
  1317.     }
  1319.     /**
  1320.      * Get specificProducts
  1321.      *
  1322.      * @return boolean
  1323.      */
  1324.     public function getSpecificProducts()
  1325.     {
  1326.         return $this->specificProducts;
  1327.     }
  1329.     /**
  1330.      * Add productClasses
  1331.      *
  1332.      * @param \XLite\Model\ProductClass $productClasses
  1333.      * @return Coupon
  1334.      */
  1335.     public function addProductClasses(\XLite\Model\ProductClass $productClasses)
  1336.     {
  1337.         $this->productClasses[] = $productClasses;
  1338.         return $this;
  1339.     }
  1341.     /**
  1342.      * Get productClasses
  1343.      *
  1344.      * @return \Doctrine\Common\Collections\Collection
  1345.      */
  1346.     public function getProductClasses()
  1347.     {
  1348.         return $this->productClasses;
  1349.     }
  1351.     /**
  1352.      * Clear product classes
  1353.      */
  1354.     public function clearProductClasses()
  1355.     {
  1356.         foreach ($this->getProductClasses()->getKeys() as $key) {
  1357.             $this->getProductClasses()->remove($key);
  1358.         }
  1359.     }
  1361.     /**
  1362.      * Add memberships
  1363.      *
  1364.      * @param \XLite\Model\Membership $memberships
  1365.      * @return Coupon
  1366.      */
  1367.     public function addMemberships(\XLite\Model\Membership $memberships)
  1368.     {
  1369.         $this->memberships[] = $memberships;
  1370.         return $this;
  1371.     }
  1373.     /**
  1374.      * Get memberships
  1375.      *
  1376.      * @return \Doctrine\Common\Collections\Collection
  1377.      */
  1378.     public function getMemberships()
  1379.     {
  1380.         return $this->memberships;
  1381.     }
  1383.     /**
  1384.      * Add coupon products
  1385.      *
  1386.      * @param \CDev\Coupons\Model\CouponProduct $couponProduct
  1387.      * @return Coupon
  1388.      */
  1389.     public function addCouponProducts(\CDev\Coupons\Model\CouponProduct $couponProduct)
  1390.     {
  1391.         $this->couponProducts[] = $couponProduct;
  1392.         return $this;
  1393.     }
  1395.     /**
  1396.      * Get product ids if coupon is specificProducts
  1397.      *
  1398.      * @return array
  1399.      */
  1400.     public function getApplicableProductIds()
  1401.     {
  1402.         $ids = [];
  1403.         if ($this->isPersistent() && $this->getSpecificProducts()) {
  1404.             $ids = \XLite\Core\Database::getRepo('CDev\Coupons\Model\CouponProduct')
  1405.                 ->getCouponProductIds($this->getId());
  1406.         }
  1408.         return $ids;
  1409.     }
  1411.     /**
  1412.      * Get coupon products
  1413.      *
  1414.      * @return \Doctrine\Common\Collections\Collection
  1415.      */
  1416.     public function getCouponProducts()
  1417.     {
  1418.         return $this->couponProducts;
  1419.     }
  1421.     /**
  1422.      * Clear memberships
  1423.      */
  1424.     public function clearMemberships()
  1425.     {
  1426.         foreach ($this->getMemberships()->getKeys() as $key) {
  1427.             $this->getMemberships()->remove($key);
  1428.         }
  1429.     }
  1431.     /**
  1432.      * Add zones
  1433.      *
  1434.      * @param \XLite\Model\Zone $zone
  1435.      * @return Coupon
  1436.      */
  1437.     public function addZones(\XLite\Model\Zone $zone)
  1438.     {
  1439.         $this->zones[] = $zone;
  1440.         return $this;
  1441.     }
  1443.     /**
  1444.      * Get zones
  1445.      *
  1446.      * @return \Doctrine\Common\Collections\ArrayCollection
  1447.      */
  1448.     public function getZones()
  1449.     {
  1450.         return $this->zones;
  1451.     }
  1453.     /**
  1454.      * Clear zones
  1455.      */
  1456.     public function clearZones()
  1457.     {
  1458.         foreach ($this->getZones()->getKeys() as $key) {
  1459.             $this->getZones()->remove($key);
  1460.         }
  1461.     }
  1463.     /**
  1464.      * Add usedCoupons
  1465.      *
  1466.      * @param \CDev\Coupons\Model\UsedCoupon $usedCoupons
  1467.      * @return Coupon
  1468.      */
  1469.     public function addUsedCoupons(\CDev\Coupons\Model\UsedCoupon $usedCoupons)
  1470.     {
  1471.         $this->usedCoupons[] = $usedCoupons;
  1472.         return $this;
  1473.     }
  1475.     /**
  1476.      * Get usedCoupons
  1477.      *
  1478.      * @return \Doctrine\Common\Collections\Collection|\CDev\Coupons\Model\UsedCoupon[]
  1479.      */
  1480.     public function getUsedCoupons()
  1481.     {
  1482.         return $this->usedCoupons;
  1483.     }
  1485.     /**
  1486.      * Add categories
  1487.      *
  1488.      * @param \XLite\Model\Category $categories
  1489.      * @return Coupon
  1490.      */
  1491.     public function addCategories(\XLite\Model\Category $categories)
  1492.     {
  1493.         $this->getCategories()->add($categories);
  1494.         return $this;
  1495.     }
  1497.     /**
  1498.      * Get categories
  1499.      *
  1500.      * @return \Doctrine\Common\Collections\Collection
  1501.      */
  1502.     public function getCategories()
  1503.     {
  1504.         return $this->categories;
  1505.     }
  1507.     /**
  1508.      * Clear categories
  1509.      */
  1510.     public function clearCategories()
  1511.     {
  1512.         foreach ($this->getCategories()->getKeys() as $key) {
  1513.             $this->getCategories()->remove($key);
  1514.         }
  1515.     }
  1516. }