app/Customize/Service/CartService.php line 369

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of EC-CUBE
  4.  *
  5.  * Copyright(c) EC-CUBE CO.,LTD. All Rights Reserved.
  6.  *
  7.  * http://www.ec-cube.co.jp/
  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 Customize\Service;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Eccube\Entity\Cart;
  17. use Eccube\Entity\CartItem;
  18. use Eccube\Entity\ProductClass;
  19. use Eccube\Repository\CartRepository;
  20. use Eccube\Repository\CartItemRepository;
  21. use Eccube\Repository\OrderRepository;
  22. use Eccube\Repository\ProductClassRepository;
  23. use Eccube\Service\Cart\CartItemAllocator;
  24. use Eccube\Service\Cart\CartItemComparator;
  25. use Customize\Service\OrderHelper;
  26. use Eccube\Util\StringUtil;
  27. use Lm\Engine\EC\Entity\GoodsExtended;
  28. use Lm\Entity\Sku;
  29. use Lm\Service\Db\SqlService;
  30. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  31. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  32. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  33. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  34. use Symfony\Component\DependencyInjection\ContainerInterface;
  35. use Eccube\Common\EccubeConfig;
  37. class CartService extends \Eccube\Service\CartService
  38. {
  39.     const CartTypeNormal = 1; #通常
  40.     const CartTypeEstimate = 2; #見積シミュレーション
  41.     const CartTypeSample = 3; #サンプル
  42.     const CartTypeCatalog = 4; #カタログ
  43.     const CartTypeComposite = 9; #複合
  44.     const Estimate_Type_Print = 2; #プリント
  45.     const Estimate_Type_Susoage = 1; #裾上げ
  46.     const Session_ExclusionControlFlg = 'Session_ExclusionControlFlg';
  47.     const Matrix_name = 'product_matrix';
  48.     const DummyEstimateId = 'xx';
  49.     const CartTypeRepeat = '101'; #リピート時　カートに商品がある
  50.     const RepeatError01 = 'RepeatError01';
  51.     const RepeatError02 = 'RepeatError02';
  52.     const RepeatError03 = 'RepeatError03';
  54.     const SaveCartType = 'Session_SaveCartType';
  56.     /**
  57.      * ルーティング名 - 「カートに入れる」関連
  58.      */
  59.     const ROUTE_ADD_NORMAL = 'add_Normal';
  60.     const ROUTE_VALID_ESTIMATE = 'valid_estimate';
  61.     const ROUTE_ADD_ESTIMATE = 'add_estimate';
  62.     const ROUTE_ADD_SAMPLE = 'add_sample';
  63.     const ROUTE_ADD_CATALOG = 'add_catalog';
  64.     const ROUTE_ADD_LINE = 'add_line';
  65.     const ROUTE_ADD_HYBRID = 'add_hybrid';
  66.     const ROUTE_ADD_REPEAT = 'add_repeat';
  68.     /**
  69.      * Case can mix susoage and print:
  70.      * Option 1:
  71.      * 伝票1 BILL_1 = Type 1 (normal) + Kyoei (type 1 normal) + Type 1 (reservation) + Kyoei (type 1 reservation) + susoage (normal + reservation)
  72.      * 伝票2 BILL_2 = Print (type 2 normal + reservation)
  73.      * 伝票3 BILL_3 = Kyoei (type 2 normal + reservation)
  74.      *  Option 2:
  75.      * 伝票1 BILL_1 = Type 1 (normal) + Kyoei (type 1 normal)
  76.      * 伝票2 BILL_2 = Print (type 2 normal + reservation)
  77.      * 伝票3 BILL_3 = Kyoei (type 2 normal + reservation)
  78.      * 伝票4 BILL_4 = Type 1 (reservation) + Kyoei (type 1 reservation) + susoage (normal + reservation)
  79.     */
  80.     const BILL_1 = "BILL_1";
  81.     const BILL_2 = "BILL_2";
  82.     const BILL_3 = "BILL_3";
  83.     const BILL_4 = "BILL_4";
  85.     const GROUP_NORMAL = 'GROUP_1_NORMAL';
  86.     const GROUP_RESERVATION = 'GROUP_2_RESERVATION';
  87.     const GROUP_KYOUEI_WITH_NAIRE_PRINT = 'GROUP_3_KYOUEI';
  89.     const SESSION_BULK_CHECKOUT_ENABLED = 'cart.bulk_checkout.enabled';
  91.     protected $GoodsService;
  92.     protected $orderHelper;
  94.     protected $CartType = 0;
  95.     protected $Quantitys;
  96.     protected $EstimateId = 0; #見積ID
  97.     protected $Container;
  98.     protected $MergeFlg = true; #商品が追加された場合　マージか　アッドか？
  100.     protected $CartItemRepository;
  101.     protected $ProductClass = [];
  102.     protected $NewItems = [];
  103.     protected $ValidationData = [];
  104.     protected $CartItemIds = [];
  105.     protected $Estimates;
  106.     protected $EstimateOption = [];
  107.     protected $EccubeConfig;
  109.     /**
  110.      * @var array
  111.      */
  112.     protected $_buffer;
  114.     public function __construct(
  115.         SessionInterface              $session,
  116.         EntityManagerInterface        $entityManager,
  117.         ProductClassRepository        $productClassRepository,
  118.         CartRepository                $cartRepository,
  119.         CartItemComparator            $cartItemComparator,
  120.         CartItemAllocator             $cartItemAllocator,
  121.         OrderRepository               $orderRepository,
  122.         TokenStorageInterface         $tokenStorage,
  123.         AuthorizationCheckerInterface $authorizationChecker,
  124.         ContainerInterface            $Container,
  125.         CartItemRepository            $CartItemRepository,
  126.         EccubeConfig                  $EccubeConfig,
  127.         GoodsService                  $GoodsService,
  128.         OrderHelper                   $orderHelper
  129.     )
  130.     {
  131.         //
  132.         parent::__construct($session, $entityManager, $productClassRepository, $cartRepository, $cartItemComparator, $cartItemAllocator, $orderRepository, $tokenStorage, $authorizationChecker);
  133.         //
  134.         $this->Container = $Container;
  135.         $this->CartItemRepository = $CartItemRepository;
  136.         $this->EccubeConfig = $EccubeConfig;
  137.         $this->orderHelper = $orderHelper;
  138.     }
  140.     /**
  141.      * カートに商品を追加します.
  142.      * @param int $ProductClass 商品規格
  143.      * @param int $quantity 数量
  144.      * @param false|bool $noOptions
  145.      * @return bool 商品を追加できた場合はtrue
  146.      */
  147.     public function addProduct($ProductClass, $quantity = 1, $noOptions = false)
  148.     {
  149.         if (!$ProductClass instanceof ProductClass) {
  150.             $ProductClassId = $ProductClass;
  151.             $ProductClass = $this->entityManager
  152.                 ->getRepository(ProductClass::class)
  153.                 ->find($ProductClassId);
  154.             if (is_null($ProductClass)) {
  155.                 return false;
  157.             }
  158.         }
  159.         // use logic calculator in cart, and set for new Order
  160.         $ClassCategory1 = $ProductClass->getClassCategory1();
  161.         $Patan = $this->EccubeConfig['ESTIMATE_WHOIT_ONLY'];
  163.         if (!preg_match($Patan, $ClassCategory1->getBackendname()) && !empty($this->Estimates)) {
  164.             $optionObject = json_decode($this->Estimates,true);
  165.             $optionObject["white_only"] = 2;
  166.             $this->SetEstimates($optionObject);
  167.         }
  169.         if ($ClassCategory1 && !$ClassCategory1->isVisible()) {
  170.             return false;
  171.         }
  172.         $ClassCategory2 = $ProductClass->getClassCategory2();
  173.         if ($ClassCategory2 && !$ClassCategory2->isVisible()) {
  174.             return false;
  175.         }
  177.         $newItem = new CartItem();
  178.         $newItem->setQuantity($quantity);
  179.         $newItem->setPrice($ProductClass->getPrice02IncTax());
  180.         $newItem->setProductClass($ProductClass);
  181.         //
  182.         if (!$noOptions) {
  183.             $newItem->setOptions($this->Estimates);
  184.         }
  186.         #見積もりIDの追加
  187.         $this->SetEstimateId();
  188.         $newItem->setEstimateId($this->EstimateId);
  190.         $allCartItems = $this->mergeAllCartItems_2([$newItem]);
  193.         $this->restoreCarts($allCartItems);
  195.         return true;
  196.     }
  198.     /**
  199.      * @param CartItem[] $cartItems
  200.      *
  201.      * @return CartItem[]
  202.      *
  203.      * mergeCartItemsを2回読んでいるが
  204.      * 1度目は　$allCartItems　が空の配列なので　Cart->getCartItems()を$allCartItems　へ置き換えているだけ
  205.      * 2度目は　$allCartItems== 　Cart->getCartItems() で　2度目で始めたマージしている
  206.      * クーロンすれば　？
  207.      */
  208.     protected function mergeAllCartItems_2($cartItems = [])
  209.     {
  210.         /** @var CartItem[] $allCartItems */
  212.         //$allCartItems=[];
  213.         /**
  214.          * @var Object $allCartItems
  215.          */
  216.         $allCartItems = count($this->getCarts()) > 0 ? [] : (object)$cartItems;
  218.         foreach ($this->getCarts() as $Cart) {
  220.             // $allCartItems = $this->mergeCartItems($Cart->getCartItems(), $allCartItems);
  221.             $allCartItems = $this->mergeCartItems_2($cartItems, $Cart->getCartItems());
  222.         }
  223.         return clone $allCartItems;
  224.         // return $this->mergeCartItems($cartItems, $allCartItems);
  225.     }
  227.     /**
  228.      * @param $cartItems
  229.      * @param $allCartItems
  230.      *
  231.      * @return array
  232.      */
  233.     protected function mergeCartItems_2($cartItems, $allCartItems)
  234.     {
  235.         foreach ($cartItems as $item) {
  236.             $itemExists = false;
  238.             foreach ($allCartItems as $i => $itemInArray) {
  240.                 if (0 != $itemInArray->getEstimateId()) {
  241.                     continue;
  242.                 }
  243.                 // 同じ明細があればマージする
  244.                 if ($this->cartItemComparator->compare($item, $itemInArray) && $this->MergeFlg) {
  245.                     $itemInArray->setQuantity($itemInArray->getQuantity() + $item->getQuantity());
  246.                     $itemExists = true;
  247.                     break;
  248.                 }
  249.             }
  250.             if (!$itemExists) {
  252.                 $allCartItems[] = $item;
  253.             }
  254.         }
  255.         return $allCartItems;
  256.     }
  258.     /**
  259.      * カートを更新します。
  260.      *
  261.      * @param $CartItemId int CartItem ID
  262.      * @param $ProductClass ProductClass 商品規格
  263.      * @param $quantity int 数量
  264.      * @param $options text オプション（見積りシミュレーションの結果、など）
  265.      *
  266.      * @return bool 商品を追加できた場合はtrue
  267.      */
  268.     public function updateCartItem($CartItemId, $ProductClass, $quantity = 1, $options = "")
  269.     {
  270.         if (!$ProductClass instanceof ProductClass) {
  271.             $ProductClassId = $ProductClass;
  272.             $ProductClass = $this->entityManager
  273.                 ->getRepository(ProductClass::class)
  274.                 ->find($ProductClassId);
  275.             if (is_null($ProductClass)) {
  276.                 return false;
  277.             }
  278.         }
  280.         $ClassCategory1 = $ProductClass->getClassCategory1();
  281.         if ($ClassCategory1 && !$ClassCategory1->isVisible()) {
  282.             return false;
  283.         }
  284.         $ClassCategory2 = $ProductClass->getClassCategory2();
  285.         if ($ClassCategory2 && !$ClassCategory2->isVisible()) {
  286.             return false;
  287.         }
  289.         $newItem = new CartItem();
  290.         $newItem->setQuantity($quantity);
  291.         $newItem->setPrice($ProductClass->getPrice02IncTax());
  292.         $newItem->setProductClass($ProductClass);
  293.         $newItem->setOptions($options);
  295.         $allCartItems = $this->mergeAllCartItems([$newItem]);
  296.         $this->restoreCarts($allCartItems);
  298.         return true;
  299.     }
  301.     /**
  302.      * EC-CUBEのカートデータを旧UTのカートデータに変換する
  303.      *
  304.      * @return array
  305.      * [
  306.      *   'cart' => [],
  307.      *   'tmp_cart' => [],
  308.      * ]
  309.      */
  310.     public function convertToLmCart()
  311.     {
  312.         $carts = $this->getCart();
  313.         $lmCart = [];
  314.         foreach ($carts as $key => $value) {
  315.             if ($key === 'hoge') {
  316.                 $lmCart['cart']['piyo'] = $value;
  317.             } else if ($key === 'piyo') {
  318.                 $lmCart['tmp_cart']['piyo'] = $value;
  319.             }
  320.         }
  321.         return $lmCart;
  322.     }
  324.     public function save()
  325.     {
  326.         $cartKeys = [];
  327.         foreach ($this->carts as $Cart) {
  328.             $Tatal = 0;
  329.             $Cart->setCustomer($this->getUser());
  331.             if (is_null($Cart->getDeliveryFeeTotal())) {
  332.                 $Cart->setDeliveryFeeTotal(0);
  333.             }
  335.             #2022/10/20 カートタイプを登録する 修正
  336.             if ($this->CartType) {
  337.                 $CartType = $this->CartType == self::CartTypeComposite ? self::CartTypeEstimate : $this->CartType;
  338.                 if ($Cart->getCartType() != $CartType) {
  339.                     $Cart->setCartType($CartType);
  340.                 }
  341.             }
  343.             $this->entityManager->persist($Cart);
  345.             foreach ($Cart->getCartItems() as $item) {
  346.                 $Tatal += $item->getPrice() * $item->getQuantity();
  347.                 $this->entityManager->persist($item);
  348.             }
  349.             if (is_null($Cart->getTotalPrice())) {
  350.                 $Cart->setTotalPrice($Tatal);
  351.             }
  353.             try {
  354.                 if (empty($Cart->CartType) || $Cart->CartType == 'null'){
  355.                     log_debug("[LM]Create Cart empty cart_type: CartInfo", [
  356.                         "Cart" => $Cart,
  357.                         "CartItem" => $Cart->getCartItems()
  358.                     ]);
  359.                 }
  360.             } catch (\Exception $exception){
  361.                 log_error("[LM]Create Cart EMPTY cart_type ERROR-  " . $exception->getMessage());
  362.             }
  365.             $this->entityManager->flush();
  366.             $cartKeys[] = $Cart->getCartKey();
  367.         }
  369.         $this->session->set('cart_keys', $cartKeys);
  371.         return;
  372.     }
  374.     protected function restoreCarts($cartItems)
  375.     {
  376.         foreach ($this->getCarts() as $Cart) {
  378.             foreach ($Cart->getCartItems() as $i) {
  379.                 $this->entityManager->remove($i);
  380.                 $this->entityManager->flush();
  381.             }
  383.             $this->entityManager->remove($Cart);
  384.             $this->entityManager->flush();
  385.         }
  387.         $this->carts = [];
  389.         /** @var Cart[] $Carts */
  390.         $Carts = [];
  392.         foreach ($cartItems as $item) {
  393.             $allocatedId = $this->cartItemAllocator->allocate($item);
  394.             $cartKey = $this->createCartKey($allocatedId, $this->getUser());
  396.             if (isset($Carts[$cartKey])) {
  397.                 $Cart = $Carts[$cartKey];
  398.                 $Cart->addCartItem($item);
  399.                 #2022/03/28 カートタイプを登録する 4/7修正
  400. #                if($this->CartType){
  401. #                    $Cart->setCartType($this->CartType);
  402. #                }
  403.                 $item->setCart($Cart);
  404.             } else {
  405.                 #/ ** @var Cart $Cart * /
  406.                 $Cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
  407.                 if ($Cart) {
  408.                     foreach ($Cart->getCartItems() as $i) {
  409.                         $this->entityManager->remove($i);
  410.                         $this->entityManager->flush();
  411.                     }
  412.                     $this->entityManager->remove($Cart);
  413.                     $this->entityManager->flush();
  414.                 }
  415.                 $Cart = new Cart();
  416.                 $Cart->setCartKey($cartKey);
  417.                 $Cart->addCartItem($item);
  418.                 #2022/03/28 カートタイプを登録する 4/7修正
  419. #                if($this->CartType){
  420. #                    $Cart->setCartType($this->CartType);
  421. #                }
  422.                 $item->setCart($Cart);
  423.                 $Carts[$cartKey] = $Cart;
  424.             }
  426.         }
  428.         $this->carts = array_values($Carts);
  429.     }
  431.     /**
  432.      * 2022/06/16 tkgoya
  433.      *
  434.      * @return int|void
  435.      */
  436.     public function GetCartType($Flg = false)
  437.     {
  438.         //
  439.         //return $this->CartHelper->GetCartType($Flg);
  440.         $Carts = $this->getCarts();
  441.         if (count($Carts) < 1) {
  442.             return $Flg ?? $this->session->get(self::SaveCartType) ?? 0;
  443.         }
  444.         foreach ($Carts as $Cart) {
  445.             $this->session->set(self::SaveCartType, $Cart->getCartType());
  446.             return $Cart->getCartType();
  447.         }
  448.     }
  450.     /**
  451.      * 2022/03/28 Kakeru
  452.      *
  453.      * @param int $CartType
  454.      *
  455.      */
  456.     public function SetCartType($CartType)
  457.     {
  458.         if ($this->CartType == $CartType) {
  459.             return;
  460.         }
  462.         $this->CartType = $CartType;
  463.         /*foreach ($this->getCarts() as $Cart) {
  464.             $Cart->setCartType($CartType);
  465.             $this->entityManager->persist($Cart);
  466.             $this->entityManager->flush();
  467.         }*/
  468.     }
  470.     /** 20220409
  471.      * 会員が保持する永続化されたカートと、非会員時のカートをマージする.
  472.      * 2022/07 カートに商品がある場合は前回の商品はマージしない
  473.      */
  474.     public function mergeFromPersistedCart()
  475.     {
  477.         $sessionCarts = $this->getSessionCarts();
  478.         $persistedCarts = [];
  479.         if (count($sessionCarts) < 1) {
  480.             $persistedCarts = $this->getPersistedCarts();
  481.         }
  483.         $CartItems = [];
  485.         // 永続化されたカートとセッションのカートが同一の場合はマージしない #4574
  486.         $cartKeys = $this->session->get('cart_keys', []);
  488.         if ((count($persistedCarts) > 0) && !in_array($persistedCarts[0]->getCartKey(), $cartKeys, true)) {
  489.             foreach ($persistedCarts as $Cart) {
  490.                 $this->CartType = $Cart->getCartType();
  491.                 $CartItems = $this->mergeCartItems($Cart->getCartItems(), $CartItems);
  492.             }
  493.         }
  495.         // セッションにある非会員カートとDBから取得した会員カートをマージする.
  496.         foreach ($sessionCarts as $Cart) {
  497.             $this->CartType = $Cart->getCartType();
  498.             $CartItems = $this->mergeCartItems($Cart->getCartItems(), $CartItems);
  499.         }
  501.         $this->restoreCarts($CartItems);
  502.     }
  504.     /**
  505.      * カートの合計数を　ClassId で取得する
  506.      *
  507.      * @param int $ClassId
  508.      *
  509.      * @return int $Quantity
  510.      */
  511.     public function getQuantitys($ClassId)
  512.     {
  514.         if (!$this->Quantitys) {
  516.             if (!$Carts = $this->getCarts()) {
  517.                 return 0;
  518.             };
  519.             foreach ($Carts as $Cart) {
  520.                 if (!$Items = $Cart->getItems()) {
  521.                     return 0;
  522.                 }
  523.                 foreach ($Items as $Item) {
  524.                     if (!$Item->isProduct()) {
  525.                         continue;
  526.                     }
  528.                     $Class = $Item->getProductClass();
  529.                     $Id = $Class->getId();
  531.                     $this->Quantitys[$Id] = $this->Quantitys[$Id] ?? 0;
  532.                     $this->Quantitys[$Id] += $Item->getQuantity();
  534.                 }
  535.             }
  536.         }
  537.         return $this->Quantitys[$ClassId] ?? 0;
  538.     }
  540.     /**
  541.      * EstimateIdの設定
  542.      *
  543.      *
  544.      */
  545.     public function SetEstimateId($Id = null)
  546.     {
  547.         if ($Id) {
  548.             $this->EstimateId = $Id;
  549.             return;
  550.         }
  551.         # 1  通常と加工の混在
  552.         if ($this->CartType == self::CartTypeComposite) {
  553. # 10/20     $this->CartType =  self::CartTypeNormal;
  554.             $this->EstimateId = 0;
  555.             return;
  556.         }
  557.         #加工でなければ
  558.         if ($this->CartType != self::CartTypeEstimate) {
  559.             return;
  560.         }
  562.         #3 既に設定している
  563.         if ($this->EstimateId !== 0) {
  564.             return;
  565.         }
  567.         #4EstimateIdの作成
  568.         $this->MergeFlg = false;
  571.         $this->EstimateId = $this->getMaxEstimateId() + 1;
  572.         return;
  574.     }
  576.     public function getMaxEstimateId()
  577.     {
  578.         $em = $this->Container->get('doctrine.orm.entity_manager');
  579.         $Qb = $em->createQueryBuilder();
  580.         $MaxEstimateId = $Qb
  581.             ->select('COALESCE(MAX(CI.EstimateId), 0)')
  582.             ->from("Eccube\\Entity\\CartItem", 'CI')
  583.             ->getQuery()
  584.             ->getSingleResult();
  586.         return $MaxEstimateId[1] ?? 0;
  587.     }
  589.     /**
  590.      * GetEstimateId を返す
  591.      * @return int $this->EstimateId;
  592.      */
  593.     public function GetEstimateId()
  594.     {
  595.         return $this->EstimateId;
  596.     }
  598.     public function getLmCartItems()
  599.     {
  600.         #カートが空なら
  601.         if (count($this->carts) < 1) {
  602.             return [];
  603.         }
  604.         $Cart = $this->carts[0];
  606.         #カタログなら
  607.         if ($Cart->getCartType() == self::CartTypeCatalog) {
  608.             return [];
  609.         }
  611.         $em = $this->Container->get('doctrine.orm.entity_manager');
  612.         $Qb = $em->createQueryBuilder();
  614.         $Items = $Qb
  615.             ->select('CI')
  616.             ->from("Eccube\\Entity\\CartItem", 'CI')
  617.             ->innerJoin('CI.ProductClass', 'pc')
  618.             ->orderBy('pc.Product', 'ASC')
  619.             ->addOrderBy('CI.EstimateId', 'ASC')
  620.             ->addOrderBy('CI.id', 'ASC')
  621.             ->where('CI.Cart = :cart')
  622.             ->setParameter('cart', $Cart)
  623.             ->getQuery()
  624.             ->getResult();
  626.         $Cart->setCartItems($Items);
  628.         return;
  629.     }
  631.     public function GetProductClass($ProductClassId)
  632.     {
  634.         if (isset($this->ProductClass[$ProductClassId])) {
  635.             return $this->ProductClass[$ProductClassId];
  636.         }
  638.         $this->ProductClass[$ProductClassId] = $this->entityManager
  639.             ->getRepository(ProductClass::class)
  640.             ->find($ProductClassId);
  642.         return $this->ProductClass[$ProductClassId];
  643.     }
  645.     /**
  646.      * @param int $CartItemId
  647.      * @return $this
  648.      */
  649.     public function RemoveItem($CartItemId)
  650.     {
  651.         $this->CartType = $this->GetCartType();
  653.         $CartItems = [];
  654.         $Flg = true;
  655.         $productClassIdDeleted = '';
  656.         $estimateIdDeleted = '';
  657.         foreach ($this->getCarts() as $Cart) {
  658.             foreach ($Cart->getCartItems() as $CartItem) {
  659.                 if ($CartItemId == $CartItem->getId()) {
  660.                     $productClassIdDeleted = $CartItem->getProductClass()->getId()??'';
  661.                     $estimateIdDeleted = $CartItem->getEstimateId();
  662.                 }
  663.             }
  664.             foreach ($Cart->getCartItems() as $CartItem) {
  665.                 if ($CartItemId == $CartItem->getId()) {
  666.                     continue;
  667.                 }
  668.                 $cartItemOptions = $CartItem->getOptions();
  669.                 $cartItemOptions = json_decode($cartItemOptions,true);
  670.                 if($CartItem->getEstimateId() == $estimateIdDeleted && isset($cartItemOptions['susoage']) && is_array($cartItemOptions['susoage'])){
  671.                     if(isset($cartItemOptions['susoage'][$productClassIdDeleted]) && is_array($cartItemOptions['susoage'][$productClassIdDeleted])){
  672.                         foreach ($cartItemOptions['susoage'][$productClassIdDeleted] as &$item){
  673.                             $item['do'] = 0;
  674.                         }
  675.                     }
  676.                 }
  677.                 $cartItemOptions = $cartItemOptions ? json_encode($cartItemOptions) : null;
  678.                 if (!empty($cartItemOptions)) {
  679.                     $this->SetEstimateOption($CartItem->getEstimateId(), $CartItem->getProductClass(), $CartItem->getQuantity(), $cartItemOptions);
  680.                 }
  681.                 $CartItems[] = clone $CartItem;
  682.                 if ($CartItem->getEstimateId()) {
  683.                     $Flg = false;
  684.                 }
  685.             }
  686.         }
  688.         #加工と　通常混在の場合　加工を削除すると　
  689.         if ($this->CartType == self::CartTypeEstimate && $Flg) {
  690.             $this->CartType = self::CartTypeNormal;
  691.         }
  693.         $this->restoreCarts($CartItems);
  694.         $this->save();
  696.         return $this;
  697.     }
  699.     /**
  700.      * カートにてDATaの追加変更を行う
  701.      * @param $Datas
  702.      */
  703.     public function AddCartLine($Datas)
  704.     {
  705.         $Items = [];
  706.         $Options = [];
  708.         foreach ($this->getCarts() as $Cart) {
  709.             $this->CartType = $Cart->getCartType();
  710.             foreach ($Cart->getCartItems() as $Item) {
  711.                 $Items[$Item->getId()] = $Item;
  712. //                $Options[$Item->getEstimateId()] = $Item->getOptions();
  713.             }
  714.         }
  716.         $Errors = [];
  717.         $AddLineFlg = false;
  718.         foreach ($Datas as $EstimateId => $Data) {
  719.             $Options = null;
  720.             foreach ($Data as $ItemId => $Product) {
  722.                 $ProductClass = null;
  723.                 if (is_numeric($ItemId)) {
  724.                     $Item = $Items[$ItemId] ?? null; # もしエラーなら
  725.                     if($Item != null){
  726.                         if ($ProductClass = $Item->getProductClass()) { #もしえらーなら　下記もエラー
  727.                             $ClassCategory1 = $ProductClass->getClassCategory1();
  728.                             $ClassCategory2 = $ProductClass->getClassCategory2();
  729.                         }
  730.                         $Options = $Item->getOptions();
  731.                     } else {
  732.                         $Options = null;
  733.                     }
  735.                     switch (true) {
  737.                         case !$Item || !$ProductClass:
  738.                             $Errors[0] = 13;
  739.                             break;
  740.                         #内容が同じなら
  741.                         case $ClassCategory1->getId() == $Product['color']
  742.                             && $ClassCategory2->getId() == $Product['size']
  743.                             && $Item->getQuantity() == $Product['quantity']:
  745.                             $this->AddValidationData($ProductClass, $Product['quantity']);
  746.                             $this->NewItems[] = clone $Item;
  747.                             break;
  748.                         default :
  749.                             $AddLineFlg = true;
  750.                             if (0 == $Product['quantity']) {
  751.                                 $Errors[$ProductClass->getId()] = 8;
  752.                             }
  753.                             $ProductClass = $this->AddNewItem($Product, $EstimateId, $Options);
  754.                             break;
  756.                     }
  757.                     #新規套路
  758.                 } else {
  759.                     if ($Product['quantity']) {
  760.                         if (is_numeric($Product['quantity'])) {
  761.                             $Ids = explode('-', $ItemId);
  762.                             $Product['product'] = $Ids[1] ?? null;
  763.                             $AddLineFlg = true;
  764.                             $ProductClass = $this->AddNewItem($Product, $EstimateId, $Options, $ItemId);
  766.                         } else {
  767.                             $Errors[$ItemId] = 4;
  768.                         }
  769.                     }
  770.                 }
  771.                 #2022/09/09 見積シミュレーション　options 内容変更
  772.                 if (!empty($Options)) {
  773.                     $this->SetEstimateOption($EstimateId, $ProductClass, $Product['quantity'], $Options);
  774.                 }
  775.             }
  776.         }
  777.         if (!$AddLineFlg) {
  778.             $Errors[0] = 14;
  779.         }
  780.         return [$this->ValidationData, $Errors];
  781.     }
  783.     protected function AddNewItem($Product, $EstimateId, $Options, $ItemId = null)
  784.     {
  785.         $ProductId = $Product['product'];
  786.         $ClassCategoryId1 = $Product['color'];
  787.         $ClassCategoryId2 = $Product['size'];
  788.         $Quantity = $Product['quantity'];
  791.         $ProductClass = $this->productClassRepository->findOneBy(['Product' => $ProductId,
  792.             'ClassCategory1' => $ClassCategoryId1,
  793.             'ClassCategory2' => $ClassCategoryId2,
  794.         ]);
  795. #            echo $ProductId.':'. $ClassCategoryId1 .';'. $ClassCategoryId2;
  796. #            echo gettype($ProductClass);
  797.         #キャッシュとバリデーションDATA　保存
  798.         if ($ProductClass) {
  799.             $this->AddValidationData($ProductClass, $Product['quantity']);
  800.         }
  801.         #追加アイテムの保存
  802.         if ($ItemId) {
  803.             $this->CartItemIds[$ProductClass->getId()][] = $ItemId;
  804.         }
  806.         $newItem = new CartItem();
  807.         $newItem->setQuantity($Quantity)
  808.             ->setPrice($ProductClass->getPrice02IncTax())
  809.             ->setProductClass($ProductClass)
  810.             ->setOptions($Options)
  811.             ->setEstimateId($EstimateId);
  813.         $this->NewItems[] = $newItem;
  814.         return $ProductClass;
  815.     }
  817.     /*
  818.     * 行の追加で　同じEstimateIde で　同じProductId で　同じ　ProductClassId の場合マージする
  819.     *
  820.     */
  821.     protected function MergeNewItem()
  822.     {
  823.         $NewItems = [];
  825.         foreach ($this->NewItems as $Item) {
  826.             $ProductClass = $Item->getProductClass();
  827.             $Product = $ProductClass->getProduct();
  828.             $EstimateId = $Item->getEstimateId();
  829.             $ProductId = $Product->getId();
  830.             $ProductClassId = $ProductClass->getId();
  832.             if (isset($NewItems[$EstimateId][$ProductId][$ProductClassId])) {
  833.                 $Quantity = $NewItems[$EstimateId][$ProductId][$ProductClassId]->getQuantity() + $Item->getQuantity();
  834.                 $NewItems[$EstimateId][$ProductId][$ProductClassId]->setQuantity($Quantity);
  835.             } else {
  836.                 $NewItems[$EstimateId][$ProductId][$ProductClassId] = $Item;
  837.             }
  838.         }
  839.         $ReNewItem = [];
  840.         foreach ($NewItems as $EstimateId => $Product) {
  841.             foreach ($Product as $ProductId => $ProductClass) {
  842.                 foreach ($ProductClass as $ProductClassId => $Item)
  843.                     $ReNewItem[] = $Item;
  844.             }
  845.         }
  847.         $goodsColorKeys = array_map(function ($item) {
  848.             /**
  849.              * @var CartItem $item
  850.              */
  851.             return $item->getProductClass()->getJancode()->getGoodsColor()->getGclDisplay();
  852.         }, $ReNewItem);
  854.         $goodsSizeKeys = array_map(function ($item) {
  855.             /**
  856.              * @var CartItem $item
  857.              */
  858.             return $item->getProductClass()->getJancode()->getGoodsPrice()->getGpDisplay();
  859.         }, $ReNewItem);
  861.         array_multisort($goodsColorKeys, SORT_ASC, SORT_NUMERIC,
  862.             $goodsSizeKeys, SORT_ASC, SORT_NUMERIC,
  863.             $ReNewItem
  864.         );
  866.         return $ReNewItem;
  867.     }
  869.     public function MakeValidationData()
  870.     {
  871.         $CartType = null;
  872.         foreach ($this->getCarts() as $Cart) {
  873.             $CartType = $Cart->getCartType();
  874.             foreach ($Cart->getCartItems() as $Item) {
  875.                 $ProductClass = $Item->getProductClass();
  876.                 if ($ProductClass) {
  877.                     $this->AddValidationData($ProductClass, $Item->getQuantity());
  878.                 }
  879.             }
  880.         }
  881.         return [$CartType, $this->ValidationData];
  882.     }
  884.     protected function AddValidationData($ProductClass, $Quantity)
  885.     {
  886.         #キャッシュ
  887.         $this->ProductClass[$ProductClass->getId()] = $ProductClass;
  888.         $ClassId = $ProductClass->getId();
  889.         if (isset($this->ValidationData[$ClassId])) {
  890.             $this->ValidationData[$ClassId] += $Quantity;
  891.         } else {
  892.             $this->ValidationData[$ClassId] = $Quantity;
  893.         }
  894.     }
  896.     /**
  897.      *  マトリックスからのDATを　コンバートする
  898.      *
  899.      *
  900.      */
  901.     public function CartItemConv($Products)
  902.     {
  903.         if (!$Products) {
  904.             return null;
  905.         }
  906.         $ReProducts = [];
  907.         foreach ($Products as $ClassId => $Quantity) {
  908.             if (!$Quantity) {
  909.                 continue;
  910.             }
  911.             #ここでDATAのコンバートをする
  912.             #1 2バイト文字をIバイト文字に変換
  913.             $Quantity = mb_convert_kana($Quantity, 'n');
  915.             $ReProducts[$ClassId] = $Quantity;
  916.         }
  917.         return $ReProducts;
  918.     }
  920.     public function convertProductsForSetPurchase($Products)
  921.     {
  922.         //
  923.         $janIdList = array_keys($Products);
  924.         //
  925.         $janIdListCsv = implode(',', $janIdList);
  926.         $sql = "SELECT
  927.                     T1.jan_id
  928.                 ,   T.goods_id
  929.                 ,   T.goods_set_purchase_flg
  930.                 ,   GROUP_CONCAT(DISTINCT T6.jan_id ORDER BY T2.gsp_type SEPARATOR ',') AS `child_jan_id_list`
  931.                 FROM goods_table AS T
  932.                 INNER Join jancode_table AS T1 ON T.goods_id = T1.jan_goods
  933.                 LEFT JOIN goods_set_purchase_table AS T2 ON T.goods_id = T2.gsp_goods_parent
  934.                 LEFT JOIN goods_table AS T3 ON T3.goods_id = T2.gsp_goods_child
  935.                 LEFT JOIN gsp_gcl_table AS T4 ON T4.gsp_gcl_parent = T1.jan_color
  936.                 LEFT JOIN gsp_gp_table AS T5 ON T5.gsp_gp_parent = T1.jan_price
  937.                 LEFT JOIN jancode_table AS T6 ON T3.goods_id = T6.jan_goods AND (T6.jan_color, T6.jan_price) IN ((T4.gsp_gcl_main, T5.gsp_gp_main), (T4.gsp_gcl_sub, T5.gsp_gp_sub), (T4.gsp_gcl_other, T5.gsp_gp_other))
  938.                 WHERE T1.jan_id IN ($janIdListCsv)
  939.                 GROUP By T.goods_id, T1.jan_id
  940.                 ORDER By T.goods_id, T1.jan_id
  941.                 ";
  942.         //
  943.         $result = (new SqlService())
  944.             ->Sql($sql)
  945.             ->FetchAll();
  946.         //
  947.         $_Products = [];
  948.         //
  949.         foreach ($result as $jan) {
  950.             //
  951.             $parentJanId = $jan['jan_id'];
  952.             $quantity = $Products[$parentJanId];
  953.             //
  954.             if ($jan['goods_set_purchase_flg'] == 1 && ($childJanIdList = explode(',', $jan['child_jan_id_list']))) {
  955.                 //
  956.                 foreach ($childJanIdList as $childJanId) {
  957.                     //
  958.                     $_Products[$childJanId] = ($_Products[$childJanId] ?? 0) + $quantity;
  959.                 }
  960.             } else {
  961.                 $_Products[$parentJanId] = ($_Products[$parentJanId] ?? 0) + $quantity;
  962.             }
  963.         }
  964.         //
  965.         return $_Products;
  966.     }
  968.     /**
  969.      *
  970.      *
  971.      */
  972.     public function AddProducts()
  973.     {
  974.         $NewItems = $this->MergeNewItem();
  975.         $this->restoreCarts($NewItems);
  976.     }
  978.     /**
  979.      *  AddLine で　追加分のDATAを返す
  980.      *　@param int $ProductClassId
  981.      *
  982.      * @return array()
  983.      */
  985.     public function GetAddlines($ProductClassId)
  986.     {
  987.         if (!$this->CartItemIds) {
  988.             return null;
  989.         } #不要？
  991.         return $this->CartItemIds[$ProductClassId] ?? null;
  992.     }
  994.     /**
  995.      *  $Estimates 見積DATAを格納する
  996.      *　@param $Estimates
  997.      *
  998.      */
  999.     public function SetEstimates($Estimates)
  1000.     {
  1001.         if ($Estimates) {
  1002.             $this->Estimates = json_encode($Estimates);
  1003.         }
  1004.     }
  1006.     /**
  1007.      *  見積もりシミュレーション　ハイブリット 戻り値の登録
  1008.      *
  1009.      */
  1010.     public function SetHybrid($CartItemId)
  1011.     {
  1012.         $CasrtItemIds = explode(',', $CartItemId);
  1013.         /**
  1014.          * @var CartItem[] $CartItems
  1015.          */
  1016.         $CartItems = $this->CartItemRepository->findBy(['id' => $CasrtItemIds]);
  1018.         foreach ($CartItems as $CartItem) {
  1019.             //
  1020.             $noOptions = $this->isProductNoOptions($CartItem->getProductClass()->getProduct()->getId());
  1021.             //
  1022.             $Cart = $CartItem->getCart();
  1023.             if ($Cart->getCartType() != self::CartTypeEstimate) {
  1025.                 $Cart->setCartType(self::CartTypeEstimate);
  1026.                 $CartItem->setCart($Cart);
  1027.             }
  1028.             //
  1029.             if (!$noOptions) {
  1030.                 $CartItem->setOptions($this->Estimates);
  1031.             }
  1033.             if (!$CartItem->getEstimateId()) {
  1034.                 $this->SetEstimateId();
  1035.                 $CartItem->setEstimateId($this->EstimateId);
  1036.             }
  1038.             $this->entityManager->persist($CartItem);
  1039.             $this->entityManager->flush();
  1040.         }
  1041.     }
  1043.     public function resetEstimateOptions()
  1044.     {
  1045.         $this->EstimateOption = [];
  1046.     }
  1048.     public function checkExistOption($estimateOptions, $estimateId, $optionName)
  1049.     {
  1050.         foreach ($estimateOptions as $options) {
  1051.             if(isset($options[$estimateId][$optionName])) {
  1052.                 return true;
  1053.             }
  1054.         }
  1055.         return false;
  1056.     }
  1058.     /**
  1059.      * @param object $Item
  1060.      *
  1061.      */
  1062.     public function GetEstimateOptionData($Items, $Page = 'cart')
  1063.     {
  1064.         foreach ($Items as $Item) {
  1066.             if (!$Item->getOptions()) {
  1067.                 continue;
  1068.             }
  1070.             #OrderItemの時　不要かな？
  1071.             if ('order' == $Page) {
  1072.                 if (1 != $Item->getOrderItemTypeId()) {
  1073.                     continue;
  1074.                 }
  1075.             }
  1077.             $EstimateId = $Item->getEstimateId();
  1078.             $Quantity = $Item->getQuantity();
  1079.             $ProductClass = $Item->getProductClass();
  1080.             $this->SetEstimateOption($EstimateId, $ProductClass, $Quantity);
  1081.         }
  1082.         return $this->GetEstimateOption();
  1083.     }
  1085.     /**
  1086.      * 見積もりシミュレーション合計値を計算する
  1087.      * 金額は金額モジュールより
  1088.      *
  1089.      * @param int $EstimateId
  1090.      * @param object $ProductClass
  1091.      * @param string $Option
  1092.      */
  1093.     public function SetEstimateOption($EstimateId, $ProductClass, $Quantity, $Options = null)
  1094.     {
  1095.         #加工なし
  1096.         if (!$EstimateId) {
  1097.             return;
  1098.         }
  1099.         #数量設定なし
  1100.         if (!$Quantity) {
  1101.             return;
  1102.         }
  1104.         #Option の登録
  1105.         if (!isset($this->EstimateOption[$EstimateId]['option']) && $Options) {
  1106.             $this->EstimateOption[$EstimateId]['option'] = $Options;
  1107.         }
  1109.         #合計金額の算出
  1110.         if (isset($this->EstimateOption[$EstimateId]['product_total'])) {
  1111.             $this->EstimateOption[$EstimateId]['product_total'] += $Quantity * $ProductClass->getPrice02IncTax();
  1112.         } else {
  1113.             $this->EstimateOption[$EstimateId]['product_total'] = $Quantity * $ProductClass->getPrice02IncTax();
  1114.         }
  1116.         #数量の算出
  1117.         if (isset($this->EstimateOption[$EstimateId]['quantity'])) {
  1118.             $this->EstimateOption[$EstimateId]['quantity'] += $Quantity;
  1119.         } else {
  1120.             $this->EstimateOption[$EstimateId]['quantity'] = $Quantity;
  1121.         }
  1123.         if (!isset($this->EstimateOption[$EstimateId]['white_only'])) {
  1124.             $this->EstimateOption[$EstimateId]['white_only'] = 1;
  1125.         }
  1126.         $ClassCategory1 = $ProductClass->getClassCategory1();
  1127.         $Patan = $this->EccubeConfig['ESTIMATE_WHOIT_ONLY'];
  1128.         if (!preg_match($Patan, $ClassCategory1->getBackendname())) {
  1129.             $this->EstimateOption[$EstimateId]['white_only'] = 2;
  1130.         }
  1131.         return;
  1132.     }
  1134.     public function GetEstimateOption()
  1135.     {
  1136.         return $this->EstimateOption[self::DummyEstimateId] ?? $this->EstimateOption;
  1137.     }
  1139.     public function UpEstimateOption()
  1140.     {
  1141.         if (count($this->EstimateOption) < 1) {
  1142.             return;
  1143.         }
  1145.         $Columns = ['product_total', 'quantity', 'white_only'];
  1146.         foreach ($this->EstimateOption as $EstimateId => $Data) {
  1147.             $Flg = false;
  1148.             if (empty($Data['option'])) continue;
  1149.             $Options = json_decode($Data['option'], true);
  1151.             foreach ($Columns as $Column) {
  1152.                 if (($Options[$Column] ?? null) != $Data[$Column]) {
  1153.                     $Flg = true;
  1154.                     $Options[$Column] = $Data[$Column];
  1155.                 }
  1156.             }
  1158.             if ($Flg) {
  1159.                 $this->RunEstimateOptions($EstimateId, json_encode($Options));
  1160.             }
  1161.         }
  1162.     }
  1164.     public function UpRepeatEstimateOption()
  1165.     {
  1166.         if (!$this->EstimateOption) {
  1167.             return;
  1168.         }
  1169.         $this->RunEstimateOptions($this->EstimateId, $this->Estimates);
  1171.     }
  1174.     protected function RunEstimateOptions($EstimateId, $Options)
  1175.     {
  1176.         foreach ($this->getCarts() as $cart) {
  1177.             $this->CartItemRepository
  1178.             ->createQueryBuilder('ci')
  1179.             ->update()
  1180.             ->set('ci.options', ':Options')
  1181.             ->andWhere('ci.Cart = :CartId')
  1182.             ->andWhere('ci.EstimateId = :EstimateId')
  1183.             ->andWhere('ci.options IS NOT NULL')
  1184.             ->setParameter('Options', $Options)
  1185.             ->setParameter('CartId', $cart->getId())
  1186.             ->setParameter('EstimateId', $EstimateId)
  1187.             ->getQuery()
  1188.             ->execute();
  1189.         }
  1190.     }
  1192.     /**
  1193.      * 分割処理により　
  1194.      * 加工
  1195.      * プリント　＝2 裾上げ　＝1 を返す
  1196.      *
  1197.      * @return inr
  1198.      */
  1199.     public function getEstimateType()
  1200.     {
  1201.         foreach ($this->getCarts() as $i => $Cart) {
  1202.             foreach ($Cart->getCartItems() as $Items) {
  1203.                 if (!$Options = $Items->getOptions()) {
  1204.                     continue;
  1205.                 }
  1206.                 $Option = json_decode($Options, true);
  1207.                 return $Option['type'] ?? 1;
  1208.             }
  1209.         }
  1210.     }
  1212.     /**
  1213.      * 2022/10/22 カートに　商品を追加する
  1214.      *
  1215.      *
  1216.      */
  1217.     public function AddCartProduct($Products)
  1218.     {
  1219.         //
  1220.         $this->clearBuffer('isProductNoOptions');
  1221.         //
  1222.         foreach ($Products as $ClassId => $Quantity) {
  1223.             if (!$Quantity) {
  1224.                 continue;
  1225.             }
  1226.             /**
  1227.              * @var ProductClass $ProductClass
  1228.              */
  1229.             $ProductClass = $this->GetProductClass($ClassId) ?? $ClassId;
  1230.             //
  1231.             $noOptions = $this->isProductNoOptions($ProductClass->getProduct()->getId());
  1232.             //
  1233.             $this->addProduct($ProductClass, $Quantity, $noOptions);
  1234.         }
  1235.         $this->save();
  1236.     }
  1238.     public function InitiarizeEstimate()
  1239.     {
  1240.         $this->Estimates = null;
  1241.         $this->EstimateId = null;
  1242.     }
  1244.     /**
  1245.      * @param string $name
  1246.      * @return void
  1247.      */
  1248.     public function clearBuffer($name = null)
  1249.     {
  1250.         if ($name === null) {
  1251.             //
  1252.             $this->_buffer = [];
  1253.         } else {
  1254.             //
  1255.             unset($this->_buffer[$name]);
  1256.         }
  1257.     }
  1259.     /**
  1260.      * @param int $productId
  1261.      * @return bool
  1262.      */
  1263.     public function isProductNoOptions($productId)
  1264.     {
  1265.         //
  1266.         $result = false;
  1267.         //
  1268.         if (!isset($this->_buffer['isProductNoOptions'])) {
  1269.             //
  1270.             $this->_buffer['isProductNoOptions'] = $productId;
  1271.         } else  {
  1272.             //
  1273.             $result = ($this->_buffer['isProductNoOptions'] != $productId);
  1274.         }
  1275.         //
  1276.         return $result;
  1277.     }
  1279.     /**
  1280.      * @return ProductClass[]
  1281.      */
  1282.     public function getAllProductClasses()
  1283.     {
  1284.         /**
  1285.          * @var ProductClass[] $ProductClasses
  1286.          */
  1287.         $ProductClasses = [];
  1288.         //
  1289.         foreach ($this->getCarts() as $Cart) {
  1290.             //
  1291.             foreach ($Cart->getCartItems() as $CartItem) {
  1292.                 //
  1293.                 if ($CartItem->isProduct()) {
  1294.                     //
  1295.                     $ProductClasses[] = $CartItem->getProductClass();
  1296.                 }
  1297.             }
  1298.         }
  1299.         //
  1300.         return $ProductClasses;
  1301.     }
  1303.     /**
  1304.      * @return ProductClass[]
  1305.      */
  1306.     public function getEstimateProductClasses()
  1307.     {
  1308.         /**
  1309.          * @var ProductClass[] $ProductClasses
  1310.          */
  1311.         $ProductClasses = [];
  1312.         //
  1313.         foreach ($this->getCarts() as $Cart) {
  1314.             //
  1315.             foreach ($Cart->getCartItems() as $CartItem) {
  1316.                 //
  1317.                 if ($CartItem->isProduct() && !empty($CartItem->getOptions())) {
  1318.                     //
  1319.                     $ProductClasses[] = $CartItem->getProductClass();
  1320.                 }
  1321.             }
  1322.         }
  1323.         //
  1324.         return $ProductClasses;
  1325.     }
  1327.     public function hasSusoage()
  1328.     {
  1329.         //
  1330.         return GoodsService::isSusoageExistInJanIdList(array_map(function ($ProductClass) {
  1331.             //
  1332.             return $ProductClass->getId();
  1333.         }, $this->getEstimateProductClasses()));
  1334.     }
  1336.     public function hasNairePrint()
  1337.     {
  1338.         //
  1339.         return GoodsService::isNairePrintExistInJanIdList(array_map(function ($ProductClass) {
  1340.             //
  1341.             return $ProductClass->getId();
  1342.         }, $this->getEstimateProductClasses()));
  1343.     }
  1345.     public function hasKyouei()
  1346.     {
  1347.         //
  1348.         return GoodsService::isKyoueiExistInJanIdList(array_map(function ($ProductClass) {
  1349.             //
  1350.             return $ProductClass->getId();
  1351.         }, $this->getAllProductClasses()));
  1352.     }
  1354.     public function hasNairePrintWithKyouei()
  1355.         //
  1356.     {
  1357.         return GoodsService::isNairePrintWithKyoueiExistInJanIdList(array_map(function ($ProductClass) {
  1358.             //
  1359.             return $ProductClass->getId();
  1360.         }, $this->getEstimateProductClasses()));
  1361.     }
  1363.     public function hasNairePrintWithoutKyouei()
  1364.         //
  1365.     {
  1366.         return GoodsService::isNairePrintWithoutKyoueiExistInJanIdList(array_map(function ($ProductClass) {
  1367.             //
  1368.             return $ProductClass->getId();
  1369.         }, $this->getEstimateProductClasses()));
  1370.     }
  1372.     public function detectCartTypeByRouteName($routeName)
  1373.     {
  1374.         switch ($routeName) {
  1375.             case self::ROUTE_ADD_NORMAL:
  1376.             case self::ROUTE_ADD_LINE:
  1377.                 //
  1378.                 return self::CartTypeNormal;
  1379.                 break;
  1380.             case self::ROUTE_VALID_ESTIMATE:
  1381.             case self::ROUTE_ADD_ESTIMATE:
  1382.             case self::ROUTE_ADD_HYBRID:
  1383.                 //
  1384.                 return self::CartTypeEstimate;
  1385.                 break;
  1386.             case self::ROUTE_ADD_SAMPLE:
  1387.                 //
  1388.                 return self::CartTypeSample;
  1389.                 break;
  1390.             case self::ROUTE_ADD_CATALOG:
  1391.                 //
  1392.                 return self::CartTypeCatalog;
  1393.                 break;
  1394.             case self::ROUTE_ADD_REPEAT:
  1395.                 // TODO: リピート注文の排他制御対応
  1396.                 return $this->GetCartType();
  1397.                 break;
  1398.             default:
  1399.                 //
  1400.                 throw new NotFoundHttpException();
  1401.         }
  1402.     }
  1404.     /**
  1405.      * @param string $routeName
  1406.      * @param array $janIdList
  1407.      * @param int|null $currentCartType
  1408.      * @return int[]|true
  1409.      */
  1410.     public function checkMixCart($routeName, array $janIdList, $pendingCartType = null, $currentCartType = null)
  1411.     {
  1412.         //
  1413.         $result = [];
  1414.         //
  1415.         if ($pendingCartType === null) {
  1416.             //
  1417.             $pendingCartType = $this->detectCartTypeByRouteName($routeName);
  1418.         }
  1419.         //
  1420.         if ($currentCartType === null) {
  1421.             //
  1422.             $currentCartType = $this->GetCartType();
  1423.         }
  1424.         //
  1425.         if ($currentCartType === CartService::CartTypeNormal) {
  1426.             //
  1427.             if ($pendingCartType === CartService::CartTypeSample) {
  1428.                 // 購入（加工なし） × 貸出サンプル
  1429.                 return [
  1430.                     CartService::CartTypeNormal,
  1431.                     CartService::CartTypeSample,
  1432.                 ];
  1433.             } else if ($pendingCartType === CartService::CartTypeCatalog) {
  1434.                 // 購入（加工なし） × カタログ請求
  1435.                 return [
  1436.                     CartService::CartTypeNormal,
  1437.                     CartService::CartTypeCatalog,
  1438.                 ];
  1439.             }
  1440.         } else if ($currentCartType === CartService::CartTypeEstimate) {
  1441.             $canMixPrintAndSusoage = $this->EccubeConfig['MIX_PRINT_AND_SUSOAGE']['Enabled'] ?? false;
  1442.             //
  1443.             if ($pendingCartType === CartService::CartTypeSample) {
  1444.                 // 購入（加工あり） × 貸出サンプル
  1445.                 return [
  1446.                     CartService::CartTypeEstimate,
  1447.                     CartService::CartTypeSample,
  1448.                 ];
  1449.             } else if ($pendingCartType === CartService::CartTypeCatalog) {
  1450.                 // 購入（加工あり） × カタログ請求
  1451.                 return [
  1452.                     CartService::CartTypeEstimate,
  1453.                     CartService::CartTypeCatalog,
  1454.                 ];
  1455.             } else if ($pendingCartType === CartService::CartTypeEstimate) {
  1456.                 // 購入（加工あり） × 購入（加工あり）
  1457.                 if ($this->hasSusoage()) {
  1458.                     //
  1459.                     if (GoodsService::isNairePrintExistInJanIdList($janIdList) && !$canMixPrintAndSusoage) {
  1460.                         // 購入（加工あり）（裾上げ） × 購入（名入れ／プリント）
  1461.                         return [
  1462.                             CartService::CartTypeEstimate,
  1463.                             CartService::CartTypeEstimate,
  1464.                             \Lm\Entity\Estimate::TYPE_SUSOAGE,
  1465.                             \Lm\Entity\Estimate::TYPE_NAIRE_PRINT,
  1466.                         ];
  1467.                     }
  1468.                 } else if ($this->hasNairePrint()) {
  1469.                     //
  1470.                     if (GoodsService::isSusoageExistInJanIdList($janIdList) && !$canMixPrintAndSusoage) {
  1471.                         // 購入（名入れ／プリント） × 購入（加工あり）（裾上げ）
  1472.                         return [
  1473.                             CartService::CartTypeEstimate,
  1474.                             CartService::CartTypeEstimate,
  1475.                             \Lm\Entity\Estimate::TYPE_NAIRE_PRINT,
  1476.                             \Lm\Entity\Estimate::TYPE_SUSOAGE,
  1477.                         ];
  1478.                     } else if ($this->hasKyouei()) {
  1479.                         //
  1480.                         if (GoodsService::isNairePrintWithoutKyoueiExistInJanIdList($janIdList) && !$canMixPrintAndSusoage) {
  1481.                             // 購入（名入れ／プリント）（共栄） × 購入（名入れ／プリント）（共栄以外）
  1482.                             return [
  1483.                                 CartService::CartTypeEstimate,
  1484.                                 CartService::CartTypeEstimate,
  1485.                                 \Lm\Entity\Estimate::TYPE_NAIRE_PRINT_KYOUEI,
  1486.                                 \Lm\Entity\Estimate::TYPE_NAIRE_PRINT,
  1487.                             ];
  1488.                         }
  1489.                     } else if (GoodsService::isNairePrintWithKyoueiExistInJanIdList($janIdList) && !$canMixPrintAndSusoage) {
  1490.                         // 購入（名入れ／プリント）（共栄以外） × 購入（名入れ／プリント）（共栄）
  1491.                         return [
  1492.                             CartService::CartTypeEstimate,
  1493.                             CartService::CartTypeEstimate,
  1494.                             \Lm\Entity\Estimate::TYPE_NAIRE_PRINT,
  1495.                             \Lm\Entity\Estimate::TYPE_NAIRE_PRINT_KYOUEI,
  1496.                         ];
  1497.                     }
  1498.                 }
  1499.             }
  1500.         } else if ($currentCartType === CartService::CartTypeSample) {
  1501.             //
  1502.             if ($pendingCartType === self::CartTypeNormal) {
  1503.                 // 貸出サンプル × 購入（加工なし）
  1504.                 return [
  1505.                     CartService::CartTypeSample,
  1506.                     CartService::CartTypeNormal,
  1507.                 ];
  1508.             } else if ($pendingCartType === self::CartTypeEstimate) {
  1509.                 // 貸出サンプル × 購入（加工あり）
  1510.                 return [
  1511.                     CartService::CartTypeSample,
  1512.                     CartService::CartTypeEstimate,
  1513.                 ];
  1514.             } else if ($pendingCartType === self::CartTypeCatalog) {
  1515.                 // 貸出サンプル × カタログ請求
  1516.                 return [
  1517.                     CartService::CartTypeSample,
  1518.                     CartService::CartTypeCatalog,
  1519.                 ];
  1520.             }
  1521.         } else if ($currentCartType === CartService::CartTypeCatalog) {
  1522.             // カタログの場合、カタログ以外を入れようとすると上書きするように
  1523.         }
  1524.         //
  1525.         return $result ?: true;
  1526.     }
  1528.     function createCommonCartKey()
  1529.     {
  1530.         if ($currentCustomer = $this->getUser()) {
  1531.             return $currentCustomer->getId() . '_type_%s';
  1532.         }
  1534.         if ($this->session->has('cart_key_prefix')) {
  1535.             return $this->session->get('cart_key_prefix') . '_type_%s';
  1536.         }
  1538.         do {
  1539.             $random = StringUtil::random(32);
  1540.             $cartKey = $random . '_type_%s';
  1541.             $cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
  1542.         } while ($cart);
  1544.         $this->session->set('cart_key_prefix', $random);
  1546.         return $cartKey;
  1547.     }
  1549.     function removeCart($cart)
  1550.     {
  1551.         foreach ($cart->getCartItems() as $i) {
  1552.             $this->entityManager->remove($i);
  1553.             $this->entityManager->flush();
  1554.         }
  1555.         $preOrderId = $cart->getPreOrderId();
  1556.         $Order = $this->orderHelper->getPurchaseProcessingOrder($preOrderId);
  1557.         if ($Order) {
  1558.             $this->entityManager->remove($Order);
  1559.         }
  1560.         $this->entityManager->remove($cart);
  1561.         $this->entityManager->flush();
  1562.     }
  1564.     /**
  1565.      * @return CartItem[]
  1566.      */
  1567.     function getAllCartsItems()
  1568.     {
  1569.         //
  1570.         return array_merge(...(array_map(function ($cart) {
  1571.             return is_array(($cartItems = $cart->getCartItems())) ? $cartItems : $cartItems->toArray();
  1572.         }, $this->getCarts()) ?: [[]]));
  1573.     }
  1575.     public function removeCartItems($cartItemIds)
  1576.     {
  1577.         $cartItems = $this->getAllCartsItems();
  1578.         foreach ($cartItems as $item) {
  1579.             if (in_array($item->getId(), $cartItemIds)) {
  1580.                 $this->entityManager->remove($item);
  1581.             }
  1582.         }
  1583.         $this->entityManager->flush();
  1584.     }
  1586.     /**
  1587.      * @param bool|null $enabled
  1588.      * @return bool|void
  1589.      */
  1590.     public function bulkCheckoutEnabled($enabled = null)
  1591.     {
  1592.         if ($enabled === null) {
  1593.             return $this->session->get(self::SESSION_BULK_CHECKOUT_ENABLED);
  1594.         } else {
  1595.             $this->session->set(self::SESSION_BULK_CHECKOUT_ENABLED, $enabled);
  1596.         }
  1597.     }
  1599.     /**
  1600.      * 在庫切れの商品が含まれていないかを確認する
  1601.      * @return bool
  1602.      * @throws \Exception
  1603.      */
  1604.     public function isItemsStockAvailable()
  1605.     {
  1606.         //
  1607.         foreach ($this->getCarts() as $cart) {
  1608.             foreach ($cart->getCartItems() as $cartItem) {
  1609.                 if ($skuInfo = $cartItem->getProductClass()->getSkuInfo()) {
  1610.                     if ($skuInfo->getBackOrder() === Sku::BACK_ORDER_UNAVAILABLE && $skuInfo->getStockAvailability() === Sku::STOCK_AVL_OUT_OF_STOCK) {
  1611.                         // 入荷予定: なし
  1612.                         // 在庫状況: 在庫切れ
  1613.                         return false;
  1614.                     }
  1615.                 }
  1616.             }
  1617.         }
  1618.         //
  1619.         return true;
  1620.     }
  1622.     /**
  1623.      * check cart has error Susoage has warning when change size, color, qty
  1624.      * @return bool
  1625.      * @throws \Exception
  1626.      */
  1627.     public function listSusoageChange()
  1628.     {
  1629.         $listOrder = [];
  1630.         foreach ($this->getCarts() as $cart) {
  1631.             foreach ($cart->getCartItems() as $cartItem) {
  1632.                 $qty = 0;
  1633.                 $qtyItem = intval($cartItem->getQuantity());
  1634.                 $options = $cartItem->getOptions();
  1635.                 $options = json_decode($options, true);
  1636.                 if (isset($options['susoage']) and is_array($options['susoage'])) {
  1637.                     $productClass = $cartItem->getProductClass();
  1638.                     if ($productClass) {
  1639.                         if (!isset($options['susoage'][$productClass->getId()])) {
  1640.                             $listOrder[$cartItem->getEstimateId()] = $cartItem->getEstimateId();
  1641.                         }
  1642.                     }
  1643.                     foreach ($options['susoage'] as $classId =>$susoage) {
  1644.                         if($classId  == $productClass->getId()){
  1645.                             $qty += count($susoage);
  1646.                         }
  1647.                     }
  1648.                     if ($qty != $qtyItem) {
  1649.                         $listOrder[$cartItem->getEstimateId()] = $cartItem->getEstimateId();
  1650.                     }
  1651.                 }
  1652.             }
  1653.         }
  1654.         //
  1655.         return $listOrder;
  1656.     }
  1658. }