core/lib/Thelia/Action/Cart.php line 140

  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 Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Symfony\Component\HttpFoundation\RequestStack;
  18. use Thelia\Core\Event\Cart\CartCreateEvent;
  19. use Thelia\Core\Event\Cart\CartDuplicationEvent;
  20. use Thelia\Core\Event\Cart\CartEvent;
  21. use Thelia\Core\Event\Cart\CartPersistEvent;
  22. use Thelia\Core\Event\Cart\CartRestoreEvent;
  23. use Thelia\Core\Event\Currency\CurrencyChangeEvent;
  24. use Thelia\Core\Event\TheliaEvents;
  25. use Thelia\Model\Base\CustomerQuery;
  26. use Thelia\Model\Base\ProductSaleElementsQuery;
  27. use Thelia\Model\Cart as CartModel;
  28. use Thelia\Model\CartItem;
  29. use Thelia\Model\CartItemQuery;
  30. use Thelia\Model\CartQuery;
  31. use Thelia\Model\ConfigQuery;
  32. use Thelia\Model\Currency as CurrencyModel;
  33. use Thelia\Model\Customer as CustomerModel;
  34. use Thelia\Model\ProductSaleElements;
  35. use Thelia\Model\Tools\ProductPriceTools;
  36. use Thelia\Tools\TokenProvider;
  38. /**
  39.  * Class Cart where all actions are manage like adding, modifying or delete items.
  40.  *
  41.  * Class Cart
  42.  *
  43.  * @author Manuel Raynaud <manu@raynaud.io>
  44.  */
  45. class Cart extends BaseAction implements EventSubscriberInterface
  46. {
  47.     /** @var RequestStack */
  48.     protected $requestStack;
  50.     /** @var TokenProvider */
  51.     protected $tokenProvider;
  53.     public function __construct(RequestStack $requestStack, TokenProvider $tokenProvider)
  54.     {
  55.         $this->requestStack = $requestStack;
  57.         $this->tokenProvider = $tokenProvider;
  58.     }
  60.     public function persistCart(CartPersistEvent $event): void
  61.     {
  62.         $cart = $event->getCart();
  64.         if ($cart->isNew()) {
  65.             $cart
  66.                 ->setToken($this->generateCartCookieIdentifier())
  67.                 ->save();
  68.             $this->getSession()->setSessionCart($cart);
  69.         }
  70.     }
  72.     /**
  73.      * add an article in the current cart.
  74.      */
  75.     public function addItem(CartEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  76.     {
  77.         $cart = $event->getCart();
  78.         $newness = $event->getNewness();
  79.         $append = $event->getAppend();
  80.         $quantity = $event->getQuantity();
  81.         $currency = $cart->getCurrency();
  82.         $customer = $cart->getCustomer();
  83.         $discount = 0;
  85.         if ($cart->isNew()) {
  86.             $persistEvent = new CartPersistEvent($cart);
  87.             $dispatcher->dispatch($persistEvent, TheliaEvents::CART_PERSIST);
  88.         }
  90.         if (null !== $customer && $customer->getDiscount() > 0) {
  91.             $discount = $customer->getDiscount();
  92.         }
  94.         $productSaleElementsId = $event->getProductSaleElementsId();
  95.         $productId = $event->getProduct();
  97.         // Search for an identical item in the cart
  98.         $findItemEvent = clone $event;
  100.         $dispatcher->dispatch($findItemEvent, TheliaEvents::CART_FINDITEM);
  102.         $cartItem = $findItemEvent->getCartItem();
  104.         if ($cartItem === null || $newness) {
  105.             $productSaleElements = ProductSaleElementsQuery::create()->findPk($productSaleElementsId);
  107.             if (null !== $productSaleElements) {
  108.                 $productPrices = $productSaleElements->getPricesByCurrency($currency, $discount);
  110.                 $cartItem = $this->doAddItem($dispatcher, $cart, $productId, $productSaleElements, $quantity, $productPrices);
  111.             }
  112.         } elseif ($append && $cartItem !== null) {
  113.             $cartItem->addQuantity($quantity)->save();
  114.         }
  116.         $event->setCartItem($cartItem);
  117.     }
  119.     /**
  120.      * Delete specify article present into cart.
  121.      */
  122.     public function deleteItem(CartEvent $event): void
  123.     {
  124.         if (null !== $cartItemId = $event->getCartItemId()) {
  125.             $cart = $event->getCart();
  126.             CartItemQuery::create()
  127.                 ->filterByCartId($cart->getId())
  128.                 ->filterById($cartItemId)
  129.                 ->delete();
  131.             // Force an update of the Cart object to provide
  132.             // to other listeners an updated CartItem collection.
  133.             $cart->clearCartItems();
  134.         }
  135.     }
  137.     /**
  138.      * Clear the cart.
  139.      */
  140.     public function clear(CartEvent $event): void
  141.     {
  142.         if (null !== $cart = $event->getCart()) {
  143.             $cart->delete();
  144.         }
  145.     }
  147.     /**
  148.      * Modify article's quantity.
  149.      *
  150.      * don't use Form here just test the Request.
  151.      */
  152.     public function changeItem(CartEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  153.     {
  154.         if ((null !== $cartItemId = $event->getCartItemId()) && (null !== $quantity = $event->getQuantity())) {
  155.             $cart = $event->getCart();
  157.             $cartItem = CartItemQuery::create()
  158.                 ->filterByCartId($cart->getId())
  159.                 ->filterById($cartItemId)
  160.                 ->findOne();
  162.             if ($cartItem) {
  163.                 $event->setCartItem(
  164.                     $this->updateQuantity($dispatcher, $cartItem, $quantity)
  165.                 );
  166.             }
  167.         }
  168.     }
  170.     public function updateCart(CurrencyChangeEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  171.     {
  172.         $cart = $event->getRequest()->getSession()->getSessionCart($dispatcher);
  174.         if (null !== $cart) {
  175.             $this->updateCartPrices($cart, $event->getCurrency());
  176.         }
  177.     }
  179.     /**
  180.      * Refresh article's price.
  181.      */
  182.     public function updateCartPrices(CartModel $cart, CurrencyModel $currency): void
  183.     {
  184.         $customer = $cart->getCustomer();
  185.         $discount = 0;
  187.         if (null !== $customer && $customer->getDiscount() > 0) {
  188.             $discount = $customer->getDiscount();
  189.         }
  191.         // cart item
  192.         foreach ($cart->getCartItems() as $cartItem) {
  193.             $productSaleElements = $cartItem->getProductSaleElements();
  195.             $productPrice = $productSaleElements->getPricesByCurrency($currency, $discount);
  197.             $cartItem
  198.                 ->setPrice($productPrice->getPrice())
  199.                 ->setPromoPrice($productPrice->getPromoPrice());
  201.             $cartItem->save();
  202.         }
  204.         // update the currency cart
  205.         $cart->setCurrencyId($currency->getId());
  206.         $cart->save();
  207.     }
  209.     /**
  210.      * increase the quantity for an existing cartItem.
  211.      *
  212.      * @param float $quantity
  213.      *
  214.      * @throws \Exception
  215.      * @throws \Propel\Runtime\Exception\PropelException
  216.      *
  217.      * @return CartItem
  218.      */
  219.     protected function updateQuantity(EventDispatcherInterface $dispatcher, CartItem $cartItem, $quantity)
  220.     {
  221.         $cartItem->setDisptacher($dispatcher);
  222.         $cartItem->updateQuantity($quantity)
  223.             ->save();
  225.         return $cartItem;
  226.     }
  228.     /**
  229.      * try to attach a new item to an existing cart.
  230.      *
  231.      * @param int   $productId
  232.      * @param float $quantity
  233.      *
  234.      * @return CartItem
  235.      */
  236.     protected function doAddItem(
  237.         EventDispatcherInterface $dispatcher,
  238.         CartModel $cart,
  239.         $productId,
  240.         ProductSaleElements $productSaleElements,
  241.         $quantity,
  242.         ProductPriceTools $productPrices
  243.     ) {
  244.         $cartItem = new CartItem();
  245.         $cartItem->setDisptacher($dispatcher);
  246.         $cartItem
  247.             ->setCart($cart)
  248.             ->setProductId($productId)
  249.             ->setProductSaleElementsId($productSaleElements->getId())
  250.             ->setQuantity($quantity)
  251.             ->setPrice($productPrices->getPrice())
  252.             ->setPromoPrice($productPrices->getPromoPrice())
  253.             ->setPromo($productSaleElements->getPromo())
  254.             ->setPriceEndOfLife(time() + ConfigQuery::read('cart.priceEOF', 60 * 60 * 24 * 30))
  255.             ->save();
  257.         return $cartItem;
  258.     }
  260.     /**
  261.      * find a specific record in CartItem table using the Cart id, the product id
  262.      * and the product_sale_elements id.
  263.      *
  264.      * @param int $cartId
  265.      * @param int $productId
  266.      * @param int $productSaleElementsId
  267.      *
  268.      * @return CartItem
  269.      *
  270.      * @deprecated this method is deprecated. Dispatch a TheliaEvents::CART_FINDITEM instead
  271.      */
  272.     protected function findItem($cartId, $productId, $productSaleElementsId)
  273.     {
  274.         return CartItemQuery::create()
  275.             ->filterByCartId($cartId)
  276.             ->filterByProductId($productId)
  277.             ->filterByProductSaleElementsId($productSaleElementsId)
  278.             ->findOne();
  279.     }
  281.     /**
  282.      * Find a specific record in CartItem table using the current CartEvent.
  283.      *
  284.      * @param CartEvent $event the cart event
  285.      */
  286.     public function findCartItem(CartEvent $event): void
  287.     {
  288.         // Do not try to find a cartItem if one exists in the event, as previous event handlers
  289.         // mays have put it in th event.
  290.         if (null === $event->getCartItem() && null !== $foundItem = CartItemQuery::create()
  291.             ->filterByCartId($event->getCart()->getId())
  292.             ->filterByProductId($event->getProduct())
  293.             ->filterByProductSaleElementsId($event->getProductSaleElementsId())
  294.             ->findOne()) {
  295.             $event->setCartItem($foundItem);
  296.         }
  297.     }
  299.     /**
  300.      * Search if cart already exists in session. If not try to restore it from the cart cookie,
  301.      * or duplicate an old one.
  302.      */
  303.     public function restoreCurrentCart(CartRestoreEvent $cartRestoreEvent, $eventName, EventDispatcherInterface $dispatcher): void
  304.     {
  305.         $cookieName = ConfigQuery::read('cart.cookie_name', 'thelia_cart');
  306.         $persistentCookie = ConfigQuery::read('cart.use_persistent_cookie', 1);
  308.         $cart = null;
  310.         if ($this->requestStack->getCurrentRequest()->cookies->has($cookieName) && $persistentCookie) {
  311.             $cart = $this->managePersistentCart($cartRestoreEvent, $cookieName, $dispatcher);
  312.         } elseif (!$persistentCookie) {
  313.             $cart = $this->manageNonPersistentCookie($cartRestoreEvent, $dispatcher);
  314.         }
  316.         // Still no cart ? Create a new one.
  317.         if (null === $cart) {
  318.             $cart = $this->dispatchNewCart($dispatcher);
  319.         }
  320.         if ($cart->getCurrency()) {
  321.             $this->getSession()->setCurrency($cart->getCurrency());
  322.         }
  323.         $cartRestoreEvent->setCart($cart);
  324.     }
  326.     /**
  327.      * The cart token is not saved in a cookie, if the cart is present in session, we just change the customer id
  328.      * if needed or create duplicate the current cart if the customer is not the same as customer already present in
  329.      * the cart.
  330.      *
  331.      * @throws \Exception
  332.      * @throws \Propel\Runtime\Exception\PropelException
  333.      *
  334.      * @return CartModel
  335.      */
  336.     protected function manageNonPersistentCookie(CartRestoreEvent $cartRestoreEvent, EventDispatcherInterface $dispatcher)
  337.     {
  338.         $cart = $cartRestoreEvent->getCart();
  340.         if (null === $cart) {
  341.             $cart = $this->dispatchNewCart($dispatcher);
  342.         } else {
  343.             $cart = $this->manageCartDuplicationAtCustomerLogin($cart, $dispatcher);
  344.         }
  346.         return $cart;
  347.     }
  349.     /**
  350.      * The cart token is saved in a cookie so we try to retrieve it. Then the customer is checked.
  351.      *
  352.      * @throws \Exception
  353.      * @throws \Propel\Runtime\Exception\PropelException
  354.      *
  355.      * @return CartModel
  356.      */
  357.     protected function managePersistentCart(CartRestoreEvent $cartRestoreEvent, $cookieName, EventDispatcherInterface $dispatcher)
  358.     {
  359.         // The cart cookie exists -> get the cart token
  360.         $token = $this->requestStack->getCurrentRequest()->cookies->get($cookieName);
  362.         // Check if a cart exists for this token
  363.         if (null !== $cart = CartQuery::create()->findOneByToken($token)) {
  364.             $cart = $this->manageCartDuplicationAtCustomerLogin($cart, $dispatcher);
  365.         }
  367.         return $cart;
  368.     }
  370.     protected function manageCartDuplicationAtCustomerLogin(CartModel $cart, EventDispatcherInterface $dispatcher)
  371.     {
  372.         /** @var CustomerModel $customer */
  373.         if (null !== $customer = $this->getSession()->getCustomerUser()) {
  374.             // Check if we have to duplicate the existing cart.
  376.             $duplicateCart = true;
  378.             // A customer is logged in.
  379.             if (null === $cart->getCustomerId()) {
  380.                 // If the customer has a discount, whe have to duplicate the cart,
  381.                 // so that the discount will be applied to the products in cart.
  383.                 if (0 === $customer->getDiscount() || 0 === $cart->countCartItems()) {
  384.                     // If no discount, or an empty cart, there's no need to duplicate.
  385.                     $duplicateCart = false;
  386.                 }
  387.             }
  389.             if ($duplicateCart) {
  390.                 // Duplicate the cart
  391.                 $cart = $this->duplicateCart($dispatcher, $cart, $customer);
  392.             } else {
  393.                 // No duplication required, just assign the cart to the customer
  394.                 $cart->setCustomerId($customer->getId())->save();
  395.             }
  396.         } elseif ($cart->getCustomerId() != null) {
  397.             // The cart belongs to another user
  398.             if (0 === $cart->countCartItems()) {
  399.                 // No items in cart, assign it to nobody.
  400.                 $cart->setCustomerId(null)->save();
  401.             } else {
  402.                 // Some itemls in cart, duplicate it without assigning a customer ID.
  403.                 $cart = $this->duplicateCart($dispatcher, $cart);
  404.             }
  405.         }
  407.         return $cart;
  408.     }
  410.     /**
  411.      * @return CartModel
  412.      */
  413.     protected function dispatchNewCart(EventDispatcherInterface $dispatcher)
  414.     {
  415.         $cartCreateEvent = new CartCreateEvent();
  417.         $dispatcher->dispatch($cartCreateEvent, TheliaEvents::CART_CREATE_NEW);
  419.         return $cartCreateEvent->getCart();
  420.     }
  422.     /**
  423.      * Create a new, empty cart object, and assign it to the current customer, if any.
  424.      */
  425.     public function createEmptyCart(CartCreateEvent $cartCreateEvent): void
  426.     {
  427.         $cart = new CartModel();
  429.         $cart->setCurrency($this->getSession()->getCurrency(true));
  431.         /** @var CustomerModel $customer */
  432.         if (null !== $customer = $this->getSession()->getCustomerUser()) {
  433.             $cart->setCustomer(CustomerQuery::create()->findPk($customer->getId()));
  434.         }
  436.         $this->getSession()->setSessionCart($cart);
  438.         if (ConfigQuery::read('cart.use_persistent_cookie', 1) == 1) {
  439.             // set cart_use_cookie to "" to remove the cart cookie
  440.             // see Thelia\Core\EventListener\ResponseListener
  441.             $this->getSession()->set('cart_use_cookie', '');
  442.         }
  444.         $cartCreateEvent->setCart($cart);
  445.     }
  447.     /**
  448.      * Duplicate an existing Cart. If a customer ID is provided the created cart will be attached to this customer.
  449.      *
  450.      * @param CustomerModel $customer
  451.      *
  452.      * @return CartModel
  453.      */
  454.     protected function duplicateCart(EventDispatcherInterface $dispatcher, CartModel $cart, CustomerModel $customer = null)
  455.     {
  456.         $newCart = $cart->duplicate(
  457.             $this->generateCartCookieIdentifier(),
  458.             $customer,
  459.             $this->getSession()->getCurrency(),
  460.             $dispatcher
  461.         );
  463.         $cartEvent = new CartDuplicationEvent($newCart, $cart);
  464.         $dispatcher->dispatch($cartEvent, TheliaEvents::CART_DUPLICATE);
  466.         return $cartEvent->getDuplicatedCart();
  467.     }
  469.     /**
  470.      * Generate the cart cookie identifier, or return null if the cart is only managed in the session object,
  471.      * not in a client cookie.
  472.      *
  473.      * @return string
  474.      */
  475.     protected function generateCartCookieIdentifier()
  476.     {
  477.         $id = null;
  479.         if (ConfigQuery::read('cart.use_persistent_cookie', 1) == 1) {
  480.             $id = $this->tokenProvider->getToken();
  481.             $this->getSession()->set('cart_use_cookie', $id);
  482.         }
  484.         return $id;
  485.     }
  487.     /**
  488.      * {@inheritdoc}
  489.      */
  490.     public static function getSubscribedEvents()
  491.     {
  492.         return [
  493.             TheliaEvents::CART_PERSIST => ['persistCart', 128],
  494.             TheliaEvents::CART_RESTORE_CURRENT => ['restoreCurrentCart', 128],
  495.             TheliaEvents::CART_CREATE_NEW => ['createEmptyCart', 128],
  496.             TheliaEvents::CART_ADDITEM => ['addItem', 128],
  497.             TheliaEvents::CART_FINDITEM => ['findCartItem', 128],
  498.             TheliaEvents::CART_DELETEITEM => ['deleteItem', 128],
  499.             TheliaEvents::CART_UPDATEITEM => ['changeItem', 128],
  500.             TheliaEvents::CART_CLEAR => ['clear', 128],
  501.             TheliaEvents::CHANGE_DEFAULT_CURRENCY => ['updateCart', 128],
  502.         ];
  503.     }
  505.     /**
  506.      * Returns the session from the current request.
  507.      *
  508.      * @return \Thelia\Core\HttpFoundation\Session\Session
  509.      */
  510.     protected function getSession()
  511.     {
  512.         return $this->requestStack->getCurrentRequest()->getSession();
  513.     }
  514. }