src/Eccube/Service/CartService.php line 492

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of EC-CUBE
  5.  *
  6.  * Copyright(c) EC-CUBE CO.,LTD. All Rights Reserved.
  7.  *
  8.  * http://www.ec-cube.co.jp/
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Eccube\Service;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\UnitOfWork;
  18. use Eccube\Entity\Cart;
  19. use Eccube\Entity\CartItem;
  20. use Eccube\Entity\Customer;
  21. use Eccube\Entity\ItemHolderInterface;
  22. use Eccube\Entity\ProductClass;
  23. use Eccube\Repository\CartRepository;
  24. use Eccube\Repository\OrderRepository;
  25. use Eccube\Repository\ProductClassRepository;
  26. use Eccube\Service\Cart\CartItemAllocator;
  27. use Eccube\Service\Cart\CartItemComparator;
  28. use Eccube\Util\StringUtil;
  29. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  30. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  31. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  33. class CartService
  34. {
  35.     /**
  36.      * @var Cart[]
  37.      */
  38.     protected $carts;
  40.     /**
  41.      * @var SessionInterface
  42.      */
  43.     protected $session;
  45.     /**
  46.      * @var \Doctrine\ORM\EntityManagerInterface
  47.      */
  48.     protected $entityManager;
  50.     /**
  51.      * @var ItemHolderInterface
  52.      *
  53.      * @deprecated
  54.      */
  55.     protected $cart;
  57.     /**
  58.      * @var ProductClassRepository
  59.      */
  60.     protected $productClassRepository;
  62.     /**
  63.      * @var CartRepository
  64.      */
  65.     protected $cartRepository;
  67.     /**
  68.      * @var CartItemComparator
  69.      */
  70.     protected $cartItemComparator;
  72.     /**
  73.      * @var CartItemAllocator
  74.      */
  75.     protected $cartItemAllocator;
  77.     /**
  78.      * @var OrderRepository
  79.      */
  80.     protected $orderRepository;
  82.     /**
  83.      * @var TokenStorageInterface
  84.      */
  85.     protected $tokenStorage;
  87.     /**
  88.      * @var AuthorizationCheckerInterface
  89.      */
  90.     protected $authorizationChecker;
  92.     /**
  93.      * CartService constructor.
  94.      */
  95.     public function __construct(
  96.         SessionInterface $session,
  97.         EntityManagerInterface $entityManager,
  98.         ProductClassRepository $productClassRepository,
  99.         CartRepository $cartRepository,
  100.         CartItemComparator $cartItemComparator,
  101.         CartItemAllocator $cartItemAllocator,
  102.         OrderRepository $orderRepository,
  103.         TokenStorageInterface $tokenStorage,
  104.         AuthorizationCheckerInterface $authorizationChecker
  105.     ) {
  106.         $this->session = $session;
  107.         $this->entityManager = $entityManager;
  108.         $this->productClassRepository = $productClassRepository;
  109.         $this->cartRepository = $cartRepository;
  110.         $this->cartItemComparator = $cartItemComparator;
  111.         $this->cartItemAllocator = $cartItemAllocator;
  112.         $this->orderRepository = $orderRepository;
  113.         $this->tokenStorage = $tokenStorage;
  114.         $this->authorizationChecker = $authorizationChecker;
  115.     }
  117.     /**
  118.      * 現在のカートの配列を取得する.
  119.      *
  120.      * 本サービスのインスタンスのメンバーが空の場合は、DBまたはセッションからカートを取得する
  121.      *
  122.      * @param bool $empty_delete true の場合、商品明細が空のカートが存在した場合は削除する
  123.      *
  124.      * @return Cart[]
  125.      */
  126.     public function getCarts($empty_delete = false)
  127.     {
  128.         if (null !== $this->carts) {
  129.             if ($empty_delete) {
  130.                 $cartKeys = [];
  131.                 foreach (array_keys($this->carts) as $index) {
  132.                     $Cart = $this->carts[$index];
  133.                     if ($Cart->getItems()->count() > 0) {
  134.                         $cartKeys[] = $Cart->getCartKey();
  135.                     } else {
  136.                         $this->entityManager->remove($this->carts[$index]);
  137.                         $this->entityManager->flush();
  138.                         unset($this->carts[$index]);
  139.                     }
  140.                 }
  142.                 $this->session->set('cart_keys', $cartKeys);
  143.             }
  145.             return $this->carts;
  146.         }
  148.         if ($this->getUser()) {
  149.             $this->carts = $this->getPersistedCarts();
  150.         } else {
  151.             $this->carts = $this->getSessionCarts();
  152.         }
  154.         return $this->carts;
  155.     }
  157.     /**
  158.      * 永続化されたカートを返す
  159.      *
  160.      * @return Cart[]
  161.      */
  162.     public function getPersistedCarts()
  163.     {
  164.         return $this->cartRepository->findBy(['Customer' => $this->getUser()]);
  165.     }
  167.     /**
  168.      * セッションにあるカートを返す
  169.      *
  170.      * @return Cart[]
  171.      */
  172.     public function getSessionCarts()
  173.     {
  174.         $cartKeys = $this->session->get('cart_keys', []);
  176.         if (empty($cartKeys)) {
  177.             return [];
  178.         }
  180.         return $this->cartRepository->findBy(['cart_key' => $cartKeys], ['id' => 'ASC']);
  181.     }
  183.     /**
  184.      * 会員が保持する永続化されたカートと、非会員時のカートをマージする.
  185.      */
  186.     public function mergeFromPersistedCart()
  187.     {
  188.         $persistedCarts = $this->getPersistedCarts();
  189.         $sessionCarts = $this->getSessionCarts();
  191.         $CartItems = [];
  193.         // 永続化されたカートとセッションのカートが同一の場合はマージしない #4574
  194.         $cartKeys = $this->session->get('cart_keys', []);
  195.         if ((count($persistedCarts) > 0) && !in_array($persistedCarts[0]->getCartKey(), $cartKeys, true)) {
  196.             foreach ($persistedCarts as $Cart) {
  197.                 $CartItems = $this->mergeCartItems($Cart->getCartItems(), $CartItems);
  198.             }
  199.         }
  201.         // セッションにある非会員カートとDBから取得した会員カートをマージする.
  202.         foreach ($sessionCarts as $Cart) {
  203.             $CartItems = $this->mergeCartItems($Cart->getCartItems(), $CartItems);
  204.         }
  206.         $this->restoreCarts($CartItems);
  207.     }
  209.     /**
  210.      * @return Cart|null
  211.      */
  212.     public function getCart()
  213.     {
  214.         $Carts = $this->getCarts();
  216.         if (empty($Carts)) {
  217.             return null;
  218.         }
  220.         $cartKeys = $this->session->get('cart_keys', []);
  221.         $Cart = null;
  222.         if (count($cartKeys) > 0) {
  223.             foreach ($Carts as $cart) {
  224.                 if ($cart->getCartKey() === current($cartKeys)) {
  225.                     $Cart = $cart;
  226.                     break;
  227.                 }
  228.             }
  229.         } else {
  230.             $Cart = $Carts[0];
  231.         }
  233.         return $Cart;
  234.     }
  236.     /**
  237.      * @param CartItem[] $cartItems
  238.      *
  239.      * @return CartItem[]
  240.      */
  241.     protected function mergeAllCartItems($cartItems = [])
  242.     {
  243.         /** @var CartItem[] $allCartItems */
  244.         $allCartItems = [];
  246.         foreach ($this->getCarts() as $Cart) {
  247.             $allCartItems = $this->mergeCartItems($Cart->getCartItems(), $allCartItems);
  248.         }
  250.         return $this->mergeCartItems($cartItems, $allCartItems);
  251.     }
  253.     /**
  254.      * @param $cartItems
  255.      * @param $allCartItems
  256.      *
  257.      * @return array
  258.      */
  259.     protected function mergeCartItems($cartItems, $allCartItems)
  260.     {
  261.         foreach ($cartItems as $item) {
  262.             $itemExists = false;
  263.             foreach ($allCartItems as $itemInArray) {
  264.                 // 同じ明細があればマージする
  265.                 if ($this->cartItemComparator->compare($item, $itemInArray)) {
  266.                     $itemInArray->setQuantity($itemInArray->getQuantity() + $item->getQuantity());
  267.                     $itemExists = true;
  268.                     break;
  269.                 }
  270.             }
  271.             if (!$itemExists) {
  272.                 $allCartItems[] = $item;
  273.             }
  274.         }
  276.         return $allCartItems;
  277.     }
  279.     protected function restoreCarts($cartItems)
  280.     {
  281.         foreach ($this->getCarts() as $Cart) {
  282.             foreach ($Cart->getCartItems() as $i) {
  283.                 $this->entityManager->remove($i);
  284.                 $this->entityManager->flush();
  285.             }
  286.             $this->entityManager->remove($Cart);
  287.             $this->entityManager->flush();
  288.         }
  289.         $this->carts = [];
  291.         /** @var Cart[] $Carts */
  292.         $Carts = [];
  294.         foreach ($cartItems as $item) {
  295.             $allocatedId = $this->cartItemAllocator->allocate($item);
  296.             $cartKey = $this->createCartKey($allocatedId, $this->getUser());
  298.             if (isset($Carts[$cartKey])) {
  299.                 $Cart = $Carts[$cartKey];
  300.                 $Cart->addCartItem($item);
  301.                 $item->setCart($Cart);
  302.             } else {
  303.                 /** @var Cart $Cart */
  304.                 $Cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
  305.                 if ($Cart) {
  306.                     foreach ($Cart->getCartItems() as $i) {
  307.                         $this->entityManager->remove($i);
  308.                         $this->entityManager->flush();
  309.                     }
  310.                     $this->entityManager->remove($Cart);
  311.                     $this->entityManager->flush();
  312.                 }
  313.                 $Cart = new Cart();
  314.                 $Cart->setCartKey($cartKey);
  315.                 $Cart->addCartItem($item);
  316.                 $item->setCart($Cart);
  317.                 $Carts[$cartKey] = $Cart;
  318.             }
  319.         }
  321.         $this->carts = array_values($Carts);
  322.     }
  324.     /**
  325.      * カートに商品を追加します.
  326.      *
  327.      * @param $ProductClass ProductClass 商品規格
  328.      * @param $quantity int 数量
  329.      *
  330.      * @return bool 商品を追加できた場合はtrue
  331.      */
  332.     public function addProduct($ProductClass, $quantity = 1, $data = null)
  333.     {
  338.       log_info(
  339.         'カートに商品を追加します',
  340.         [
  341.             'ProductClass' => $ProductClass,
  342.             'data' => $data,
  343.         ]
  344.       );
  353.       if (!$ProductClass instanceof ProductClass) {
  354.             $ProductClassId = $ProductClass;
  355.             $ProductClass = $this->entityManager
  356.                 ->getRepository(ProductClass::class)
  357.                 ->find($ProductClassId);
  360.                 log_info(
  361.                   'カートに商品を追加します0',
  362.                   [
  363.                       'ProductClass' => is_null($ProductClass),
  364.                   ]
  365.                 );
  366.          
  367.         
  370.             if (is_null($ProductClass)) {
  371.                 return false;
  372.             }
  373.         }
  375.         log_info(
  376.           'カートに商品を追加します2',
  377.           [
  378.               'product_id' => $quantity,
  379.           ]
  380.         );
  381.  
  384.         $ClassCategory1 = $ProductClass->getClassCategory1();
  385.         if ($ClassCategory1 && !$ClassCategory1->isVisible()) {
  386.             return false;
  387.         }
  388.         $ClassCategory2 = $ProductClass->getClassCategory2();
  389.         if ($ClassCategory2 && !$ClassCategory2->isVisible()) {
  390.             return false;
  391.         }
  393.         log_info(
  394.           'カートに商品を追加します3',
  395.           [
  396.               'product_id' => $quantity,
  397.           ]
  398.         );
  399.   
  400.         $product_custom_delivery_date = new \DateTime($data['product_custom_delivery_date']);
  402.         $newItem = new CartItem();
  403.         $newItem->setQuantity($quantity);
  404.         $newItem->setProductClass($ProductClass);
  406.         if ($data) {
  408.           log_info(
  409.             'newItem->setPrice 1',
  410.             [
  411.                 'price' => $data['product_subtotal'],
  412.             ]
  413.           );
  415.           $newItem->setPrice((int)$data['product_subtotal']);
  416.           $newItem->setProduct_custom($data['product_custom']);
  417.           $newItem->setProduct_custom_data($data['product_custom']);
  418.           $newItem->setProductCustomDeliveryDate($product_custom_delivery_date);
  419.         } else {
  421.           log_info(
  422.             'newItem->setPrice 2',
  423.             [
  424.                 'price' => $ProductClass->getPrice02IncTax(),
  425.             ]
  426.           );
  429.           $newItem->setPrice($ProductClass->getPrice02IncTax());
  430.           $newItem->setProduct_custom('');
  431.           $newItem->setProduct_custom_data('');
  432.           $newItem->setProductCustomDeliveryDate(null);
  433.         }
  435.         log_info(
  436.           'カートに商品を追加します4',
  437.           [
  438.               'product_id' => $quantity,
  439.           ]
  440.         );
  442.         $allCartItems = $this->mergeAllCartItems([$newItem]);
  443.         $this->restoreCarts($allCartItems);
  445.         return true;
  446.     }
  448.     public function removeProduct($ProductClass)
  449.     {
  450.         if (!$ProductClass instanceof ProductClass) {
  451.             $ProductClassId = $ProductClass;
  452.             $ProductClass = $this->entityManager
  453.                 ->getRepository(ProductClass::class)
  454.                 ->find($ProductClassId);
  455.             if (is_null($ProductClass)) {
  456.                 return false;
  457.             }
  458.         }
  460.         $removeItem = new CartItem();
  461.         $removeItem->setPrice($ProductClass->getPrice02IncTax());
  462.         $removeItem->setProductClass($ProductClass);
  464.         $allCartItems = $this->mergeAllCartItems();
  465.         $foundIndex = -1;
  466.         foreach ($allCartItems as $index => $itemInCart) {
  467.             if ($this->cartItemComparator->compare($itemInCart, $removeItem)) {
  468.                 $foundIndex = $index;
  469.                 break;
  470.             }
  471.         }
  473.         array_splice($allCartItems, $foundIndex, 1);
  474.         $this->restoreCarts($allCartItems);
  476.         return true;
  477.     }
  479.     public function save()
  480.     {
  481.         $cartKeys = [];
  482.         foreach ($this->carts as $Cart) {
  483.             $Cart->setCustomer($this->getUser());
  484.             $this->entityManager->persist($Cart);
  485.             foreach ($Cart->getCartItems() as $item) {
  486.                 $this->entityManager->persist($item);
  487.             }
  488.             $this->entityManager->flush();
  489.             $cartKeys[] = $Cart->getCartKey();
  490.         }
  492.         $this->session->set('cart_keys', $cartKeys);
  494.         return;
  495.     }
  497.     /**
  498.      * @param  string $pre_order_id
  499.      *
  500.      * @return \Eccube\Service\CartService
  501.      */
  502.     public function setPreOrderId($pre_order_id)
  503.     {
  504.         $this->getCart()->setPreOrderId($pre_order_id);
  506.         return $this;
  507.     }
  509.     /**
  510.      * @return string|null
  511.      */
  512.     public function getPreOrderId()
  513.     {
  514.         $Cart = $this->getCart();
  515.         if (!empty($Cart)) {
  516.             return $Cart->getPreOrderId();
  517.         }
  519.         return null;
  520.     }
  522.     /**
  523.      * @return \Eccube\Service\CartService
  524.      */
  525.     public function clear()
  526.     {
  527.         $Carts = $this->getCarts();
  528.         if (!empty($Carts)) {
  529.             $removed = $this->getCart();
  530.             if ($removed && UnitOfWork::STATE_MANAGED === $this->entityManager->getUnitOfWork()->getEntityState($removed)) {
  531.                 $this->entityManager->remove($removed);
  532.                 $this->entityManager->flush();
  534.                 $cartKeys = [];
  535.                 foreach ($Carts as $key => $Cart) {
  536.                     // テーブルから削除されたカートを除外する
  537.                     if ($Cart == $removed) {
  538.                         unset($Carts[$key]);
  539.                     }
  540.                     $cartKeys[] = $Cart->getCartKey();
  541.                 }
  542.                 $this->session->set('cart_keys', $cartKeys);
  543.                 // 注文完了のカートキーをセッションから削除する
  544.                 $this->session->remove('cart_key');
  545.                 $this->carts = $this->cartRepository->findBy(['cart_key' => $cartKeys], ['id' => 'ASC']);
  546.             }
  547.         }
  549.         return $this;
  550.     }
  552.     /**
  553.      * @param CartItemComparator $cartItemComparator
  554.      */
  555.     public function setCartItemComparator($cartItemComparator)
  556.     {
  557.         $this->cartItemComparator = $cartItemComparator;
  558.     }
  560.     /**
  561.      * カートキーで指定したインデックスにあるカートを優先にする
  562.      *
  563.      * @param string $cartKey カートキー
  564.      */
  565.     public function setPrimary($cartKey)
  566.     {
  567.         $Carts = $this->getCarts();
  568.         $primary = $Carts[0];
  569.         $index = 0;
  570.         foreach ($Carts as $key => $Cart) {
  571.             if ($Cart->getCartKey() === $cartKey) {
  572.                 $index = $key;
  573.                 $primary = $Carts[$index];
  574.                 break;
  575.             }
  576.         }
  577.         $prev = $Carts[0];
  578.         array_splice($Carts, 0, 1, [$primary]);
  579.         array_splice($Carts, $index, 1, [$prev]);
  580.         $this->carts = $Carts;
  581.         $this->save();
  582.     }
  584.     protected function getUser()
  585.     {
  586.         if (null === $token = $this->tokenStorage->getToken()) {
  587.             return;
  588.         }
  590.         if (!is_object($user = $token->getUser())) {
  591.             // e.g. anonymous authentication
  592.             return;
  593.         }
  595.         return $user;
  596.     }
  598.     /**
  599.      * @param string $allocatedId
  600.      */
  601.     protected function createCartKey($allocatedId, Customer $Customer = null)
  602.     {
  603.         if ($Customer instanceof Customer) {
  604.             return $Customer->getId().'_'.$allocatedId;
  605.         }
  607.         if ($this->session->has('cart_key_prefix')) {
  608.             return $this->session->get('cart_key_prefix').'_'.$allocatedId;
  609.         }
  611.         do {
  612.             $random = StringUtil::random(32);
  613.             $cartKey = $random.'_'.$allocatedId;
  614.             $Cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
  615.         } while ($Cart);
  617.         $this->session->set('cart_key_prefix', $random);
  619.         return $cartKey;
  620.     }
  621. }