Eccube\Service\CartService

Complexity

Total Complexity

53

Size/Duplication

Total Lines	428
Duplicated Lines	4.21 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

93.06%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	mergeFromPersistedCart()	0	13	2
A	mergeCartItems()	0	19	5
B	addProduct()	9	31	7
A	setPreOrderId()	0	6	1
A	getPreOrderId()	0	4	1
A	__construct()	0	23	1
A	getCarts()	0	11	2
A	save()	0	18	3
A	getCart()	0	10	2
A	mergeAllCartItems()	0	11	2
B	restoreCarts()	0	46	8
A	removeProduct()	9	30	5
A	clear()	0	20	5
A	setCartItemComparator()	0	4	1
A	setPrimary()	0	10	1
A	getUser()	0	13	3
A	createCartKey()	0	20	4

<?php

/*
 * This file is part of EC-CUBE
 *
 * Copyright(c) LOCKON CO.,LTD. All Rights Reserved.
 *
 * http://www.lockon.co.jp/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Eccube\Service;

use Doctrine\ORM\UnitOfWork;
use Eccube\Entity\Cart;
use Eccube\Entity\CartItem;
use Eccube\Entity\Customer;
use Eccube\Entity\ItemHolderInterface;
use Eccube\Entity\ProductClass;
use Eccube\Repository\CartRepository;
use Eccube\Repository\ProductClassRepository;
use Eccube\Repository\OrderRepository;
use Eccube\Service\Cart\CartItemAllocator;
use Eccube\Service\Cart\CartItemComparator;
use Eccube\Util\StringUtil;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Doctrine\ORM\EntityManagerInterface;

class CartService

Missing class doc comment

{
    /**
     * @var Cart[]
     */
    protected $carts;

    /**
     * @var SessionInterface
     */
    protected $session;

    /**
     * @var \Doctrine\ORM\EntityManagerInterface
     */
    protected $entityManager;

    /**
     * @var ItemHolderInterface
     *
     * @deprecated
     */
    protected $cart;

    /**
     * @var ProductClassRepository
     */
    protected $productClassRepository;

    /**
     * @var CartRepository
     */
    protected $cartRepository;

    /**
     * @var CartItemComparator
     */
    protected $cartItemComparator;

    /**
     * @var CartItemAllocator
     */
    protected $cartItemAllocator;

    /**
     * @var OrderHelper
     */
    protected $orderHelper;

    /**
     * @var OrderRepository
     */
    protected $orderRepository;

    /**
     * @var TokenStorageInterface
     */
    protected $tokenStorage;

    /**
     * @var AuthorizationCheckerInterface
     */
    protected $authorizationChecker;

    /**

Doc comment for parameter "$cartRepository" missing

Doc comment for parameter "$orderRepository" missing

     * CartService constructor.
     *
     * @param SessionInterface $session

Expected 14 spaces after parameter type; 1 found

     * @param EntityManagerInterface $entityManager

Expected 8 spaces after parameter type; 1 found

     * @param ProductClassRepository $productClassRepository

Expected 8 spaces after parameter type; 1 found

     * @param CartItemComparator $cartItemComparator

Expected 12 spaces after parameter type; 1 found

Doc comment for parameter $cartItemComparator does not match actual variable name $cartRepository

     * @param CartItemAllocator $cartItemAllocator

Expected 13 spaces after parameter type; 1 found

Doc comment for parameter $cartItemAllocator does not match actual variable name $cartItemComparator

     * @param OrderHelper $orderHelper

Expected 19 spaces after parameter type; 1 found

Doc comment for parameter $orderHelper does not match actual variable name $cartItemAllocator

     * @param TokenStorageInterface $tokenStorage

Expected 9 spaces after parameter type; 1 found

Doc comment for parameter $tokenStorage does not match actual variable name $orderHelper

     * @param AuthorizationCheckerInterface $authorizationChecker

Doc comment for parameter $authorizationChecker does not match actual variable name $orderRepository

     */
    public function __construct(
        SessionInterface $session,
        EntityManagerInterface $entityManager,
        ProductClassRepository $productClassRepository,
        CartRepository $cartRepository,
        CartItemComparator $cartItemComparator,
        CartItemAllocator $cartItemAllocator,
        OrderHelper $orderHelper,
        OrderRepository $orderRepository,
        TokenStorageInterface $tokenStorage,
        AuthorizationCheckerInterface $authorizationChecker
    ) {
        $this->session = $session;
        $this->entityManager = $entityManager;
        $this->productClassRepository = $productClassRepository;
        $this->cartRepository = $cartRepository;
        $this->cartItemComparator = $cartItemComparator;
        $this->cartItemAllocator = $cartItemAllocator;
        $this->orderHelper = $orderHelper;
        $this->orderRepository = $orderRepository;
        $this->tokenStorage = $tokenStorage;
        $this->authorizationChecker = $authorizationChecker;
    }

    public function getCarts()
    {
        if (!empty($this->carts)) {
            return $this->carts;
        }

        $cartKeys = $this->session->get('cart_keys', []);
        $this->carts = $this->cartRepository->findBy(['cart_key' => $cartKeys], ['id' => 'DESC']);

        return $this->carts;
    }

    /**
     * 会員が保持する永続化されたカートと、非会員時のカートをマージする.
     *
     * @param Customer $Customer
     */
    public function mergeFromPersistedCart(Customer $Customer)
    {
        $Carts = $this->cartRepository->findBy(['Customer' => $Customer]);

        $CartItems = [];
        foreach ($Carts as $Cart) {
            $CartItems = $this->mergeCartItems($Cart->getCartItems(), $CartItems);
        }

        // セッションにある非会員カートとDBから取得した会員カートをマージする.
        $CartItems = $this->mergeAllCartItems($CartItems);
        $this->restoreCarts($CartItems);
    }

    /**
     * @return ItemHolderInterface|Cart
     */
    public function getCart()
    {
        $Carts = $this->getCarts();

        if (empty($Carts)) {
            return null;
        }

        return current($Carts);
    }

    /**
     * @param CartItem[] $cartItems
     *
     * @return CartItem[]
     */
    protected function mergeAllCartItems($cartItems = [])
    {
        /** @var CartItem[] $allCartItems */
        $allCartItems = [];

        foreach ($this->getCarts() as $Cart) {
            $allCartItems = $this->mergeCartItems($Cart->getCartItems(), $allCartItems);
        }

        return $this->mergeCartItems($cartItems, $allCartItems);
    }

    /**
     * @param $cartItems
     * @param $allCartItems
     *
     * @return array
     */
    protected function mergeCartItems($cartItems, $allCartItems)
    {
        foreach ($cartItems as $item) {
            $itemExists = false;
            foreach ($allCartItems as $itemInArray) {
                // 同じ明細があればマージする
                if ($this->cartItemComparator->compare($item, $itemInArray)) {
                    $itemInArray->setQuantity($itemInArray->getQuantity() + $item->getQuantity());
                    $itemExists = true;
                    break;
                }
            }
            if (!$itemExists) {
                $allCartItems[] = $item;
            }
        }

        return $allCartItems;
    }

    protected function restoreCarts($cartItems)
    {
        if (empty($cartItems)) {
            foreach ($this->getCarts() as $Cart) {
                foreach ($Cart->getCartItems() as $i) {
                    $this->entityManager->remove($i);
                    $this->entityManager->flush($i);

The call to EntityManagerInterface::flush() has too many arguments starting with $i.

                }
                $this->entityManager->remove($Cart);
                $this->entityManager->flush($Cart);

The call to EntityManagerInterface::flush() has too many arguments starting with $Cart.

            }
            $this->carts = [];
        }

        /** @var Cart[] $Carts */
        $Carts = [];

        foreach ($cartItems as $item) {
            $allocatedId = $this->cartItemAllocator->allocate($item);
            $cartKey = $this->createCartKey($allocatedId, $this->getUser());

            if (isset($Carts[$cartKey])) {
                $Cart = $Carts[$cartKey];
                $Cart->addCartItem($item);
                $item->setCart($Cart);
            } else {
                /** @var Cart $Cart */
                $Cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
                if ($Cart) {
                    foreach ($Cart->getCartItems() as $i) {
                        $this->entityManager->remove($i);
                        $this->entityManager->flush($i);

The call to EntityManagerInterface::flush() has too many arguments starting with $i.

                    }
                    $this->entityManager->remove($Cart);
                    $this->entityManager->flush($Cart);

The call to EntityManagerInterface::flush() has too many arguments starting with $Cart.

                }
                $Cart = new Cart();
                $Cart->setCartKey($cartKey);
                $Cart->addCartItem($item);
                $item->setCart($Cart);
                $Carts[$cartKey] = $Cart;
            }
        }

        $this->carts = array_values($Carts);
    }

    /**

Doc comment for parameter "$ProductClass" missing

Doc comment for parameter "$quantity" missing

     * カートに商品を追加します.
     *
     * @param $ProductClass ProductClass 商品規格

Missing parameter name

     * @param $quantity int 数量

Missing parameter name

     *
     * @return bool 商品を追加できた場合はtrue
     */
    public function addProduct($ProductClass, $quantity = 1)

Declare public methods first, then protected ones and finally private ones

    {
        if (!$ProductClass instanceof ProductClass) {
            $ProductClassId = $ProductClass;
            $ProductClass = $this->entityManager
                ->getRepository(ProductClass::class)
                ->find($ProductClassId);
            if (is_null($ProductClass)) {
                return false;
            }
        }

        $ClassCategory1 = $ProductClass->getClassCategory1();
        if ($ClassCategory1 && !$ClassCategory1->isVisible()) {
            return false;
        }
        $ClassCategory2 = $ProductClass->getClassCategory2();
        if ($ClassCategory2 && !$ClassCategory2->isVisible()) {
            return false;
        }

        $newItem = new CartItem();
        $newItem->setQuantity($quantity);
        $newItem->setPrice($ProductClass->getPrice02IncTax());
        $newItem->setProductClass($ProductClass);

        $allCartItems = $this->mergeAllCartItems([$newItem]);
        $this->restoreCarts($allCartItems);

        return true;
    }

    public function removeProduct($ProductClass)
    {
        if (!$ProductClass instanceof ProductClass) {
            $ProductClassId = $ProductClass;
            $ProductClass = $this->entityManager
                ->getRepository(ProductClass::class)
                ->find($ProductClassId);
            if (is_null($ProductClass)) {
                return false;
            }
        }

        $removeItem = new CartItem();
        $removeItem->setPrice($ProductClass->getPrice02IncTax());
        $removeItem->setProductClass($ProductClass);

        $allCartItems = $this->mergeAllCartItems();
        $foundIndex = -1;
        foreach ($allCartItems as $index => $itemInCart) {
            if ($this->cartItemComparator->compare($itemInCart, $removeItem)) {
                $foundIndex = $index;
                break;
            }
        }

        array_splice($allCartItems, $foundIndex, 1);
        $this->restoreCarts($allCartItems);

        return true;
    }

    public function save()
    {
        $cartKeys = [];
        foreach ($this->carts as $Cart) {
            $Cart->setCustomer($this->getUser());
            $this->entityManager->persist($Cart);
            foreach ($Cart->getCartItems() as $item) {
                $this->entityManager->persist($item);
                $this->entityManager->flush($item);

The call to EntityManagerInterface::flush() has too many arguments starting with $item.

            }
            $this->entityManager->flush($Cart);

The call to EntityManagerInterface::flush() has too many arguments starting with $Cart.

            $cartKeys[] = $Cart->getCartKey();
        }

        $this->session->set('cart_keys', $cartKeys);

        return;

Empty return statement not required here

    }

    /**
     * @param  string $pre_order_id
     *
     * @return \Eccube\Service\CartService
     */
    public function setPreOrderId($pre_order_id)
    {
        $this->getCart()->setPreOrderId($pre_order_id);

        return $this;
    }

    /**
     * @return string
     */
    public function getPreOrderId()
    {
        return $this->getCart()->getPreOrderId();
    }

    /**
     * @return \Eccube\Service\CartService
     */
    public function clear()
    {
        $Carts = $this->getCarts();
        if (!empty($Carts)) {
            $removed = array_shift($Carts);
            if ($removed && UnitOfWork::STATE_MANAGED === $this->entityManager->getUnitOfWork()->getEntityState($removed)) {
                $this->entityManager->remove($removed);
                $this->entityManager->flush($removed);

The call to EntityManagerInterface::flush() has too many arguments starting with $removed.

                $cartKeys = [];
                foreach ($Carts as $Cart) {
                    $cartKeys[] = $Cart->getCartKey();
                }
                $this->session->set('cart_keys', $cartKeys);
                $this->carts = $this->cartRepository->findBy(['cart_key' => $cartKeys], ['id' => 'DESC']);
            }
        }

        return $this;
    }

    /**
     * @param CartItemComparator $cartItemComparator
     */
    public function setCartItemComparator($cartItemComparator)
    {
        $this->cartItemComparator = $cartItemComparator;
    }

    /**
     * 指定したインデックスにあるカートを優先にする
     *
     * @param int $index カートのインデックス
     */
    public function setPrimary($index = 0)
    {
        $Carts = $this->getCarts();
        $primary = $Carts[$index];
        $prev = $Carts[0];
        array_splice($Carts, 0, 1, [$primary]);
        array_splice($Carts, $index, 1, [$prev]);
        $this->carts = $Carts;
        $this->save();
    }

    protected function getUser()
    {
        if (null === $token = $this->tokenStorage->getToken()) {
            return;
        }

        if (!is_object($user = $token->getUser())) {
            // e.g. anonymous authentication
            return;
        }

        return $user;
    }

    protected function createCartKey($allocatedId, Customer $Customer = null)
    {
        if ($Customer instanceof Customer) {
            return $Customer->getId().'_'.$allocatedId;
        }

        if ($this->session->has('cart_key_prefix')) {
            return $this->session->get('cart_key_prefix').'_'.$allocatedId;
        }

        do {
            $random = StringUtil::random(32);
            $cartKey = $random.'_'.$allocatedId;
            $Cart = $this->cartRepository->findOneBy(['cart_key' => $cartKey]);
        } while ($Cart);

        $this->session->set('cart_key_prefix', $random);

        return $cartKey;
    }
}