core/lib/Thelia/Action/Order.php line 106

  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 Thelia\Core\Event\Order\GetStockUpdateOperationOnOrderStatusChangeEvent;
  20. use Thelia\Core\Event\Order\OrderAddressEvent;
  21. use Thelia\Core\Event\Order\OrderEvent;
  22. use Thelia\Core\Event\Order\OrderManualEvent;
  23. use Thelia\Core\Event\Order\OrderPaymentEvent;
  24. use Thelia\Core\Event\Order\OrderPayTotalEvent;
  25. use Thelia\Core\Event\Product\VirtualProductOrderHandleEvent;
  26. use Thelia\Core\Event\TheliaEvents;
  27. use Thelia\Core\HttpFoundation\Request;
  28. use Thelia\Core\Security\SecurityContext;
  29. use Thelia\Core\Security\User\UserInterface;
  30. use Thelia\Exception\TheliaProcessException;
  31. use Thelia\Log\Tlog;
  32. use Thelia\Mailer\MailerFactory;
  33. use Thelia\Model\AddressQuery;
  34. use Thelia\Model\Cart as CartModel;
  35. use Thelia\Model\ConfigQuery;
  36. use Thelia\Model\Currency as CurrencyModel;
  37. use Thelia\Model\Lang as LangModel;
  38. use Thelia\Model\Map\OrderTableMap;
  39. use Thelia\Model\ModuleQuery;
  40. use Thelia\Model\Order as ModelOrder;
  41. use Thelia\Model\Order as OrderModel;
  42. use Thelia\Model\OrderAddress;
  43. use Thelia\Model\OrderAddressQuery;
  44. use Thelia\Model\OrderProduct;
  45. use Thelia\Model\OrderProductAttributeCombination;
  46. use Thelia\Model\OrderProductTax;
  47. use Thelia\Model\OrderStatusQuery;
  48. use Thelia\Model\OrderVersionQuery;
  49. use Thelia\Model\ProductI18n;
  50. use Thelia\Model\ProductSaleElements;
  51. use Thelia\Model\ProductSaleElementsQuery;
  52. use Thelia\Model\TaxRuleI18n;
  53. use Thelia\Tools\I18n;
  55. /**
  56.  * Class Order.
  57.  *
  58.  * @author Etienne Roudeix <eroudeix@openstudio.fr>
  59.  * @author Franck Allimant <thelia@cqfdev.fr>
  60.  */
  61. class Order extends BaseAction implements EventSubscriberInterface
  62. {
  63.     /** @var RequestStack */
  64.     protected $requestStack;
  66.     /** @var MailerFactory */
  67.     protected $mailer;
  69.     /** @var SecurityContext */
  70.     protected $securityContext;
  72.     public function __construct(RequestStack $requestStack, MailerFactory $mailer, SecurityContext $securityContext)
  73.     {
  74.         $this->requestStack = $requestStack;
  75.         $this->mailer = $mailer;
  76.         $this->securityContext = $securityContext;
  77.     }
  79.     public function setDeliveryAddress(OrderEvent $event): void
  80.     {
  81.         $order = $event->getOrder();
  83.         $order->setChoosenDeliveryAddress($event->getDeliveryAddress());
  85.         $event->setOrder($order);
  86.     }
  88.     public function setDeliveryModule(OrderEvent $event): void
  89.     {
  90.         $order = $event->getOrder();
  92.         $deliveryModuleId = $event->getDeliveryModule();
  94.         $order->setDeliveryModuleId($deliveryModuleId);
  96.         // Reset postage cost if the delivery module had been removed
  97.         if ($deliveryModuleId <= 0) {
  98.             $order->setPostage(0);
  99.             $order->setPostageTax(0);
  100.             $order->setPostageTaxRuleTitle(null);
  101.         }
  103.         $event->setOrder($order);
  104.     }
  106.     public function setPostage(OrderEvent $event): void
  107.     {
  108.         $order = $event->getOrder();
  110.         $order->setPostage($event->getPostage());
  111.         $order->setPostageTax($event->getPostageTax());
  112.         $order->setPostageTaxRuleTitle($event->getPostageTaxRuleTitle());
  114.         $event->setOrder($order);
  115.     }
  117.     public function setInvoiceAddress(OrderEvent $event): void
  118.     {
  119.         $order = $event->getOrder();
  121.         $order->setChoosenInvoiceAddress($event->getInvoiceAddress());
  123.         $event->setOrder($order);
  124.     }
  126.     public function setPaymentModule(OrderEvent $event): void
  127.     {
  128.         $order = $event->getOrder();
  130.         $order->setPaymentModuleId($event->getPaymentModule());
  132.         $event->setOrder($order);
  133.     }
  135.     /**
  136.      * @param bool $unusedArgument           deprecated argument. Will be removed in 2.5
  137.      * @param bool $useOrderDefinedAddresses if true, the delivery and invoice OrderAddresses will be used instead of creating new OrderAdresses using Order::getChoosenXXXAddress()
  138.      *
  139.      * @throws \Exception
  140.      * @throws \Propel\Runtime\Exception\PropelException
  141.      *
  142.      * @return ModelOrder
  143.      */
  144.     protected function createOrder(
  145.         EventDispatcherInterface $dispatcher,
  146.         ModelOrder $sessionOrder,
  147.         CurrencyModel $currency,
  148.         LangModel $lang,
  149.         CartModel $cart,
  150.         UserInterface $customer,
  151.         $unusedArgument = null,
  152.         $useOrderDefinedAddresses = false
  153.     ) {
  154.         $con = Propel::getConnection(
  155.             OrderTableMap::DATABASE_NAME
  156.         );
  158.         $con->beginTransaction();
  160.         $placedOrder = $sessionOrder->copy();
  162.         // Be sure to create a brand new order, as copy raises the modified flag for all fields
  163.         // and will also copy order reference and id.
  164.         $placedOrder->setId(null)->setRef(null)->setNew(true);
  166.         // Dates should be marked as not updated so that Propel will update them.
  167.         $placedOrder->resetModified(OrderTableMap::COL_CREATED_AT);
  168.         $placedOrder->resetModified(OrderTableMap::COL_UPDATED_AT);
  169.         $placedOrder->resetModified(OrderTableMap::COL_VERSION_CREATED_AT);
  171.         $cartItems = $cart->getCartItems();
  173.         /* fulfill order */
  174.         $placedOrder->setCustomerId($customer->getId());
  175.         $placedOrder->setCurrencyId($currency->getId());
  176.         $placedOrder->setCurrencyRate($currency->getRate());
  177.         $placedOrder->setLangId($lang->getId());
  179.         if ($useOrderDefinedAddresses) {
  180.             $taxCountry =
  181.                 OrderAddressQuery::create()
  182.                     ->findPk($placedOrder->getDeliveryOrderAddressId())
  183.                     ->getCountry()
  184.             ;
  185.         } else {
  186.             $deliveryAddress = AddressQuery::create()->findPk($sessionOrder->getChoosenDeliveryAddress());
  187.             $invoiceAddress = AddressQuery::create()->findPk($sessionOrder->getChoosenInvoiceAddress());
  189.             /* hard save the delivery and invoice addresses */
  190.             $deliveryOrderAddress = new OrderAddress();
  191.             $deliveryOrderAddress
  192.                 ->setCustomerTitleId($deliveryAddress->getTitleId())
  193.                 ->setCompany($deliveryAddress->getCompany())
  194.                 ->setFirstname($deliveryAddress->getFirstname())
  195.                 ->setLastname($deliveryAddress->getLastname())
  196.                 ->setAddress1($deliveryAddress->getAddress1())
  197.                 ->setAddress2($deliveryAddress->getAddress2())
  198.                 ->setAddress3($deliveryAddress->getAddress3())
  199.                 ->setZipcode($deliveryAddress->getZipcode())
  200.                 ->setCity($deliveryAddress->getCity())
  201.                 ->setPhone($deliveryAddress->getPhone())
  202.                 ->setCellphone($deliveryAddress->getCellphone())
  203.                 ->setCountryId($deliveryAddress->getCountryId())
  204.                 ->setStateId($deliveryAddress->getStateId())
  205.                 ->save($con);
  207.             $invoiceOrderAddress = new OrderAddress();
  208.             $invoiceOrderAddress
  209.                 ->setCustomerTitleId($invoiceAddress->getTitleId())
  210.                 ->setCompany($invoiceAddress->getCompany())
  211.                 ->setFirstname($invoiceAddress->getFirstname())
  212.                 ->setLastname($invoiceAddress->getLastname())
  213.                 ->setAddress1($invoiceAddress->getAddress1())
  214.                 ->setAddress2($invoiceAddress->getAddress2())
  215.                 ->setAddress3($invoiceAddress->getAddress3())
  216.                 ->setZipcode($invoiceAddress->getZipcode())
  217.                 ->setCity($invoiceAddress->getCity())
  218.                 ->setPhone($invoiceAddress->getPhone())
  219.                 ->setCellphone($invoiceAddress->getCellphone())
  220.                 ->setCountryId($invoiceAddress->getCountryId())
  221.                 ->setStateId($deliveryAddress->getStateId())
  222.                 ->save($con);
  224.             $placedOrder->setDeliveryOrderAddressId($deliveryOrderAddress->getId());
  225.             $placedOrder->setInvoiceOrderAddressId($invoiceOrderAddress->getId());
  227.             $taxCountry = $deliveryAddress->getCountry();
  228.         }
  230.         $placedOrder->setStatusId(
  231.             OrderStatusQuery::getNotPaidStatus()->getId()
  232.         );
  234.         $placedOrder->setCartId($cart->getId());
  236.         /* memorize discount */
  237.         $placedOrder->setDiscount(
  238.             $cart->getDiscount()
  239.         );
  241.         $placedOrder->save($con);
  243.         $manageStock = $placedOrder->isStockManagedOnOrderCreation($dispatcher);
  245.         /* fulfill order_products and decrease stock */
  247.         foreach ($cartItems as $cartItem) {
  248.             $product = $cartItem->getProduct();
  250.             /* get translation */
  251.             /** @var ProductI18n $productI18n */
  252.             $productI18n = I18n::forceI18nRetrieving($lang->getLocale(), 'Product', $product->getId());
  254.             $pse = $cartItem->getProductSaleElements();
  256.             // get the virtual document path
  257.             $virtualDocumentEvent = new VirtualProductOrderHandleEvent($placedOrder, $pse->getId());
  258.             // essentially used for virtual product. modules that handles virtual product can
  259.             // allow the use of stock even for virtual products
  260.             $useStock = true;
  261.             $virtual = 0;
  263.             // if the product is virtual, dispatch an event to collect information
  264.             if ($product->getVirtual() === 1) {
  265.                 $dispatcher->dispatch($virtualDocumentEvent, TheliaEvents::VIRTUAL_PRODUCT_ORDER_HANDLE);
  266.                 $useStock = $virtualDocumentEvent->isUseStock();
  267.                 $virtual = $virtualDocumentEvent->isVirtual() ? 1 : 0;
  268.             }
  270.             /* check still in stock */
  271.             if ($cartItem->getQuantity() > $pse->getQuantity()
  272.                 && true === ConfigQuery::checkAvailableStock()
  273.                 && $useStock) {
  274.                 throw new TheliaProcessException('Not enough stock', TheliaProcessException::CART_ITEM_NOT_ENOUGH_STOCK, $cartItem);
  275.             }
  277.             if ($useStock && $manageStock) {
  278.                 /* decrease stock for non virtual product */
  279.                 $allowNegativeStock = (int) ConfigQuery::read('allow_negative_stock', 0);
  280.                 $newStock = $pse->getQuantity() - $cartItem->getQuantity();
  281.                 // Forbid negative stock
  282.                 if ($newStock < 0 && 0 === $allowNegativeStock) {
  283.                     $newStock = 0;
  284.                 }
  285.                 $pse->setQuantity(
  286.                     $newStock
  287.                 );
  289.                 $pse->save($con);
  290.             }
  292.             /* get tax */
  293.             /** @var TaxRuleI18n $taxRuleI18n */
  294.             $taxRuleI18n = I18n::forceI18nRetrieving($lang->getLocale(), 'TaxRule', $product->getTaxRuleId());
  296.             $taxDetail = $product->getTaxRule()->getTaxDetail(
  297.                 $product,
  298.                 $taxCountry,
  299.                 $cartItem->getPrice(),
  300.                 $cartItem->getPromoPrice(),
  301.                 $lang->getLocale()
  302.             );
  304.             $orderProduct = new OrderProduct();
  305.             $orderProduct
  306.                 ->setOrderId($placedOrder->getId())
  307.                 ->setProductRef($product->getRef())
  308.                 ->setProductSaleElementsRef($pse->getRef())
  309.                 ->setProductSaleElementsId($pse->getId())
  310.                 ->setTitle($productI18n->getTitle())
  311.                 ->setChapo($productI18n->getChapo())
  312.                 ->setDescription($productI18n->getDescription())
  313.                 ->setPostscriptum($productI18n->getPostscriptum())
  314.                 ->setVirtual($virtual)
  315.                 ->setVirtualDocument($virtualDocumentEvent->getPath())
  316.                 ->setQuantity($cartItem->getQuantity())
  317.                 ->setPrice($cartItem->getPrice())
  318.                 ->setPromoPrice($cartItem->getPromoPrice())
  319.                 ->setWasNew($pse->getNewness())
  320.                 ->setWasInPromo($cartItem->getPromo())
  321.                 ->setWeight($pse->getWeight())
  322.                 ->setTaxRuleTitle($taxRuleI18n->getTitle())
  323.                 ->setTaxRuleDescription($taxRuleI18n->getDescription())
  324.                 ->setEanCode($pse->getEanCode())
  325.                 ->setCartItemId($cartItem->getId())
  327.                 ->save($con)
  328.             ;
  330.             /* fulfill order_product_tax */
  331.             /** @var OrderProductTax $tax */
  332.             foreach ($taxDetail as $tax) {
  333.                 $tax->setOrderProductId($orderProduct->getId());
  334.                 $tax->save($con);
  335.             }
  337.             /* fulfill order_attribute_combination and decrease stock */
  338.             foreach ($pse->getAttributeCombinations() as $attributeCombination) {
  339.                 /** @var \Thelia\Model\Attribute $attribute */
  340.                 $attribute = I18n::forceI18nRetrieving($lang->getLocale(), 'Attribute', $attributeCombination->getAttributeId());
  342.                 /** @var \Thelia\Model\AttributeAv $attributeAv */
  343.                 $attributeAv = I18n::forceI18nRetrieving($lang->getLocale(), 'AttributeAv', $attributeCombination->getAttributeAvId());
  345.                 $orderAttributeCombination = new OrderProductAttributeCombination();
  346.                 $orderAttributeCombination
  347.                     ->setOrderProductId($orderProduct->getId())
  348.                     ->setAttributeTitle($attribute->getTitle())
  349.                     ->setAttributeChapo($attribute->getChapo())
  350.                     ->setAttributeDescription($attribute->getDescription())
  351.                     ->setAttributePostscriptum($attribute->getPostscriptum())
  352.                     ->setAttributeAvTitle($attributeAv->getTitle())
  353.                     ->setAttributeAvChapo($attributeAv->getChapo())
  354.                     ->setAttributeAvDescription($attributeAv->getDescription())
  355.                     ->setAttributeAvPostscriptum($attributeAv->getPostscriptum())
  356.                     ->save($con);
  357.             }
  358.         }
  360.         $con->commit();
  362.         return $placedOrder;
  363.     }
  365.     /**
  366.      * Create an order outside of the front-office context, e.g. manually from the back-office.
  367.      *
  368.      * @throws \Exception
  369.      * @throws \Propel\Runtime\Exception\PropelException
  370.      */
  371.     public function createManual(OrderManualEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  372.     {
  373.         $event->setPlacedOrder(
  374.             $this->createOrder(
  375.                 $dispatcher,
  376.                 $event->getOrder(),
  377.                 $event->getCurrency(),
  378.                 $event->getLang(),
  379.                 $event->getCart(),
  380.                 $event->getCustomer(),
  381.                 null,
  382.                 $event->getUseOrderDefinedAddresses()
  383.             )
  384.         );
  386.         $event->setOrder(new OrderModel());
  387.     }
  389.     /**
  390.      * @throws \Thelia\Exception\TheliaProcessException
  391.      * @throws \Exception
  392.      * @throws \Propel\Runtime\Exception\PropelException
  393.      */
  394.     public function create(OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  395.     {
  396.         $session = $this->getSession();
  398.         $order = $event->getOrder();
  399.         $paymentModule = ModuleQuery::create()->findPk($order->getPaymentModuleId());
  401.         $placedOrder = $this->createOrder(
  402.             $dispatcher,
  403.             $event->getOrder(),
  404.             $session->getCurrency(),
  405.             $session->getLang(),
  406.             $session->getSessionCart($dispatcher),
  407.             $this->securityContext->getCustomerUser()
  408.         );
  410.         $dispatcher->dispatch(new OrderEvent($placedOrder), TheliaEvents::ORDER_BEFORE_PAYMENT);
  412.         /* but memorize placed order */
  413.         $event->setOrder(new OrderModel());
  414.         $event->setPlacedOrder($placedOrder);
  416.         /* call pay method */
  417.         $payEvent = new OrderPaymentEvent($placedOrder);
  419.         $dispatcher->dispatch($payEvent, TheliaEvents::MODULE_PAY);
  421.         if ($payEvent->hasResponse()) {
  422.             $event->setResponse($payEvent->getResponse());
  423.         }
  424.     }
  426.     public function orderBeforePayment(OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  427.     {
  428.         $dispatcher->dispatch(clone $event, TheliaEvents::ORDER_SEND_CONFIRMATION_EMAIL);
  430.         $dispatcher->dispatch(clone $event, TheliaEvents::ORDER_SEND_NOTIFICATION_EMAIL);
  431.     }
  433.     /**
  434.      * Clear the cart and the order in the customer session once the order is placed,
  435.      * and the payment performed.
  436.      */
  437.     public function orderCartClear(/* @noinspection PhpUnusedParameterInspection */ OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  438.     {
  439.         // Empty cart and clear current order
  440.         $session = $this->getSession();
  442.         $session->clearSessionCart($dispatcher);
  444.         $session->setOrder(new OrderModel());
  445.     }
  447.     /**
  448.      * @throws \Exception if the message cannot be loaded
  449.      */
  450.     public function sendConfirmationEmail(OrderEvent $event): void
  451.     {
  452.         $this->mailer->sendEmailToCustomer(
  453.             'order_confirmation',
  454.             $event->getOrder()->getCustomer(),
  455.             [
  456.                 'order_id' => $event->getOrder()->getId(),
  457.                 'order_ref' => $event->getOrder()->getRef(),
  458.             ]
  459.         );
  460.     }
  462.     /**
  463.      * @throws \Exception if the message cannot be loaded
  464.      */
  465.     public function sendNotificationEmail(OrderEvent $event): void
  466.     {
  467.         $this->mailer->sendEmailToShopManagers(
  468.             'order_notification',
  469.             [
  470.                 'order_id' => $event->getOrder()->getId(),
  471.                 'order_ref' => $event->getOrder()->getRef(),
  472.             ]
  473.         );
  474.     }
  476.     /**
  477.      * @throws \Exception
  478.      * @throws \Propel\Runtime\Exception\PropelException
  479.      */
  480.     public function updateStatus(OrderEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  481.     {
  482.         $order = $event->getOrder();
  483.         $newStatus = $event->getStatus();
  485.         $con = Propel::getConnection(OrderTableMap::DATABASE_NAME);
  487.         // Prevent partial stock update on status change.
  488.         $con->beginTransaction();
  490.         try {
  491.             $this->updateQuantity($order, $newStatus, $dispatcher);
  493.             $order->setStatusId($newStatus)->save();
  495.             $event->setOrder($order);
  497.             $con->commit();
  498.         } catch (\Exception $ex) {
  499.             $con->rollBack();
  501.             throw $ex;
  502.         }
  503.     }
  505.     /**
  506.      * Check if a stock update is required on order products for a given order status change, and compute if
  507.      * the stock should be decreased or increased.
  508.      *
  509.      * @throws \Propel\Runtime\Exception\PropelException
  510.      */
  511.     public function getStockUpdateOnOrderStatusChange(GetStockUpdateOperationOnOrderStatusChangeEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  512.     {
  513.         // The order
  514.         $order = $event->getOrder();
  516.         // The new order status
  517.         $newStatus = $event->getNewOrderStatus();
  519.         if ($newStatus->getId() !== $order->getStatusId()) {
  520.             // We have to change the stock in the following cases :
  521.             // 1) The order is currently paid, and will become unpaid (get products back in stock unconditionnaly)
  522.             // 2) The order is currently unpaid, and will become paid (remove products from stock, except if was done at order creation $manageStockOnCreation == false)
  523.             // 3) The order is currently NOT PAID, and will become canceled or the like (get products back in stock if it was done at order creation $manageStockOnCreation == true)
  525.             // We consider the ManageStockOnCreation flag only if the order status as not yet changed.
  526.             // Count distinct order statuses (e.g. NOT_PAID to something else) in the order version table.
  527.             if (OrderVersionQuery::create()->groupByStatusId()->filterById($order->getId())->count() > 1) {
  528.                 // A status change occured. Ignore $manageStockOnCreation
  529.                 $manageStockOnCreation = false;
  530.             } else {
  531.                 // A status has not yet occured. Consider the ManageStockOnCreation flag
  532.                 $manageStockOnCreation = $order->isStockManagedOnOrderCreation($dispatcher);
  533.             }
  535.             if (($order->isPaid(false) && $newStatus->isNotPaid(false)) // Case 1
  536.                 ||
  537.                 ($order->isNotPaid(true) && $newStatus->isNotPaid(false) && $manageStockOnCreation === true) // Case 3
  538.             ) {
  539.                 $event->setOperation($event::INCREASE_STOCK);
  540.             }
  542.             if ($order->isNotPaid(false) // Case 2
  543.                 &&
  544.                 $newStatus->isPaid(false)
  545.                 &&
  546.                 $manageStockOnCreation === false) {
  547.                 $event->setOperation($event::DECREASE_STOCK);
  548.             }
  550.             Tlog::getInstance()->addInfo(
  551.                 'Checking stock operation for status change of order : '.$order->getRef()
  552.                 .', version: '.$order->getVersion()
  553.                 .', manageStockOnCreation: '.($manageStockOnCreation ? 0 : 1)
  554.                 .', paid:'.($order->isPaid(false) ? 1 : 0)
  555.                 .', is not paid:'.($order->isNotPaid(false) ? 1 : 0)
  556.                 .', new status paid:'.($newStatus->isPaid(false) ? 1 : 0)
  557.                 .', new status is not paid:'.($newStatus->isNotPaid(false) ? 1 : 0)
  558.                 .' = operation: '.$event->getOperation()
  559.             );
  560.         }
  561.     }
  563.     /**
  564.      * Update order products stock after an order status change.
  565.      *
  566.      * @param int $newStatus the new status ID
  567.      *
  568.      * @throws \Exception
  569.      * @throws \Propel\Runtime\Exception\PropelException
  570.      */
  571.     protected function updateQuantity(ModelOrder $order, $newStatus, EventDispatcherInterface $dispatcher): void
  572.     {
  573.         if ($newStatus !== $order->getStatusId()) {
  574.             if (null !== $newStatusModel = OrderStatusQuery::create()->findPk($newStatus)) {
  575.                 $operationEvent = new GetStockUpdateOperationOnOrderStatusChangeEvent($order, $newStatusModel);
  577.                 $dispatcher->dispatch(
  578.                     $operationEvent,
  579.                     TheliaEvents::ORDER_GET_STOCK_UPDATE_OPERATION_ON_ORDER_STATUS_CHANGE
  580.                 );
  582.                 if ($operationEvent->getOperation() !== $operationEvent::DO_NOTHING) {
  583.                     $orderProductList = $order->getOrderProducts();
  585.                     /** @var OrderProduct $orderProduct */
  586.                     foreach ($orderProductList as $orderProduct) {
  587.                         $productSaleElementsId = $orderProduct->getProductSaleElementsId();
  589.                         /** @var ProductSaleElements $productSaleElements */
  590.                         if (null !== $productSaleElements = ProductSaleElementsQuery::create()->findPk($productSaleElementsId)) {
  591.                             $offset = 0;
  593.                             if ($operationEvent->getOperation() == $operationEvent::INCREASE_STOCK) {
  594.                                 $offset = $orderProduct->getQuantity();
  595.                             } elseif ($operationEvent->getOperation() == $operationEvent::DECREASE_STOCK) {
  596.                                 /* Check if we have enough stock */
  597.                                 if ($orderProduct->getQuantity() > $productSaleElements->getQuantity() && true === ConfigQuery::checkAvailableStock()) {
  598.                                     throw new TheliaProcessException($productSaleElements->getRef().' : Not enough stock 2');
  599.                                 }
  601.                                 $offset = -$orderProduct->getQuantity();
  602.                             }
  604.                             Tlog::getInstance()->addError('Product stock: '.$productSaleElements->getQuantity().' -> '.($productSaleElements->getQuantity() + $offset));
  606.                             $productSaleElements
  607.                                 ->setQuantity($productSaleElements->getQuantity() + $offset)
  608.                                 ->save();
  609.                         }
  610.                     }
  611.                 }
  612.             }
  613.         }
  614.     }
  616.     /**
  617.      * @throws \Propel\Runtime\Exception\PropelException
  618.      */
  619.     public function updateDeliveryRef(OrderEvent $event): void
  620.     {
  621.         $order = $event->getOrder();
  623.         $order->setDeliveryRef($event->getDeliveryRef())->save();
  625.         $event->setOrder($order);
  626.     }
  628.     /**
  629.      * @throws \Propel\Runtime\Exception\PropelException
  630.      */
  631.     public function updateTransactionRef(OrderEvent $event): void
  632.     {
  633.         $order = $event->getOrder();
  635.         $order->setTransactionRef($event->getTransactionRef())->save();
  637.         $event->setOrder($order);
  638.     }
  640.     /**
  641.      * @throws \Propel\Runtime\Exception\PropelException
  642.      */
  643.     public function updateAddress(OrderAddressEvent $event): void
  644.     {
  645.         $orderAddress = $event->getOrderAddress();
  647.         $orderAddress
  648.             ->setCustomerTitleId($event->getTitle())
  649.             ->setCompany($event->getCompany())
  650.             ->setFirstname($event->getFirstname())
  651.             ->setLastname($event->getLastname())
  652.             ->setAddress1($event->getAddress1())
  653.             ->setAddress2($event->getAddress2())
  654.             ->setAddress3($event->getAddress3())
  655.             ->setZipcode($event->getZipcode())
  656.             ->setCity($event->getCity())
  657.             ->setCountryId($event->getCountry())
  658.             ->setStateId($event->getState())
  659.             ->setPhone($event->getPhone())
  660.             ->setCellphone($event->getCellphone())
  661.             ->save()
  662.         ;
  664.         $event->setOrderAddress($orderAddress);
  665.     }
  667.     /**
  668.      * @throws \Propel\Runtime\Exception\PropelException
  669.      */
  670.     public function getOrderPayTotal(OrderPayTotalEvent $event): void
  671.     {
  672.         $order = $event->getOrder();
  673.         $tax = $event->getTax();
  675.         $total = $order->getTotalAmount(
  676.             $tax,
  677.             $event->isIncludePostage(),
  678.             $event->isIncludeDiscount()
  679.         );
  681.         $event->setTotal($total);
  682.         $event->setTax($tax);
  683.     }
  685.     /**
  686.      * {@inheritdoc}
  687.      */
  688.     public static function getSubscribedEvents()
  689.     {
  690.         return [
  691.             TheliaEvents::ORDER_SET_DELIVERY_ADDRESS => ['setDeliveryAddress', 128],
  692.             TheliaEvents::ORDER_SET_DELIVERY_MODULE => ['setDeliveryModule', 128],
  693.             TheliaEvents::ORDER_SET_POSTAGE => ['setPostage', 128],
  694.             TheliaEvents::ORDER_SET_INVOICE_ADDRESS => ['setInvoiceAddress', 128],
  695.             TheliaEvents::ORDER_SET_PAYMENT_MODULE => ['setPaymentModule', 128],
  696.             TheliaEvents::ORDER_PAY => ['create', 128],
  697.             TheliaEvents::ORDER_PAY_GET_TOTAL => ['getOrderPayTotal', 128],
  698.             TheliaEvents::ORDER_CART_CLEAR => ['orderCartClear', 128],
  699.             TheliaEvents::ORDER_BEFORE_PAYMENT => ['orderBeforePayment', 128],
  700.             TheliaEvents::ORDER_SEND_CONFIRMATION_EMAIL => ['sendConfirmationEmail', 128],
  701.             TheliaEvents::ORDER_SEND_NOTIFICATION_EMAIL => ['sendNotificationEmail', 128],
  702.             TheliaEvents::ORDER_UPDATE_STATUS => ['updateStatus', 128],
  703.             TheliaEvents::ORDER_UPDATE_DELIVERY_REF => ['updateDeliveryRef', 128],
  704.             TheliaEvents::ORDER_UPDATE_TRANSACTION_REF => ['updateTransactionRef', 128],
  705.             TheliaEvents::ORDER_UPDATE_ADDRESS => ['updateAddress', 128],
  706.             TheliaEvents::ORDER_CREATE_MANUAL => ['createManual', 128],
  707.             TheliaEvents::ORDER_GET_STOCK_UPDATE_OPERATION_ON_ORDER_STATUS_CHANGE => ['getStockUpdateOnOrderStatusChange', 128],
  708.         ];
  709.     }
  711.     /**
  712.      * Returns the session from the current request.
  713.      *
  714.      * @return \Thelia\Core\HttpFoundation\Session\Session
  715.      */
  716.     protected function getSession()
  717.     {
  718.         /** @var Request $request */
  719.         $request = $this->requestStack->getCurrentRequest();
  721.         return $request->getSession();
  722.     }
  723. }