OrderHelper - Code Metrics - Inspection of "購入時の税率で固定されるように修正" - kiy0taka/ec-cube - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev/4269 ( 0f73fd )

by Kiyotaka

created 2019-08-16 05:02 UTC

OrderHelper A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	464
Duplicated Lines	3.02 %

Coupling/Cohesion

Components	2
Dependencies	23

Importance

Changes

Metric	Value
dl	14
loc	464
rs	9.2
c	0
b	0
f	0
wmc	40
lcom	2
cbo	23

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	27	1
A	createPurchaseProcessingOrder()	0	39	3
A	verifyCart()	0	17	3
A	isLoginRequired()	0	19	5
A	getPurchaseProcessingOrder()	0	11	2
A	getNonMember()	0	10	3
A	initializeOrder()	0	13	2
A	removeSession()	0	7	1
A	updateCustomerInfo()	0	6	2
A	createPreOrderId()	0	15	2
A	setCustomer()	0	16	2
B	createOrderItemsFromCartItems()	0	41	5
A	createShippingFromCustomer()	0	17	1
A	setDefaultDelivery()	5	20	2
A	setDefaultPayment()	9	30	4
A	addOrderItems()	0	9	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like OrderHelper often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use OrderHelper, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of EC-CUBE
 *
 * Copyright(c) EC-CUBE CO.,LTD. All Rights Reserved.
 *
 * http://www.ec-cube.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\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use Eccube\Entity\Cart;
use Eccube\Entity\CartItem;
use Eccube\Entity\Customer;
use Eccube\Entity\Master\DeviceType;
use Eccube\Entity\Master\OrderItemType;
use Eccube\Entity\Master\OrderStatus;
use Eccube\Entity\Order;
use Eccube\Entity\OrderItem;
use Eccube\Entity\Shipping;
use Eccube\Entity\TaxRule;
use Eccube\EventListener\SecurityListener;
use Eccube\Repository\DeliveryRepository;
use Eccube\Repository\Master\DeviceTypeRepository;
use Eccube\Repository\Master\OrderItemTypeRepository;
use Eccube\Repository\Master\OrderStatusRepository;
use Eccube\Repository\Master\PrefRepository;
use Eccube\Repository\OrderRepository;
use Eccube\Repository\PaymentRepository;
use Eccube\Repository\TaxRuleRepository;
use Eccube\Util\StringUtil;
use SunCat\MobileDetectBundle\DeviceDetector\MobileDetector;
use Symfony\Bundle\FrameworkBundle\Controller\ControllerTrait;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Session\SessionInterface;

class OrderHelper
{
    // FIXME 必要なメソッドのみ移植する
    use ControllerTrait;

    /**
     * @var ContainerInterface
     */
    protected $container;

    /**
     * @var string 非会員情報を保持するセッションのキー
     */
    const SESSION_NON_MEMBER = 'eccube.front.shopping.nonmember';

    /**
     * @var string 非会員の住所情報を保持するセッションのキー
     */
    const SESSION_NON_MEMBER_ADDRESSES = 'eccube.front.shopping.nonmember.customeraddress';

    /**
     * @var string 受注IDを保持するセッションのキー
     */
    const SESSION_ORDER_ID = 'eccube.front.shopping.order.id';

    /**
     * @var string カートが分割されているかどうかのフラグ. 購入フローからのログイン時にカートが分割された場合にtrueがセットされる.
     *
     * @see SecurityListener
     */
    const SESSION_CART_DIVIDE_FLAG = 'eccube.front.cart.divide';

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

    /**
     * @var PrefRepository
     */
    protected $prefRepository;

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

    /**
     * @var OrderItemTypeRepository
     */
    protected $orderItemTypeRepository;

    /**
     * @var OrderStatusRepository
     */
    protected $orderStatusRepository;

    /**
     * @var DeliveryRepository
     */
    protected $deliveryRepository;

    /**
     * @var PaymentRepository
     */
    protected $paymentRepository;

    /**
     * @var DeviceTypeRepository
     */
    protected $deviceTypeRepository;

    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    /**
     * @var MobileDetector
     */
    protected $mobileDetector;

    /**
     * @var TaxRuleRepository
     */
    protected $taxRuleRepository;

    public function __construct(
        ContainerInterface $container,
        EntityManagerInterface $entityManager,
        OrderRepository $orderRepository,
        OrderItemTypeRepository $orderItemTypeRepository,
        OrderStatusRepository $orderStatusRepository,
        DeliveryRepository $deliveryRepository,
        PaymentRepository $paymentRepository,
        DeviceTypeRepository $deviceTypeRepository,
        PrefRepository $prefRepository,
        TaxRuleRepository $taxRuleRepository,
        MobileDetector $mobileDetector,
        SessionInterface $session
    ) {
        $this->container = $container;
        $this->orderRepository = $orderRepository;
        $this->orderStatusRepository = $orderStatusRepository;
        $this->orderItemTypeRepository = $orderItemTypeRepository;
        $this->deliveryRepository = $deliveryRepository;
        $this->paymentRepository = $paymentRepository;
        $this->deviceTypeRepository = $deviceTypeRepository;
        $this->entityManager = $entityManager;
        $this->prefRepository = $prefRepository;
        $this->taxRuleRepository = $taxRuleRepository;
        $this->mobileDetector = $mobileDetector;
        $this->session = $session;
    }

    /**
     * 購入処理中の受注を生成する.
     *
     * @param Customer $Customer
     * @param $CartItems
     *
     * @return Order
     */
    public function createPurchaseProcessingOrder(Cart $Cart, Customer $Customer)
    {
        $OrderStatus = $this->orderStatusRepository->find(OrderStatus::PROCESSING);
        $Order = new Order($OrderStatus);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $preOrderId = $this->createPreOrderId();
        $Order->setPreOrderId($preOrderId);

        // 顧客情報の設定
        $this->setCustomer($Order, $Customer);

        $DeviceType = $this->deviceTypeRepository->find($this->mobileDetector->isMobile() ? DeviceType::DEVICE_TYPE_MB : DeviceType::DEVICE_TYPE_PC);
        $Order->setDeviceType($DeviceType);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        // 明細情報の設定
        $OrderItems = $this->createOrderItemsFromCartItems($Cart->getCartItems());
        $OrderItemsGroupBySaleType = array_reduce($OrderItems, function ($result, $item) {
            /* @var OrderItem $item */
            $saleTypeId = $item->getProductClass()->getSaleType()->getId();
            $result[$saleTypeId][] = $item;

            return $result;
        }, []);

        foreach ($OrderItemsGroupBySaleType as $OrderItems) {
            $Shipping = $this->createShippingFromCustomer($Customer);
            $Shipping->setOrder($Order);
            $this->addOrderItems($Order, $Shipping, $OrderItems);
            $this->setDefaultDelivery($Shipping);
            $this->entityManager->persist($Shipping);
            $Order->addShipping($Shipping);
        }

        $this->setDefaultPayment($Order);

        $this->entityManager->persist($Order);

        return $Order;
    }

    /**
     * @param Cart $Cart
     *
     * @return bool
     */
    public function verifyCart(Cart $Cart)
    {
        if (count($Cart->getCartItems()) > 0) {
            $divide = $this->session->get(self::SESSION_CART_DIVIDE_FLAG);
            if ($divide) {
                log_info('ログイン時に販売種別が異なる商品がカートと結合されました。');

                return false;
            }

            return true;
        }

        log_info('カートに商品が入っていません。');

        return false;
    }

    /**
     * 注文手続き画面でログインが必要かどうかの判定
     *
     * @return bool
     */
    public function isLoginRequired()
    {
        // フォームログイン済はログイン不要
        if ($this->isGranted('IS_AUTHENTICATED_FULLY')) {
            return false;
        }

        // Remember Meログイン済の場合はフォームからのログインが必要
        if ($this->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
            return true;
        }

        // 未ログインだがお客様情報を入力している場合はログイン不要
        if (!$this->getUser() && $this->getNonMember()) {
            return false;
        }

        return true;
    }

    /**
     * 購入処理中の受注を取得する.
     *
     * @param null|string $preOrderId
     *
     * @return null|Order
     */
    public function getPurchaseProcessingOrder($preOrderId = null)
    {
        if (null === $preOrderId) {
            return null;
        }

        return $this->orderRepository->findOneBy([
            'pre_order_id' => $preOrderId,
            'OrderStatus' => OrderStatus::PROCESSING,
        ]);
    }

    /**
     * セッションに保持されている非会員情報を取得する.
     * 非会員購入時に入力されたお客様情報を返す.
     *
     * @return Customer
     */
    public function getNonMember()
    {
        $NonMember = $this->session->get(self::SESSION_NON_MEMBER);
        if ($NonMember && $NonMember->getPref()) {
            $Pref = $this->prefRepository->find($NonMember->getPref()->getId());
            $NonMember->setPref($Pref);
        }

        return $NonMember;
    }

    /**
     * @param Cart $Cart
     * @param Customer $Customer
     *
     * @return Order|null
     */
    public function initializeOrder(Cart $Cart, Customer $Customer)
    {
        // 購入処理中の受注情報を取得
        if ($Order = $this->getPurchaseProcessingOrder($Cart->getPreOrderId())) {
            return $Order;
        }

        // 受注情報を作成
        $Order = $this->createPurchaseProcessingOrder($Cart, $Customer);
        $Cart->setPreOrderId($Order->getPreOrderId());

        return $Order;
    }

    public function removeSession()
    {
        $this->session->remove(self::SESSION_ORDER_ID);
        $this->session->remove(self::SESSION_ORDER_ID);
        $this->session->remove(self::SESSION_NON_MEMBER);
        $this->session->remove(self::SESSION_NON_MEMBER_ADDRESSES);
    }

    /**
     * 会員情報の更新日時が受注の作成日時よりも新しければ, 受注の注文者情報を更新する.
     *
     * @param Order $Order
     * @param Customer $Customer
     */
    public function updateCustomerInfo(Order $Order, Customer $Customer)
    {
        if ($Order->getCreateDate() < $Customer->getUpdateDate()) {
            $this->setCustomer($Order, $Customer);
        }
    }

    public function createPreOrderId()
    {
        // ランダムなpre_order_idを作成
        do {
            $preOrderId = sha1(StringUtil::random(32));

            $Order = $this->orderRepository->findOneBy(
                [
                    'pre_order_id' => $preOrderId,
                ]
            );
        } while ($Order);

        return $preOrderId;
    }

    protected function setCustomer(Order $Order, Customer $Customer)
    {
        if ($Customer->getId()) {
            $Order->setCustomer($Customer);
        }

        $Order->copyProperties(
            $Customer,
            [
                'id',
                'create_date',
                'update_date',
                'del_flg',
            ]
        );
    }

    /**
     * @param Collection|ArrayCollection|CartItem[] $CartItems
     *
     * @return OrderItem[]
     */
    protected function createOrderItemsFromCartItems($CartItems)
    {
        $ProductItemType = $this->orderItemTypeRepository->find(OrderItemType::PRODUCT);

        return array_map(function ($item) use ($ProductItemType) {
            /* @var $item CartItem */
            /* @var $ProductClass \Eccube\Entity\ProductClass */
            $ProductClass = $item->getProductClass();
            /* @var $Product \Eccube\Entity\Product */
            $Product = $ProductClass->getProduct();
            /** @var TaxRule $TaxRule */
            $TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass)
                ?: $this->taxRuleRepository->getByRule();

            $OrderItem = new OrderItem();
            $OrderItem
                ->setProduct($Product)
                ->setProductClass($ProductClass)
                ->setProductName($Product->getName())
                ->setProductCode($ProductClass->getCode())
                ->setPrice($ProductClass->getPrice02())
                ->setQuantity($item->getQuantity())
                ->setOrderItemType($ProductItemType)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                ->setTax($TaxRule->getTaxRate())
                ->setTaxAdjust($TaxRule->getTaxAdjust())
                ->setRoundingType($TaxRule->getRoundingType());

            $ClassCategory1 = $ProductClass->getClassCategory1();
            if (!is_null($ClassCategory1)) {
                $OrderItem->setClasscategoryName1($ClassCategory1->getName());
                $OrderItem->setClassName1($ClassCategory1->getClassName()->getName());
            }
            $ClassCategory2 = $ProductClass->getClassCategory2();
            if (!is_null($ClassCategory2)) {
                $OrderItem->setClasscategoryName2($ClassCategory2->getName());
                $OrderItem->setClassName2($ClassCategory2->getClassName()->getName());
            }

            return $OrderItem;
        }, $CartItems instanceof Collection ? $CartItems->toArray() : $CartItems);
    }

    /**
     * @param Customer $Customer
     *
     * @return Shipping
     */
    protected function createShippingFromCustomer(Customer $Customer)
    {
        $Shipping = new Shipping();
        $Shipping
            ->setName01($Customer->getName01())
            ->setName02($Customer->getName02())
            ->setKana01($Customer->getKana01())
            ->setKana02($Customer->getKana02())
            ->setCompanyName($Customer->getCompanyName())
            ->setPhoneNumber($Customer->getPhoneNumber())
            ->setPostalCode($Customer->getPostalCode())
            ->setPref($Customer->getPref())
            ->setAddr01($Customer->getAddr01())
            ->setAddr02($Customer->getAddr02());

        return $Shipping;
    }

    /**
     * @param Shipping $Shipping
     */
    protected function setDefaultDelivery(Shipping $Shipping)
    {
        // 配送商品に含まれる販売種別を抽出.
        $OrderItems = $Shipping->getOrderItems();
        $SaleTypes = [];
        /** @var OrderItem $OrderItem */
        foreach ($OrderItems as $OrderItem) {

            $ProductClass = $OrderItem->getProductClass();
            $SaleType = $ProductClass->getSaleType();
            $SaleTypes[$SaleType->getId()] = $SaleType;
        }

        // 販売種別に紐づく配送業者を取得.
        $Deliveries = $this->deliveryRepository->getDeliveries($SaleTypes);

        // 初期の配送業者を設定
        $Delivery = current($Deliveries);
        $Shipping->setDelivery($Delivery);
        $Shipping->setShippingDeliveryName($Delivery->getName());
    }

    /**
     * @param Order $Order
     */
    protected function setDefaultPayment(Order $Order)
    {
        $OrderItems = $Order->getOrderItems();

        // 受注明細に含まれる販売種別を抽出.
        $SaleTypes = [];
        /** @var OrderItem $OrderItem */
        foreach ($OrderItems as $OrderItem) {

            $ProductClass = $OrderItem->getProductClass();
            if (is_null($ProductClass)) {
                // 商品明細のみ対象とする. 送料明細等はスキップする.
                continue;
            }
            $SaleType = $ProductClass->getSaleType();
            $SaleTypes[$SaleType->getId()] = $SaleType;
        }

        // 販売種別に紐づく配送業者を抽出
        $Deliveries = $this->deliveryRepository->getDeliveries($SaleTypes);

        // 利用可能な支払い方法を抽出.
        $Payments = $this->paymentRepository->findAllowedPayments($Deliveries, true);

        // 初期の支払い方法を設定.
        $Payment = current($Payments);
        if ($Payment) {
            $Order->setPayment($Payment);
            $Order->setPaymentMethod($Payment->getMethod());
        }
    }

    /**
     * @param Order $Order
     * @param Shipping $Shipping
     * @param array $OrderItems
     */
    protected function addOrderItems(Order $Order, Shipping $Shipping, array $OrderItems)
    {
        foreach ($OrderItems as $OrderItem) {
            $Shipping->addOrderItem($OrderItem);
            $Order->addOrderItem($OrderItem);
            $OrderItem->setOrder($Order);
            $OrderItem->setShipping($Shipping);
        }
    }
}


1		<?php
2
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		*/
13
14		namespace Eccube\Service;
15
16		use Doctrine\Common\Collections\ArrayCollection;
17		use Doctrine\Common\Collections\Collection;
18		use Doctrine\ORM\EntityManagerInterface;
19		use Eccube\Entity\Cart;
20		use Eccube\Entity\CartItem;
21		use Eccube\Entity\Customer;
22		use Eccube\Entity\Master\DeviceType;
23		use Eccube\Entity\Master\OrderItemType;
24		use Eccube\Entity\Master\OrderStatus;
25		use Eccube\Entity\Order;
26		use Eccube\Entity\OrderItem;
27		use Eccube\Entity\Shipping;
28		use Eccube\Entity\TaxRule;
29		use Eccube\EventListener\SecurityListener;
30		use Eccube\Repository\DeliveryRepository;
31		use Eccube\Repository\Master\DeviceTypeRepository;
32		use Eccube\Repository\Master\OrderItemTypeRepository;
33		use Eccube\Repository\Master\OrderStatusRepository;
34		use Eccube\Repository\Master\PrefRepository;
35		use Eccube\Repository\OrderRepository;
36		use Eccube\Repository\PaymentRepository;
37		use Eccube\Repository\TaxRuleRepository;
38		use Eccube\Util\StringUtil;
39		use SunCat\MobileDetectBundle\DeviceDetector\MobileDetector;
40		use Symfony\Bundle\FrameworkBundle\Controller\ControllerTrait;
41		use Symfony\Component\DependencyInjection\ContainerInterface;
42		use Symfony\Component\HttpFoundation\Session\SessionInterface;
43
44		class OrderHelper
45		{
46		// FIXME 必要なメソッドのみ移植する
47		use ControllerTrait;
48
49		/**
50		* @var ContainerInterface
51		*/
52		protected $container;
53
54		/**
55		* @var string 非会員情報を保持するセッションのキー
56		*/
57		const SESSION_NON_MEMBER = 'eccube.front.shopping.nonmember';
58
59		/**
60		* @var string 非会員の住所情報を保持するセッションのキー
61		*/
62		const SESSION_NON_MEMBER_ADDRESSES = 'eccube.front.shopping.nonmember.customeraddress';
63
64		/**
65		* @var string 受注IDを保持するセッションのキー
66		*/
67		const SESSION_ORDER_ID = 'eccube.front.shopping.order.id';
68
69		/**
70		* @var string カートが分割されているかどうかのフラグ. 購入フローからのログイン時にカートが分割された場合にtrueがセットされる.
71		*
72		* @see SecurityListener
73		*/
74		const SESSION_CART_DIVIDE_FLAG = 'eccube.front.cart.divide';
75
76		/**
77		* @var SessionInterface
78		*/
79		protected $session;
80
81		/**
82		* @var PrefRepository
83		*/
84		protected $prefRepository;
85
86		/**
87		* @var OrderRepository
88		*/
89		protected $orderRepository;
90
91		/**
92		* @var OrderItemTypeRepository
93		*/
94		protected $orderItemTypeRepository;
95
96		/**
97		* @var OrderStatusRepository
98		*/
99		protected $orderStatusRepository;
100
101		/**
102		* @var DeliveryRepository
103		*/
104		protected $deliveryRepository;
105
106		/**
107		* @var PaymentRepository
108		*/
109		protected $paymentRepository;
110
111		/**
112		* @var DeviceTypeRepository
113		*/
114		protected $deviceTypeRepository;
115
116		/**
117		* @var EntityManagerInterface
118		*/
119		protected $entityManager;
120
121		/**
122		* @var MobileDetector
123		*/
124		protected $mobileDetector;
125
126		/**
127		* @var TaxRuleRepository
128		*/
129		protected $taxRuleRepository;
130
131		public function __construct(
132		ContainerInterface $container,
133		EntityManagerInterface $entityManager,
134		OrderRepository $orderRepository,
135		OrderItemTypeRepository $orderItemTypeRepository,
136		OrderStatusRepository $orderStatusRepository,
137		DeliveryRepository $deliveryRepository,
138		PaymentRepository $paymentRepository,
139		DeviceTypeRepository $deviceTypeRepository,
140		PrefRepository $prefRepository,
141		TaxRuleRepository $taxRuleRepository,
142		MobileDetector $mobileDetector,
143		SessionInterface $session
144		) {
145		$this->container = $container;
146		$this->orderRepository = $orderRepository;
147		$this->orderStatusRepository = $orderStatusRepository;
148		$this->orderItemTypeRepository = $orderItemTypeRepository;
149		$this->deliveryRepository = $deliveryRepository;
150		$this->paymentRepository = $paymentRepository;
151		$this->deviceTypeRepository = $deviceTypeRepository;
152		$this->entityManager = $entityManager;
153		$this->prefRepository = $prefRepository;
154		$this->taxRuleRepository = $taxRuleRepository;
155		$this->mobileDetector = $mobileDetector;
156		$this->session = $session;
157		}
158
159		/**
160		* 購入処理中の受注を生成する.
161		*
162		* @param Customer $Customer
163		* @param $CartItems
164		*
165		* @return Order
166		*/
167		public function createPurchaseProcessingOrder(Cart $Cart, Customer $Customer)
168		{
169		$OrderStatus = $this->orderStatusRepository->find(OrderStatus::PROCESSING);
170		$Order = new Order($OrderStatus);
		0 ignored issues – show Bug introduced 2018-08-02 03:20 UTC by Report Bug Copy Issue Report It seems like `$OrderStatus` defined by `$this->orderStatusReposi...rderStatus::PROCESSING)` on line `169` can also be of type `object`; however, `Eccube\Entity\Order::__construct()` does only seem to accept `null\|object<Eccube\Entity\Master\OrderStatus>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
171
172		$preOrderId = $this->createPreOrderId();
173		$Order->setPreOrderId($preOrderId);
174
175		// 顧客情報の設定
176		$this->setCustomer($Order, $Customer);
177
178		$DeviceType = $this->deviceTypeRepository->find($this->mobileDetector->isMobile() ? DeviceType::DEVICE_TYPE_MB : DeviceType::DEVICE_TYPE_PC);
179		$Order->setDeviceType($DeviceType);
		0 ignored issues – show Bug introduced 2019-08-16 05:06 UTC by Report Bug Copy Issue Report It seems like `$DeviceType` defined by `$this->deviceTypeReposit...ceType::DEVICE_TYPE_PC)` on line `178` can also be of type `object`; however, `Eccube\Entity\Order::setDeviceType()` does only seem to accept `null\|object<Eccube\Entity\Master\DeviceType>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
180
181		// 明細情報の設定
182		$OrderItems = $this->createOrderItemsFromCartItems($Cart->getCartItems());
183		$OrderItemsGroupBySaleType = array_reduce($OrderItems, function ($result, $item) {
184		/* @var OrderItem $item */
185		$saleTypeId = $item->getProductClass()->getSaleType()->getId();
186		$result[$saleTypeId][] = $item;
187
188		return $result;
189		}, []);
190
191		foreach ($OrderItemsGroupBySaleType as $OrderItems) {
192		$Shipping = $this->createShippingFromCustomer($Customer);
193		$Shipping->setOrder($Order);
194		$this->addOrderItems($Order, $Shipping, $OrderItems);
195		$this->setDefaultDelivery($Shipping);
196		$this->entityManager->persist($Shipping);
197		$Order->addShipping($Shipping);
198		}
199
200		$this->setDefaultPayment($Order);
201
202		$this->entityManager->persist($Order);
203
204		return $Order;
205		}
206
207		/**
208		* @param Cart $Cart
209		*
210		* @return bool
211		*/
212		public function verifyCart(Cart $Cart)
213		{
214		if (count($Cart->getCartItems()) > 0) {
215		$divide = $this->session->get(self::SESSION_CART_DIVIDE_FLAG);
216		if ($divide) {
217		log_info('ログイン時に販売種別が異なる商品がカートと結合されました。');
218
219		return false;
220		}
221
222		return true;
223		}
224
225		log_info('カートに商品が入っていません。');
226
227		return false;
228		}
229
230		/**
231		* 注文手続き画面でログインが必要かどうかの判定
232		*
233		* @return bool
234		*/
235		public function isLoginRequired()
236		{
237		// フォームログイン済はログイン不要
238		if ($this->isGranted('IS_AUTHENTICATED_FULLY')) {
239		return false;
240		}
241
242		// Remember Meログイン済の場合はフォームからのログインが必要
243		if ($this->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
244		return true;
245		}
246
247		// 未ログインだがお客様情報を入力している場合はログイン不要
248		if (!$this->getUser() && $this->getNonMember()) {
249		return false;
250		}
251
252		return true;
253		}
254
255		/**
256		* 購入処理中の受注を取得する.
257		*
258		* @param null\|string $preOrderId
259		*
260		* @return null\|Order
261		*/
262		public function getPurchaseProcessingOrder($preOrderId = null)
263		{
264		if (null === $preOrderId) {
265		return null;
266		}
267
268		return $this->orderRepository->findOneBy([
269		'pre_order_id' => $preOrderId,
270		'OrderStatus' => OrderStatus::PROCESSING,
271		]);
272		}
273
274		/**
275		* セッションに保持されている非会員情報を取得する.
276		* 非会員購入時に入力されたお客様情報を返す.
277		*
278		* @return Customer
279		*/
280		public function getNonMember()
281		{
282		$NonMember = $this->session->get(self::SESSION_NON_MEMBER);
283		if ($NonMember && $NonMember->getPref()) {
284		$Pref = $this->prefRepository->find($NonMember->getPref()->getId());
285		$NonMember->setPref($Pref);
286		}
287
288		return $NonMember;
289		}
290
291		/**
292		* @param Cart $Cart
293		* @param Customer $Customer
294		*
295		* @return Order\|null
296		*/
297		public function initializeOrder(Cart $Cart, Customer $Customer)
298		{
299		// 購入処理中の受注情報を取得
300		if ($Order = $this->getPurchaseProcessingOrder($Cart->getPreOrderId())) {
301		return $Order;
302		}
303
304		// 受注情報を作成
305		$Order = $this->createPurchaseProcessingOrder($Cart, $Customer);
306		$Cart->setPreOrderId($Order->getPreOrderId());
307
308		return $Order;
309		}
310
311		public function removeSession()
312		{
313		$this->session->remove(self::SESSION_ORDER_ID);
314		$this->session->remove(self::SESSION_ORDER_ID);
315		$this->session->remove(self::SESSION_NON_MEMBER);
316		$this->session->remove(self::SESSION_NON_MEMBER_ADDRESSES);
317		}
318
319		/**
320		* 会員情報の更新日時が受注の作成日時よりも新しければ, 受注の注文者情報を更新する.
321		*
322		* @param Order $Order
323		* @param Customer $Customer
324		*/
325		public function updateCustomerInfo(Order $Order, Customer $Customer)
326		{
327		if ($Order->getCreateDate() < $Customer->getUpdateDate()) {
328		$this->setCustomer($Order, $Customer);
329		}
330		}
331
332		public function createPreOrderId()
333		{
334		// ランダムなpre_order_idを作成
335		do {
336		$preOrderId = sha1(StringUtil::random(32));
337
338		$Order = $this->orderRepository->findOneBy(
339		[
340		'pre_order_id' => $preOrderId,
341		]
342		);
343		} while ($Order);
344
345		return $preOrderId;
346		}
347
348		protected function setCustomer(Order $Order, Customer $Customer)
349		{
350		if ($Customer->getId()) {
351		$Order->setCustomer($Customer);
352		}
353
354		$Order->copyProperties(
355		$Customer,
356		[
357		'id',
358		'create_date',
359		'update_date',
360		'del_flg',
361		]
362		);
363		}
364
365		/**
366		* @param Collection\|ArrayCollection\|CartItem[] $CartItems
367		*
368		* @return OrderItem[]
369		*/
370		protected function createOrderItemsFromCartItems($CartItems)
371		{
372		$ProductItemType = $this->orderItemTypeRepository->find(OrderItemType::PRODUCT);
373
374		return array_map(function ($item) use ($ProductItemType) {
375		/* @var $item CartItem */
376		/* @var $ProductClass \Eccube\Entity\ProductClass */
377		$ProductClass = $item->getProductClass();
378		/* @var $Product \Eccube\Entity\Product */
379		$Product = $ProductClass->getProduct();
380		/** @var TaxRule $TaxRule */
381		$TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass)
382		?: $this->taxRuleRepository->getByRule();
383
384		$OrderItem = new OrderItem();
385		$OrderItem
386		->setProduct($Product)
387		->setProductClass($ProductClass)
388		->setProductName($Product->getName())
389		->setProductCode($ProductClass->getCode())
390		->setPrice($ProductClass->getPrice02())
391		->setQuantity($item->getQuantity())
392		->setOrderItemType($ProductItemType)
		0 ignored issues – show Bug introduced 2018-08-02 03:20 UTC by Report Bug Copy Issue Report It seems like `$ProductItemType` defined by `$this->orderItemTypeRepo...OrderItemType::PRODUCT)` on line `372` can also be of type `object`; however, `Eccube\Entity\OrderItem::setOrderItemType()` does only seem to accept `null\|object<Eccube\Entity\Master\OrderItemType>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
393		->setTax($TaxRule->getTaxRate())
394		->setTaxAdjust($TaxRule->getTaxAdjust())
395		->setRoundingType($TaxRule->getRoundingType());
396
397		$ClassCategory1 = $ProductClass->getClassCategory1();
398		if (!is_null($ClassCategory1)) {
399		$OrderItem->setClasscategoryName1($ClassCategory1->getName());
400		$OrderItem->setClassName1($ClassCategory1->getClassName()->getName());
401		}
402		$ClassCategory2 = $ProductClass->getClassCategory2();
403		if (!is_null($ClassCategory2)) {
404		$OrderItem->setClasscategoryName2($ClassCategory2->getName());
405		$OrderItem->setClassName2($ClassCategory2->getClassName()->getName());
406		}
407
408		return $OrderItem;
409		}, $CartItems instanceof Collection ? $CartItems->toArray() : $CartItems);
410		}
411
412		/**
413		* @param Customer $Customer
414		*
415		* @return Shipping
416		*/
417		protected function createShippingFromCustomer(Customer $Customer)
418		{
419		$Shipping = new Shipping();
420		$Shipping
421		->setName01($Customer->getName01())
422		->setName02($Customer->getName02())
423		->setKana01($Customer->getKana01())
424		->setKana02($Customer->getKana02())
425		->setCompanyName($Customer->getCompanyName())
426		->setPhoneNumber($Customer->getPhoneNumber())
427		->setPostalCode($Customer->getPostalCode())
428		->setPref($Customer->getPref())
429		->setAddr01($Customer->getAddr01())
430		->setAddr02($Customer->getAddr02());
431
432		return $Shipping;
433		}
434
435		/**
436		* @param Shipping $Shipping
437		*/
438		protected function setDefaultDelivery(Shipping $Shipping)
439		{
440		// 配送商品に含まれる販売種別を抽出.
441		$OrderItems = $Shipping->getOrderItems();
442		$SaleTypes = [];
443		/** @var OrderItem $OrderItem */
444	View Code Duplication	foreach ($OrderItems as $OrderItem) {
		0 ignored issues – show Duplication introduced 2018-08-02 03:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
445		$ProductClass = $OrderItem->getProductClass();
446		$SaleType = $ProductClass->getSaleType();
447		$SaleTypes[$SaleType->getId()] = $SaleType;
448		}
449
450		// 販売種別に紐づく配送業者を取得.
451		$Deliveries = $this->deliveryRepository->getDeliveries($SaleTypes);
452
453		// 初期の配送業者を設定
454		$Delivery = current($Deliveries);
455		$Shipping->setDelivery($Delivery);
456		$Shipping->setShippingDeliveryName($Delivery->getName());
457		}
458
459		/**
460		* @param Order $Order
461		*/
462		protected function setDefaultPayment(Order $Order)
463		{
464		$OrderItems = $Order->getOrderItems();
465
466		// 受注明細に含まれる販売種別を抽出.
467		$SaleTypes = [];
468		/** @var OrderItem $OrderItem */
469	View Code Duplication	foreach ($OrderItems as $OrderItem) {
		0 ignored issues – show Duplication introduced 2018-08-02 03:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
470		$ProductClass = $OrderItem->getProductClass();
471		if (is_null($ProductClass)) {
472		// 商品明細のみ対象とする. 送料明細等はスキップする.
473		continue;
474		}
475		$SaleType = $ProductClass->getSaleType();
476		$SaleTypes[$SaleType->getId()] = $SaleType;
477		}
478
479		// 販売種別に紐づく配送業者を抽出
480		$Deliveries = $this->deliveryRepository->getDeliveries($SaleTypes);
481
482		// 利用可能な支払い方法を抽出.
483		$Payments = $this->paymentRepository->findAllowedPayments($Deliveries, true);
484
485		// 初期の支払い方法を設定.
486		$Payment = current($Payments);
487		if ($Payment) {
488		$Order->setPayment($Payment);
489		$Order->setPaymentMethod($Payment->getMethod());
490		}
491		}
492
493		/**
494		* @param Order $Order
495		* @param Shipping $Shipping
496		* @param array $OrderItems
497		*/
498		protected function addOrderItems(Order $Order, Shipping $Shipping, array $OrderItems)
499		{
500		foreach ($OrderItems as $OrderItem) {
501		$Shipping->addOrderItem($OrderItem);
502		$Order->addOrderItem($OrderItem);
503		$OrderItem->setOrder($Order);
504		$OrderItem->setShipping($Shipping);
505		}
506		}
507		}
508

kiy0taka / ec-cube