core/lib/Thelia/Action/Coupon.php line 98

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\Action;
  15. use Propel\Runtime\Propel;
  16. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Symfony\Component\HttpFoundation\RequestStack;
  19. use Symfony\Contracts\EventDispatcher\Event;
  20. use Thelia\Condition\ConditionCollection;
  21. use Thelia\Condition\ConditionFactory;
  22. use Thelia\Condition\Implementation\ConditionInterface;
  23. use Thelia\Condition\Implementation\MatchForEveryone;
  24. use Thelia\Core\Event\Coupon\CouponConsumeEvent;
  25. use Thelia\Core\Event\Coupon\CouponCreateOrUpdateEvent;
  26. use Thelia\Core\Event\Coupon\CouponDeleteEvent;
  27. use Thelia\Core\Event\Order\OrderEvent;
  28. use Thelia\Core\Event\TheliaEvents;
  29. use Thelia\Coupon\CouponFactory;
  30. use Thelia\Coupon\CouponManager;
  31. use Thelia\Coupon\Type\CouponInterface;
  32. use Thelia\Model\Coupon as CouponModel;
  33. use Thelia\Model\CouponCountry;
  34. use Thelia\Model\CouponCountryQuery;
  35. use Thelia\Model\CouponModule;
  36. use Thelia\Model\CouponModuleQuery;
  37. use Thelia\Model\CouponQuery;
  38. use Thelia\Model\Event\AddressEvent;
  39. use Thelia\Model\Map\OrderCouponTableMap;
  40. use Thelia\Model\OrderCoupon;
  41. use Thelia\Model\OrderCouponCountry;
  42. use Thelia\Model\OrderCouponModule;
  43. use Thelia\Model\OrderCouponQuery;
  45. /**
  46.  * Process Coupon Events.
  47.  *
  48.  * @author  Guillaume MOREL <gmorel@openstudio.fr>, Franck Allimant <franck@cqfdev.fr>
  49.  */
  50. class Coupon extends BaseAction implements EventSubscriberInterface
  51. {
  52.     /** @var RequestStack */
  53.     protected $requestStack;
  55.     /** @var CouponFactory */
  56.     protected $couponFactory;
  58.     /** @var CouponManager */
  59.     protected $couponManager;
  61.     /** @var ConditionInterface */
  62.     protected $noConditionRule;
  64.     /** @var ConditionFactory */
  65.     protected $conditionFactory;
  67.     public function __construct(
  68.         RequestStack $requestStack,
  69.         CouponFactory $couponFactory,
  70.         CouponManager $couponManager,
  71.         MatchForEveryone $noConditionRule,
  72.         ConditionFactory $conditionFactory
  73.     ) {
  74.         $this->requestStack = $requestStack;
  75.         $this->couponFactory = $couponFactory;
  76.         $this->couponManager = $couponManager;
  77.         $this->noConditionRule = $noConditionRule;
  78.         $this->conditionFactory = $conditionFactory;
  79.     }
  81.     /**
  82.      * Occurring when a Coupon is about to be created.
  83.      *
  84.      * @param CouponCreateOrUpdateEvent $event Event creation or update Coupon
  85.      */
  86.     public function create(CouponCreateOrUpdateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  87.     {
  88.         $coupon = new CouponModel();
  90.         $this->createOrUpdate($coupon, $event, $dispatcher);
  91.     }
  93.     /**
  94.      * Occurring when a Coupon is about to be updated.
  95.      *
  96.      * @param CouponCreateOrUpdateEvent $event Event creation or update Coupon
  97.      */
  98.     public function update(CouponCreateOrUpdateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  99.     {
  100.         $coupon = $event->getCouponModel();
  102.         $this->createOrUpdate($coupon, $event, $dispatcher);
  103.     }
  105.     public function delete(CouponDeleteEvent $event): void
  106.     {
  107.         $coupon = $event->getCoupon();
  109.         if (null === $coupon) {
  110.             throw new \InvalidArgumentException(
  111.                 'The coupon should not be null'
  112.             );
  113.         }
  115.         $coupon->delete();
  117.         $event->setCoupon(null);
  118.     }
  120.     /**
  121.      * Occurring when a Coupon condition is about to be updated.
  122.      *
  123.      * @param CouponCreateOrUpdateEvent $event Event creation or update Coupon condition
  124.      */
  125.     public function updateCondition(CouponCreateOrUpdateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  126.     {
  127.         $modelCoupon = $event->getCouponModel();
  129.         $this->createOrUpdateCondition($modelCoupon, $event, $dispatcher);
  130.     }
  132.     /**
  133.      * Clear all coupons in session.
  134.      */
  135.     public function clearAllCoupons(Event $event, $eventName, EventDispatcherInterface $dispatcher): void
  136.     {
  137.         // Tell coupons to clear any data they may have stored
  138.         $this->couponManager->clear();
  140.         $this->getSession()->setConsumedCoupons([]);
  142.         $this->updateOrderDiscount($event, $eventName, $dispatcher);
  143.     }
  145.     /**
  146.      * Occurring when a Coupon condition is about to be consumed.
  147.      *
  148.      * @param CouponConsumeEvent $event Event consuming Coupon
  149.      */
  150.     public function consume(CouponConsumeEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  151.     {
  152.         $totalDiscount = 0;
  153.         $isValid = false;
  155.         /** @var CouponInterface $coupon */
  156.         $coupon = $this->couponFactory->buildCouponFromCode($event->getCode());
  158.         if ($coupon) {
  159.             $isValid = $coupon->isMatching();
  161.             if ($isValid) {
  162.                 $this->couponManager->pushCouponInSession($event->getCode());
  163.                 $totalDiscount = $this->couponManager->getDiscount();
  165.                 $this->getSession()
  166.                     ->getSessionCart($dispatcher)
  167.                     ->setDiscount($totalDiscount)
  168.                     ->save();
  170.                 $this->getSession()
  171.                     ->getOrder()
  172.                     ->setDiscount($totalDiscount)
  173.                 ;
  174.             }
  175.         }
  177.         $event->setIsValid($isValid);
  178.         $event->setDiscount($totalDiscount);
  179.     }
  181.     public function updateOrderDiscount(Event $event, $eventName, EventDispatcherInterface $dispatcher): void
  182.     {
  183.         $discount = $this->couponManager->getDiscount();
  185.         $this->getSession()
  186.             ->getSessionCart($dispatcher)
  187.             ->setDiscount($discount)
  188.             ->save();
  190.         $this->getSession()
  191.             ->getOrder()
  192.             ->setDiscount($discount);
  193.     }
  195.     /**
  196.      * Call the Model and delegate the create or delete action
  197.      * Feed the Event with the updated model.
  198.      *
  199.      * @param CouponModel               $coupon Model to save
  200.      * @param CouponCreateOrUpdateEvent $event  Event containing data
  201.      */
  202.     protected function createOrUpdate(CouponModel $coupon, CouponCreateOrUpdateEvent $event, EventDispatcherInterface $dispatcher): void
  203.     {
  204.         // Set default condition if none found
  205.         /** @var ConditionInterface $noConditionRule */
  206.         $noConditionRule = $this->noConditionRule;
  207.         /** @var ConditionFactory $conditionFactory */
  208.         $conditionFactory = $this->conditionFactory;
  209.         $couponRuleCollection = new ConditionCollection();
  210.         $couponRuleCollection[] = $noConditionRule;
  211.         $defaultSerializedRule = $conditionFactory->serializeConditionCollection(
  212.             $couponRuleCollection
  213.         );
  215.         $coupon->createOrUpdate(
  216.             $event->getCode(),
  217.             $event->getTitle(),
  218.             $event->getEffects(),
  219.             $event->getServiceId(),
  220.             $event->isRemovingPostage(),
  221.             $event->getShortDescription(),
  222.             $event->getDescription(),
  223.             $event->isEnabled(),
  224.             $event->getExpirationDate(),
  225.             $event->isAvailableOnSpecialOffers(),
  226.             $event->isCumulative(),
  227.             $event->getMaxUsage(),
  228.             $defaultSerializedRule,
  229.             $event->getLocale(),
  230.             $event->getFreeShippingForCountries(),
  231.             $event->getFreeShippingForMethods(),
  232.             $event->getPerCustomerUsageCount(),
  233.             $event->getStartDate()
  234.         );
  236.         $event->setCouponModel($coupon);
  237.     }
  239.     /**
  240.      * Call the Model and delegate the create or delete action
  241.      * Feed the Event with the updated model.
  242.      *
  243.      * @param CouponModel               $coupon Model to save
  244.      * @param CouponCreateOrUpdateEvent $event  Event containing data
  245.      */
  246.     protected function createOrUpdateCondition(CouponModel $coupon, CouponCreateOrUpdateEvent $event, EventDispatcherInterface $dispatcher): void
  247.     {
  248.         /** @var ConditionFactory $conditionFactory */
  249.         $conditionFactory = $this->conditionFactory;
  251.         $coupon->createOrUpdateConditions(
  252.             $conditionFactory->serializeConditionCollection($event->getConditions()),
  253.             $event->getLocale()
  254.         );
  256.         $event->setCouponModel($coupon);
  257.     }
  259.     public function testFreePostage(OrderEvent $event): void
  260.     {
  261.         $order = $event->getOrder();
  263.         if ($this->couponManager->isCouponRemovingPostage($order)) {
  264.             $order->setPostage(0);
  266.             $event->setOrder($order);
  268.             $event->stopPropagation();
  269.         }
  270.     }
  272.     /**
  273.      * @throws \Exception if something goes wrong
  274.      */
  275.     public function afterOrder(OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  276.     {
  277.         /** @var CouponInterface[] $consumedCoupons */
  278.         $consumedCoupons = $this->couponManager->getCouponsKept();
  280.         if (\is_array($consumedCoupons) && \count($consumedCoupons) > 0) {
  281.             $con = Propel::getWriteConnection(OrderCouponTableMap::DATABASE_NAME);
  282.             $con->beginTransaction();
  284.             try {
  285.                 foreach ($consumedCoupons as $couponCode) {
  286.                     $couponQuery = CouponQuery::create();
  287.                     $couponModel = $couponQuery->findOneByCode($couponCode->getCode());
  288.                     $couponModel->setLocale($this->getSession()->getLang()->getLocale());
  290.                     /* decrease coupon quantity */
  291.                     $this->couponManager->decrementQuantity($couponModel, $event->getOrder()->getCustomerId());
  293.                     /* memorize coupon */
  294.                     $orderCoupon = new OrderCoupon();
  295.                     $orderCoupon->setOrder($event->getOrder())
  296.                         ->setCode($couponModel->getCode())
  297.                         ->setType($couponModel->getType())
  298.                         ->setAmount($couponCode->exec())
  300.                         ->setTitle($couponModel->getTitle())
  301.                         ->setShortDescription($couponModel->getShortDescription())
  302.                         ->setDescription($couponModel->getDescription())
  304.                         ->setStartDate($couponModel->getStartDate())
  305.                         ->setExpirationDate($couponModel->getExpirationDate())
  306.                         ->setIsCumulative($couponModel->getIsCumulative())
  307.                         ->setIsRemovingPostage($couponModel->getIsRemovingPostage())
  308.                         ->setIsAvailableOnSpecialOffers($couponModel->getIsAvailableOnSpecialOffers())
  309.                         ->setSerializedConditions($couponModel->getSerializedConditions())
  310.                         ->setPerCustomerUsageCount($couponModel->getPerCustomerUsageCount())
  311.                     ;
  312.                     $orderCoupon->save();
  314.                     // Copy order coupon free shipping data for countries and modules
  315.                     $couponCountries = CouponCountryQuery::create()->filterByCouponId($couponModel->getId())->find();
  317.                     /** @var CouponCountry $couponCountry */
  318.                     foreach ($couponCountries as $couponCountry) {
  319.                         $occ = new OrderCouponCountry();
  321.                         $occ
  322.                             ->setCouponId($orderCoupon->getId())
  323.                             ->setCountryId($couponCountry->getCountryId())
  324.                             ->save();
  325.                     }
  327.                     $couponModules = CouponModuleQuery::create()->filterByCouponId($couponModel->getId())->find();
  329.                     /** @var CouponModule $couponModule */
  330.                     foreach ($couponModules as $couponModule) {
  331.                         $ocm = new OrderCouponModule();
  333.                         $ocm
  334.                             ->setCouponId($orderCoupon->getId())
  335.                             ->setModuleId($couponModule->getModuleId())
  336.                             ->save();
  337.                     }
  338.                 }
  340.                 $con->commit();
  341.             } catch (\Exception  $ex) {
  342.                 $con->rollBack();
  344.                 throw $ex;
  345.             }
  346.         }
  348.         // Clear all coupons.
  349.         $dispatcher->dispatch(new Event(), TheliaEvents::COUPON_CLEAR_ALL);
  350.     }
  352.     /**
  353.      * Cancels order coupons usage when order is canceled or refunded,
  354.      * or use canceled coupons again if the order is no longer canceled or refunded.
  355.      *
  356.      * @param string $eventName
  357.      *
  358.      * @throws \Exception
  359.      * @throws \Propel\Runtime\Exception\PropelException
  360.      */
  361.     public function orderStatusChange(OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  362.     {
  363.         // The order has been canceled or refunded ?
  364.         if ($event->getOrder()->isCancelled() || $event->getOrder()->isRefunded()) {
  365.             // Cancel usage of all coupons for this order
  366.             $usedCoupons = OrderCouponQuery::create()
  367.                 ->filterByUsageCanceled(false)
  368.                 ->findByOrderId($event->getOrder()->getId());
  370.             $customerId = $event->getOrder()->getCustomerId();
  372.             /** @var OrderCoupon $usedCoupon */
  373.             foreach ($usedCoupons as $usedCoupon) {
  374.                 if (null !== $couponModel = CouponQuery::create()->findOneByCode($usedCoupon->getCode())) {
  375.                     // If the coupon still exists, restore one usage to the usage count.
  376.                     $this->couponManager->incrementQuantity($couponModel, $customerId);
  377.                 }
  379.                 // Mark coupon usage as canceled in the OrderCoupon table
  380.                 $usedCoupon->setUsageCanceled(true)->save();
  381.             }
  382.         } else {
  383.             // Mark canceled coupons for this order as used again
  384.             $usedCoupons = OrderCouponQuery::create()
  385.                 ->filterByUsageCanceled(true)
  386.                 ->findByOrderId($event->getOrder()->getId());
  388.             $customerId = $event->getOrder()->getCustomerId();
  390.             /** @var OrderCoupon $usedCoupon */
  391.             foreach ($usedCoupons as $usedCoupon) {
  392.                 if (null !== $couponModel = CouponQuery::create()->findOneByCode($usedCoupon->getCode())) {
  393.                     // If the coupon still exists, mark the coupon as used
  394.                     $this->couponManager->decrementQuantity($couponModel, $customerId);
  395.                 }
  397.                 // The coupon is no longer canceled
  398.                 $usedCoupon->setUsageCanceled(false)->save();
  399.             }
  400.         }
  401.     }
  403.     /**
  404.      * {@inheritdoc}
  405.      */
  406.     public static function getSubscribedEvents()
  407.     {
  408.         return [
  409.             TheliaEvents::COUPON_CREATE => ['create', 128],
  410.             TheliaEvents::COUPON_UPDATE => ['update', 128],
  411.             TheliaEvents::COUPON_DELETE => ['delete', 128],
  412.             TheliaEvents::COUPON_CONSUME => ['consume', 128],
  413.             TheliaEvents::COUPON_CLEAR_ALL => ['clearAllCoupons', 128],
  414.             TheliaEvents::COUPON_CONDITION_UPDATE => ['updateCondition', 128],
  415.             TheliaEvents::ORDER_SET_POSTAGE => ['testFreePostage', 132],
  416.             TheliaEvents::ORDER_BEFORE_PAYMENT => ['afterOrder', 128],
  417.             TheliaEvents::ORDER_UPDATE_STATUS => ['orderStatusChange', 10],
  418.             TheliaEvents::CART_ADDITEM => ['updateOrderDiscount', 10],
  419.             TheliaEvents::CART_UPDATEITEM => ['updateOrderDiscount', 10],
  420.             TheliaEvents::CART_DELETEITEM => ['updateOrderDiscount', 10],
  421.             TheliaEvents::CUSTOMER_LOGIN => ['updateOrderDiscount', 10],
  422.             AddressEvent::POST_UPDATE => ['updateOrderDiscount', 10],
  423.         ];
  424.     }
  426.     /**
  427.      * Returns the session from the current request.
  428.      *
  429.      * @return \Thelia\Core\HttpFoundation\Session\Session
  430.      */
  431.     protected function getSession()
  432.     {
  433.         return $this->requestStack->getCurrentRequest()->getSession();
  434.     }
  435. }