local/modules/Front/Controller/OrderController.php line 52

  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 Front\Controller;
  15. use Front\Front;
  16. use Propel\Runtime\ActiveQuery\Criteria;
  17. use Propel\Runtime\Exception\PropelException;
  18. use Symfony\Component\HttpFoundation\Response as BaseResponse;
  19. use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
  20. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  21. use Thelia\Controller\Front\BaseFrontController;
  22. use Thelia\Core\Event\Delivery\DeliveryPostageEvent;
  23. use Thelia\Core\Event\Order\OrderEvent;
  24. use Thelia\Core\Event\Product\VirtualProductOrderDownloadResponseEvent;
  25. use Thelia\Core\Event\TheliaEvents;
  26. use Thelia\Core\HttpFoundation\Request;
  27. use Thelia\Exception\TheliaProcessException;
  28. use Thelia\Form\Definition\FrontForm;
  29. use Thelia\Form\Exception\FormValidationException;
  30. use Thelia\Log\Tlog;
  31. use Thelia\Model\Address;
  32. use Thelia\Model\AddressQuery;
  33. use Thelia\Model\AreaDeliveryModuleQuery;
  34. use Thelia\Model\ConfigQuery;
  35. use Thelia\Model\ModuleQuery;
  36. use Thelia\Model\Order;
  37. use Thelia\Model\OrderProductQuery;
  38. use Thelia\Model\OrderQuery;
  39. use Thelia\Module\AbstractDeliveryModule;
  40. use Thelia\Module\Exception\DeliveryException;
  42. /**
  43.  * Class OrderController.
  44.  *
  45.  * @author Etienne Roudeix <eroudeix@openstudio.fr>
  46.  */
  47. class OrderController extends BaseFrontController
  48. {
  49.     /**
  50.      * Check if the cart contains only virtual products.
  51.      */
  52.     public function deliverView(EventDispatcherInterface $eventDispatcher)
  53.     {
  54.         $this->checkAuth();
  55.         $this->checkCartNotEmpty($eventDispatcher);
  57.         // check if the cart contains only virtual products
  58.         $cart = $this->getSession()->getSessionCart($eventDispatcher);
  60.         $deliveryAddress = $this->getCustomerAddress();
  62.         if ($cart->isVirtual()) {
  63.             if (null !== $deliveryAddress) {
  64.                 $deliveryModule = ModuleQuery::create()->retrieveVirtualProductDelivery($this->container);
  66.                 if (false === $deliveryModule) {
  67.                     Tlog::getInstance()->error(
  68.                         $this->getTranslator()->trans(
  69.                             'To enable the virtual product feature, the VirtualProductDelivery module should be activated',
  70.                             [],
  71.                             Front::MESSAGE_DOMAIN
  72.                         )
  73.                     );
  74.                 } elseif (\count($deliveryModule) == 1) {
  75.                     return $this->registerVirtualProductDelivery($eventDispatcher, $deliveryModule[0], $deliveryAddress);
  76.                 }
  77.             }
  78.         }
  80.         return $this->render(
  81.             'order-delivery',
  82.             [
  83.                 'delivery_address_id' => (null !== $deliveryAddress) ? $deliveryAddress->getId() : null,
  84.             ]
  85.         );
  86.     }
  88.     /**
  89.      * @param AbstractDeliveryModule $moduleInstance
  90.      * @param Address                $deliveryAddress
  91.      *
  92.      * @return \Symfony\Component\HttpFoundation\Response
  93.      */
  94.     private function registerVirtualProductDelivery(EventDispatcherInterface $eventDispatcher, $moduleInstance, $deliveryAddress)
  95.     {
  96.         /* get postage amount */
  97.         $deliveryModule = $moduleInstance->getModuleModel();
  98.         $cart = $this->getSession()->getSessionCart($eventDispatcher);
  99.         $deliveryPostageEvent = new DeliveryPostageEvent($moduleInstance, $cart, $deliveryAddress);
  101.         $eventDispatcher->dispatch(
  102.             $deliveryPostageEvent,
  103.             TheliaEvents::MODULE_DELIVERY_GET_POSTAGE
  104.         );
  106.         $postage = $deliveryPostageEvent->getPostage();
  108.         $orderEvent = $this->getOrderEvent();
  109.         $orderEvent->setDeliveryAddress($deliveryAddress->getId());
  110.         $orderEvent->setDeliveryModule($deliveryModule->getId());
  111.         $orderEvent->setPostage($postage->getAmount());
  112.         $orderEvent->setPostageTax($postage->getAmountTax());
  113.         $orderEvent->setPostageTaxRuleTitle($postage->getTaxRuleTitle());
  115.         $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_DELIVERY_ADDRESS);
  116.         $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_DELIVERY_MODULE);
  117.         $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_POSTAGE);
  119.         return $this->generateRedirectFromRoute('order.invoice');
  120.     }
  122.     /**
  123.      * set delivery address
  124.      * set delivery module.
  125.      */
  126.     public function deliver(EventDispatcherInterface $eventDispatcher)
  127.     {
  128.         $this->checkAuth();
  129.         $this->checkCartNotEmpty($eventDispatcher);
  131.         $message = false;
  133.         $orderDelivery = $this->createForm(FrontForm::ORDER_DELIVER);
  135.         try {
  136.             $form = $this->validateForm($orderDelivery, 'post');
  138.             $deliveryAddressId = $form->get('delivery-address')->getData();
  139.             $deliveryModuleId = $form->get('delivery-module')->getData();
  140.             $deliveryAddress = AddressQuery::create()->findPk($deliveryAddressId);
  141.             $deliveryModule = ModuleQuery::create()->findPk($deliveryModuleId);
  143.             /* check that the delivery address belongs to the current customer */
  144.             if ($deliveryAddress->getCustomerId() !== $this->getSecurityContext()->getCustomerUser()->getId()) {
  145.                 throw new \Exception(
  146.                     $this->getTranslator()->trans(
  147.                         'Delivery address does not belong to the current customer',
  148.                         [],
  149.                         Front::MESSAGE_DOMAIN
  150.                     )
  151.                 );
  152.             }
  154.             /* check that the delivery module fetches the delivery address area */
  155.             if (null === AreaDeliveryModuleQuery::create()->findByCountryAndModule(
  156.                 $deliveryAddress->getCountry(),
  157.                 $deliveryModule,
  158.                 $deliveryAddress->getState()
  159.             )) {
  160.                 throw new \Exception(
  161.                     $this->getTranslator()->trans(
  162.                         'Delivery module cannot be use with selected delivery address',
  163.                         [],
  164.                         Front::MESSAGE_DOMAIN
  165.                     )
  166.                 );
  167.             }
  169.             /* get postage amount */
  170.             $moduleInstance = $deliveryModule->getDeliveryModuleInstance($this->container);
  172.             $cart = $this->getSession()->getSessionCart($eventDispatcher);
  173.             $deliveryPostageEvent = new DeliveryPostageEvent($moduleInstance, $cart, $deliveryAddress);
  175.             $eventDispatcher->dispatch(
  176.                 $deliveryPostageEvent,
  177.                 TheliaEvents::MODULE_DELIVERY_GET_POSTAGE
  178.             );
  180.             if (!$deliveryPostageEvent->isValidModule() || null === $deliveryPostageEvent->getPostage()) {
  181.                 throw new DeliveryException(
  182.                     $this->getTranslator()->trans('The delivery module is not valid.', [], Front::MESSAGE_DOMAIN)
  183.                 );
  184.             }
  186.             $postage = $deliveryPostageEvent->getPostage();
  188.             $orderEvent = $this->getOrderEvent();
  189.             $orderEvent->setDeliveryAddress($deliveryAddressId);
  190.             $orderEvent->setDeliveryModule($deliveryModuleId);
  191.             $orderEvent->setPostage($postage->getAmount());
  192.             $orderEvent->setPostageTax($postage->getAmountTax());
  193.             $orderEvent->setPostageTaxRuleTitle($postage->getTaxRuleTitle());
  195.             $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_DELIVERY_ADDRESS);
  196.             $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_DELIVERY_MODULE);
  197.             $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_POSTAGE);
  199.             return $this->generateRedirectFromRoute('order.invoice');
  200.         } catch (FormValidationException $e) {
  201.             $message = $this->getTranslator()->trans(
  202.                 'Please check your input: %s',
  203.                 ['%s' => $e->getMessage()],
  204.                 Front::MESSAGE_DOMAIN
  205.             );
  206.         } catch (PropelException $e) {
  207.             $this->getParserContext()->setGeneralError($e->getMessage());
  208.         } catch (\Exception $e) {
  209.             $message = $this->getTranslator()->trans(
  210.                 'Sorry, an error occured: %s',
  211.                 ['%s' => $e->getMessage()],
  212.                 Front::MESSAGE_DOMAIN
  213.             );
  214.         }
  216.         if ($message !== false) {
  217.             Tlog::getInstance()->error(
  218.                 sprintf('Error during order delivery process : %s. Exception was %s', $message, $e->getMessage())
  219.             );
  221.             $orderDelivery->setErrorMessage($message);
  223.             $this->getParserContext()
  224.                 ->addForm($orderDelivery)
  225.                 ->setGeneralError($message)
  226.             ;
  227.         }
  228.     }
  230.     /**
  231.      * set invoice address
  232.      * set payment module.
  233.      */
  234.     public function invoice(EventDispatcherInterface $eventDispatcher)
  235.     {
  236.         $this->checkAuth();
  237.         $this->checkCartNotEmpty($eventDispatcher);
  238.         $this->checkValidDelivery();
  240.         $message = false;
  242.         $orderPayment = $this->createForm(FrontForm::ORDER_PAYMENT);
  244.         try {
  245.             $form = $this->validateForm($orderPayment, 'post');
  247.             $invoiceAddressId = $form->get('invoice-address')->getData();
  248.             $paymentModuleId = $form->get('payment-module')->getData();
  250.             /* check that the invoice address belongs to the current customer */
  251.             $invoiceAddress = AddressQuery::create()->findPk($invoiceAddressId);
  252.             if ($invoiceAddress->getCustomerId() !== $this->getSecurityContext()->getCustomerUser()->getId()) {
  253.                 throw new \Exception(
  254.                     $this->getTranslator()->trans(
  255.                         'Invoice address does not belong to the current customer',
  256.                         [],
  257.                         Front::MESSAGE_DOMAIN
  258.                     )
  259.                 );
  260.             }
  262.             $orderEvent = $this->getOrderEvent();
  263.             $orderEvent->setInvoiceAddress($invoiceAddressId);
  264.             $orderEvent->setPaymentModule($paymentModuleId);
  266.             $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_INVOICE_ADDRESS);
  267.             $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_SET_PAYMENT_MODULE);
  269.             return $this->generateRedirectFromRoute('order.payment.process');
  270.         } catch (FormValidationException $e) {
  271.             $message = $this->getTranslator()->trans(
  272.                 'Please check your input: %s',
  273.                 ['%s' => $e->getMessage()],
  274.                 Front::MESSAGE_DOMAIN
  275.             );
  276.         } catch (PropelException $e) {
  277.             $this->getParserContext()->setGeneralError($e->getMessage());
  278.         } catch (\Exception $e) {
  279.             $message = $this->getTranslator()->trans(
  280.                 'Sorry, an error occured: %s',
  281.                 ['%s' => $e->getMessage()],
  282.                 Front::MESSAGE_DOMAIN
  283.             );
  284.         }
  286.         if ($message !== false) {
  287.             Tlog::getInstance()->error(
  288.                 sprintf('Error during order payment process : %s. Exception was %s', $message, $e->getMessage())
  289.             );
  291.             $orderPayment->setErrorMessage($message);
  293.             $this->getParserContext()
  294.                 ->addForm($orderPayment)
  295.                 ->setGeneralError($message)
  296.             ;
  297.         }
  299.         return $this->generateErrorRedirect($orderPayment);
  300.     }
  302.     public function pay(EventDispatcherInterface $eventDispatcher)
  303.     {
  304.         /* check customer */
  305.         $this->checkAuth();
  307.         /* check cart count */
  308.         $this->checkCartNotEmpty($eventDispatcher);
  310.         /* check stock not empty */
  311.         if (true === ConfigQuery::checkAvailableStock()) {
  312.             if (null !== $response = $this->checkStockNotEmpty($eventDispatcher)) {
  313.                 return $response;
  314.             }
  315.         }
  317.         /* check delivery address and module */
  318.         $this->checkValidDelivery();
  320.         /* check invoice address and payment module */
  321.         $this->checkValidInvoice();
  323.         $orderEvent = $this->getOrderEvent();
  325.         $eventDispatcher->dispatch($orderEvent, TheliaEvents::ORDER_PAY);
  327.         $placedOrder = $orderEvent->getPlacedOrder();
  329.         if (null !== $placedOrder && null !== $placedOrder->getId()) {
  330.             /* order has been placed */
  331.             if ($orderEvent->hasResponse()) {
  332.                 return $orderEvent->getResponse();
  333.             }
  335.             return $this->generateRedirectFromRoute(
  336.                 'order.placed',
  337.                 [],
  338.                 ['order_id' => $orderEvent->getPlacedOrder()->getId()]
  339.             );
  340.         }
  341.         /* order has not been placed */
  342.         return $this->generateRedirectFromRoute('cart.view');
  343.     }
  345.     public function orderPlaced(EventDispatcherInterface $eventDispatcher, $order_id): void
  346.     {
  347.         /* check if the placed order matched the customer */
  348.         $placedOrder = OrderQuery::create()->findPk(
  349.             $this->getRequest()->attributes->get('order_id')
  350.         );
  352.         if (null === $placedOrder) {
  353.             throw new TheliaProcessException(
  354.                 $this->getTranslator()->trans(
  355.                     'No placed order',
  356.                     [],
  357.                     Front::MESSAGE_DOMAIN
  358.                 ),
  359.                 TheliaProcessException::NO_PLACED_ORDER,
  360.                 $placedOrder
  361.             );
  362.         }
  364.         $customer = $this->getSecurityContext()->getCustomerUser();
  366.         if (null === $customer || $placedOrder->getCustomerId() !== $customer->getId()) {
  367.             throw new TheliaProcessException(
  368.                 $this->getTranslator()->trans(
  369.                     'Received placed order id does not belong to the current customer',
  370.                     [],
  371.                     Front::MESSAGE_DOMAIN
  372.                 ),
  373.                 TheliaProcessException::PLACED_ORDER_ID_BAD_CURRENT_CUSTOMER,
  374.                 $placedOrder
  375.             );
  376.         }
  378.         $eventDispatcher->dispatch($this->getOrderEvent(), TheliaEvents::ORDER_CART_CLEAR);
  380.         $this->getParserContext()->set('placed_order_id', $placedOrder->getId());
  381.     }
  383.     public function orderFailed($order_id, $message): void
  384.     {
  385.         if (empty($order_id)) {
  386.             // Fallback to request parameter if the method parameter is empty.
  387.             $order_id = $this->getRequest()->get('order_id');
  388.         }
  390.         $failedOrder = OrderQuery::create()->findPk($order_id);
  392.         if (null !== $failedOrder) {
  393.             $customer = $this->getSecurityContext()->getCustomerUser();
  395.             if (null === $customer || $failedOrder->getCustomerId() !== $customer->getId()) {
  396.                 throw new TheliaProcessException(
  397.                     $this->getTranslator()->trans(
  398.                         'Received failed order id does not belong to the current customer',
  399.                         [],
  400.                         Front::MESSAGE_DOMAIN
  401.                     ),
  402.                     TheliaProcessException::PLACED_ORDER_ID_BAD_CURRENT_CUSTOMER,
  403.                     $failedOrder
  404.                 );
  405.             }
  406.         } else {
  407.             Tlog::getInstance()->warning("Failed order ID '$order_id' not found.");
  408.         }
  410.         $this->getParserContext()
  411.             ->set('failed_order_id', $order_id)
  412.             ->set('failed_order_message', $message)
  413.         ;
  414.     }
  416.     protected function getOrderEvent()
  417.     {
  418.         $order = $this->getOrder($this->getRequest());
  420.         return new OrderEvent($order);
  421.     }
  423.     public function getOrder(Request $request)
  424.     {
  425.         $session = $request->getSession();
  427.         if (null !== $order = $session->getOrder()) {
  428.             return $order;
  429.         }
  431.         $order = new Order();
  433.         $session->setOrder($order);
  435.         return $order;
  436.     }
  438.     public function viewAction($order_id)
  439.     {
  440.         $this->checkOrderCustomer($order_id);
  442.         return $this->render('account-order', ['order_id' => $order_id]);
  443.     }
  445.     public function generateInvoicePdf(EventDispatcherInterface $eventDispatcher, $order_id)
  446.     {
  447.         $this->checkOrderCustomer($order_id);
  449.         return $this->generateOrderPdf($eventDispatcher, $order_id, ConfigQuery::read('pdf_invoice_file', 'invoice'));
  450.     }
  452.     public function generateDeliveryPdf(EventDispatcherInterface $eventDispatcher, $order_id)
  453.     {
  454.         $this->checkOrderCustomer($order_id);
  456.         return $this->generateOrderPdf($eventDispatcher, $order_id, ConfigQuery::read('pdf_delivery_file', 'delivery'));
  457.     }
  459.     public function downloadVirtualProduct(EventDispatcherInterface $eventDispatcher, $order_product_id)
  460.     {
  461.         if (null !== $orderProduct = OrderProductQuery::create()->findPk($order_product_id)) {
  462.             $order = $orderProduct->getOrder();
  464.             if ($order->isPaid(false)) {
  465.                 // check customer
  466.                 $this->checkOrderCustomer($order->getId());
  468.                 $virtualProductEvent = new VirtualProductOrderDownloadResponseEvent($orderProduct);
  469.                 $eventDispatcher->dispatch(
  470.                     $virtualProductEvent,
  471.                     TheliaEvents::VIRTUAL_PRODUCT_ORDER_DOWNLOAD_RESPONSE
  472.                 );
  474.                 $response = $virtualProductEvent->getResponse();
  476.                 if (!$response instanceof BaseResponse) {
  477.                     throw new \RuntimeException('A Response must be added in the event TheliaEvents::VIRTUAL_PRODUCT_ORDER_DOWNLOAD_RESPONSE');
  478.                 }
  480.                 return $response;
  481.             }
  482.         }
  484.         throw new AccessDeniedHttpException();
  485.     }
  487.     private function checkOrderCustomer($order_id): void
  488.     {
  489.         $this->checkAuth();
  491.         $order = OrderQuery::create()->findPk($order_id);
  492.         $valid = true;
  493.         if ($order) {
  494.             $customerOrder = $order->getCustomer();
  495.             $customer = $this->getSecurityContext()->getCustomerUser();
  497.             if ($customerOrder->getId() != $customer->getId()) {
  498.                 $valid = false;
  499.             }
  500.         } else {
  501.             $valid = false;
  502.         }
  504.         if (false === $valid) {
  505.             throw new AccessDeniedHttpException();
  506.         }
  507.     }
  509.     public function getDeliveryModuleListAjaxAction()
  510.     {
  511.         $this->checkXmlHttpRequest();
  513.         // Change the delivery address if customer has changed it
  514.         $address = null;
  515.         $session = $this->getSession();
  516.         $addressId = $this->getRequest()->get('address_id', null);
  517.         if (null !== $addressId && $addressId !== $session->getOrder()->getChoosenDeliveryAddress()) {
  518.             $address = AddressQuery::create()->findPk($addressId);
  519.             if (null !== $address && $address->getCustomerId() === $session->getCustomerUser()->getId()) {
  520.                 $session->getOrder()->setChoosenDeliveryAddress($addressId);
  521.             }
  522.         }
  524.         $address = AddressQuery::create()->findPk($session->getOrder()->getChoosenDeliveryAddress());
  526.         $countryId = $address->getCountryId();
  527.         $stateId = $address->getStateId();
  529.         $args = [
  530.             'country' => $countryId,
  531.             'state' => $stateId,
  532.             'address' => $session->getOrder()->getChoosenDeliveryAddress(),
  533.         ];
  535.         return $this->render('ajax/order-delivery-module-list', $args);
  536.     }
  538.     /**
  539.      * Redirect to cart view if at least one non product is out of stock.
  540.      *
  541.      * @return BaseResponse|null
  542.      */
  543.     private function checkStockNotEmpty(EventDispatcherInterface $eventDispatcher)
  544.     {
  545.         $cart = $this->getSession()->getSessionCart($eventDispatcher);
  547.         $cartItems = $cart->getCartItems();
  549.         foreach ($cartItems as $cartItem) {
  550.             $pse = $cartItem->getProductSaleElements();
  552.             $product = $cartItem->getProduct();
  554.             if ($pse->getQuantity() <= 0 && $product->getVirtual() !== 1) {
  555.                 return $this->generateRedirectFromRoute('cart.view');
  556.             }
  557.         }
  559.         return null;
  560.     }
  562.     /**
  563.      * Retrieve the chosen delivery address for a cart or the default customer address if not exists.
  564.      *
  565.      * @return Address|null
  566.      */
  567.     protected function getCustomerAddress()
  568.     {
  569.         $deliveryAddress = null;
  570.         $addressId = $this->getSession()->getOrder()->getChoosenDeliveryAddress();
  571.         if (null === $addressId) {
  572.             $customer = $this->getSecurityContext()->getCustomerUser();
  574.             $deliveryAddress = AddressQuery::create()
  575.                 ->filterByCustomerId($customer->getId())
  576.                 ->orderByIsDefault(Criteria::DESC)
  577.                 ->findOne();
  579.             if (null !== $deliveryAddress) {
  580.                 $this->getSession()->getOrder()->setChoosenDeliveryAddress(
  581.                     $deliveryAddress->getId()
  582.                 );
  583.             }
  584.         } else {
  585.             $deliveryAddress = AddressQuery::create()->findPk($addressId);
  586.         }
  588.         return $deliveryAddress;
  589.     }
  590. }