OrderItemType::buildForm() - Code Metrics - Inspection of "Merge pull request #4302 from EC-CUBE/dev/reduced_..." - EC-CUBE/ec-cube - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — 4.0 ( f3e983...d5d6e1 )

by Ryo

created 2019-09-02 00:57 UTC

OrderItemType::buildForm() F

↳ Parent: OrderItemType

Complexity

Conditions	22
Paths	1

Size

Total Lines

165

Duplication

Lines	24
Ratio	14.55 %

Code Coverage

Tests	67
CRAP Score	22.5879

Importance

Changes

Metric	Value
cc	22
nc	1
nop	2
dl	24
loc	165
ccs	67
cts	75
cp	0.8933
crap	22.5879
rs	3.3333
c	0
b	0
f	0

How to fix Long Method Complexity

<?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\Form\Type\Admin;

use Doctrine\ORM\EntityManagerInterface;
use Eccube\Common\EccubeConfig;
use Eccube\Entity\BaseInfo;
use Eccube\Entity\Master\OrderItemType as OrderItemTypeMaster;
use Eccube\Entity\Master\TaxType;
use Eccube\Entity\OrderItem;
use Eccube\Entity\ProductClass;
use Eccube\Form\DataTransformer;
use Eccube\Form\Type\PriceType;
use Eccube\Repository\BaseInfoRepository;
use Eccube\Repository\Master\OrderItemTypeRepository;
use Eccube\Repository\OrderItemRepository;
use Eccube\Repository\ProductClassRepository;
use Eccube\Repository\TaxRuleRepository;
use Eccube\Util\StringUtil;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\Extension\Core\Type\IntegerType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormError;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class OrderItemType extends AbstractType
{
    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    /**
     * @var EccubeConfig
     */
    protected $eccubeConfig;

    /**
     * @var BaseInfo
     */
    protected $BaseInfo;

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

    /**
     * @var OrderItemRepository
     */
    protected $orderItemRepository;

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

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

    /**
     * @var ValidatorInterface
     */
    protected $validator;

    /**
     * OrderItemType constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param EccubeConfig $eccubeConfig
     * @param BaseInfoRepository $baseInfoRepository
     * @param ProductClassRepository $productClassRepository
     * @param OrderItemRepository $orderItemRepository
     * @param OrderItemTypeRepository $orderItemTypeRepository
     * @param TaxRuleRepository $taxRuleRepository
     * @param ValidatorInterface $validator
     *
     * @throws \Exception
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        EccubeConfig $eccubeConfig,
        BaseInfoRepository $baseInfoRepository,
        ProductClassRepository $productClassRepository,
        OrderItemRepository $orderItemRepository,
        OrderItemTypeRepository $orderItemTypeRepository,
        TaxRuleRepository $taxRuleRepository,
        ValidatorInterface $validator
    ) {
        $this->entityManager = $entityManager;
        $this->eccubeConfig = $eccubeConfig;
        $this->BaseInfo = $baseInfoRepository->get();
        $this->productClassRepository = $productClassRepository;
        $this->orderItemRepository = $orderItemRepository;
        $this->orderItemTypeRepository = $orderItemTypeRepository;
        $this->taxRuleRepository = $taxRuleRepository;
        $this->validator = $validator;
    }

    /**
     * {@inheritdoc}
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('product_name', TextType::class, [
                'constraints' => [
                    new Assert\NotBlank(),
                    new Assert\Length([
                        'max' => $this->eccubeConfig['eccube_mtext_len'],
                    ]),
                ],
            ])
            ->add('price', PriceType::class, [
                'accept_minus' => true,
            ])
            ->add('quantity', IntegerType::class, [
                'constraints' => [
                    new Assert\NotBlank(),
                    new Assert\Length([
                        'max' => $this->eccubeConfig['eccube_int_len'],
                    ]),
                ],
            ])
            ->add('tax_rate', IntegerType::class, [
                'required' => true,
                'constraints' => [
                    new Assert\NotBlank(),
                    new Assert\Range(['min' => 0]),
                    new Assert\Regex([
                        'pattern' => "/^\d+(\.\d+)?$/u",
                        'message' => 'form_error.float_only',
                    ]),
                ],
            ]);

        $builder
            ->add($builder->create('order_item_type', HiddenType::class)
                ->addModelTransformer(new DataTransformer\EntityToIdTransformer(
                    $this->entityManager,
                    OrderItemTypeMaster::class
                )))
            ->add($builder->create('tax_type', HiddenType::class)
                ->addModelTransformer(new DataTransformer\EntityToIdTransformer(
                    $this->entityManager,
                    TaxType::class
                )))
            ->add($builder->create('ProductClass', HiddenType::class)
                ->addModelTransformer(new DataTransformer\EntityToIdTransformer(
                    $this->entityManager,
                    ProductClass::class
                )));

        // 受注明細フォームの税率を補完する
        $builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) {
            $OrderItem = $event->getData();

            if (!isset($OrderItem['tax_rate']) || StringUtil::isBlank($OrderItem['tax_rate'])) {
                $orderItemTypeId = $OrderItem['order_item_type'];

                if ($orderItemTypeId == OrderItemTypeMaster::PRODUCT) {
                    /** @var ProductClass $ProductClass */
                    $ProductClass = $this->productClassRepository->find($OrderItem['ProductClass']);
                    $Product = $ProductClass->getProduct();
                    $TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass);

                    if (!isset($OrderItem['tax_type']) || StringUtil::isBlank($OrderItem['tax_type'])) {
                        $OrderItem['tax_type'] = TaxType::TAXATION;
                    }

                } else {
                    if ($orderItemTypeId == OrderItemTypeMaster::DISCOUNT && $OrderItem['tax_type'] == TaxType::NON_TAXABLE) {
                        $OrderItem['tax_rate'] = '0';
                        $event->setData($OrderItem);

                        return;
                    }

                    $TaxRule = $this->taxRuleRepository->getByRule();
                }

                $OrderItem['tax_rate'] = $TaxRule->getTaxRate();
                $event->setData($OrderItem);
            }
        });

        $builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
            /** @var OrderItem $OrderItem */
            $OrderItem = $event->getData();

            $OrderItemType = $OrderItem->getOrderItemType();

            switch ($OrderItemType->getId()) {
                case OrderItemTypeMaster::PRODUCT:
                    $ProductClass = $OrderItem->getProductClass();
                    $Product = $ProductClass->getProduct();
                    $OrderItem->setProduct($Product);
                    if (null === $OrderItem->getPrice()) {
                        $OrderItem->setPrice($ProductClass->getPrice02());
                    }
                    if (null === $OrderItem->getProductCode()) {
                        $OrderItem->setProductCode($ProductClass->getCode());
                    }
                    if (null === $OrderItem->getClassName1() && $ProductClass->hasClassCategory1()) {
                        $ClassCategory1 = $ProductClass->getClassCategory1();
                        $OrderItem->setClassName1($ClassCategory1->getClassName()->getName());
                        $OrderItem->setClassCategoryName1($ClassCategory1->getName());
                    }
                    if (null === $OrderItem->getClassName2() && $ProductClass->hasClassCategory2()) {
                        if ($ClassCategory2 = $ProductClass->getClassCategory2()) {
                            $OrderItem->setClassName2($ClassCategory2->getClassName()->getName());
                            $OrderItem->setClassCategoryName2($ClassCategory2->getName());
                        }
                    }
                    if (null === $OrderItem->getRoundingType()) {
                        $TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass);
                        $OrderItem->setRoundingType($TaxRule->getRoundingType())
                            ->setTaxAdjust($TaxRule->getTaxAdjust());
                    }
                    break;
                default:
                    if (null === $OrderItem->getRoundingType()) {
                        $TaxRule = $this->taxRuleRepository->getByRule();
                        $OrderItem->setRoundingType($TaxRule->getRoundingType())
                            ->setTaxAdjust($TaxRule->getTaxAdjust());
                    }
            }
        });

        // price, quantityのバリデーション
        $builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
            $form = $event->getForm();
            /** @var OrderItem $OrderItem */
            $OrderItem = $event->getData();

            $OrderItemType = $OrderItem->getOrderItemType();
            switch ($OrderItemType->getId()) {
                // 商品明細: 金額 -> 正, 個数 -> 正負
                case OrderItemTypeMaster::PRODUCT:
                    $errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\GreaterThanOrEqual(0)]);
                    $this->addErrorsIfExists($form['price'], $errors);
                    break;

                // 値引き明細: 金額 -> 負, 個数 -> 正
                case OrderItemTypeMaster::DISCOUNT:
                    $errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\LessThanOrEqual(0)]);
                    $this->addErrorsIfExists($form['price'], $errors);
                    $errors = $this->validator->validate($OrderItem->getQuantity(), [new Assert\GreaterThanOrEqual(0)]);
                    $this->addErrorsIfExists($form['quantity'], $errors);

                    break;

                // 送料, 手数料: 金額 -> 正, 個数 -> 正
                case OrderItemTypeMaster::DELIVERY_FEE:
                case OrderItemTypeMaster::CHARGE:
                    $errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\GreaterThanOrEqual(0)]);
                    $this->addErrorsIfExists($form['price'], $errors);
                    $errors = $this->validator->validate($OrderItem->getQuantity(), [new Assert\GreaterThanOrEqual(0)]);
                    $this->addErrorsIfExists($form['quantity'], $errors);

                    break;

                default:
                    break;
            }
        });
    }

    /**
     * {@inheritdoc}
     */
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => OrderItem::class,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function getBlockPrefix()
    {
        return 'order_item';
    }

    /**
     * @param FormInterface $form
     * @param ConstraintViolationListInterface $errors
     */
    protected function addErrorsIfExists(FormInterface $form, ConstraintViolationListInterface $errors)
    {
        if (empty($errors)) {
            return;
        }

        foreach ($errors as $error) {
            $form->addError(new FormError(
                $error->getMessage(),
                $error->getMessageTemplate(),
                $error->getParameters(),
                $error->getPlural()));
        }
    }
}


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\Form\Type\Admin;
15
16			use Doctrine\ORM\EntityManagerInterface;
17			use Eccube\Common\EccubeConfig;
18			use Eccube\Entity\BaseInfo;
19			use Eccube\Entity\Master\OrderItemType as OrderItemTypeMaster;
20			use Eccube\Entity\Master\TaxType;
21			use Eccube\Entity\OrderItem;
22			use Eccube\Entity\ProductClass;
23			use Eccube\Form\DataTransformer;
24			use Eccube\Form\Type\PriceType;
25			use Eccube\Repository\BaseInfoRepository;
26			use Eccube\Repository\Master\OrderItemTypeRepository;
27			use Eccube\Repository\OrderItemRepository;
28			use Eccube\Repository\ProductClassRepository;
29			use Eccube\Repository\TaxRuleRepository;
30			use Eccube\Util\StringUtil;
31			use Symfony\Component\Form\AbstractType;
32			use Symfony\Component\Form\Extension\Core\Type\HiddenType;
33			use Symfony\Component\Form\Extension\Core\Type\IntegerType;
34			use Symfony\Component\Form\Extension\Core\Type\TextType;
35			use Symfony\Component\Form\FormBuilderInterface;
36			use Symfony\Component\Form\FormError;
37			use Symfony\Component\Form\FormEvent;
38			use Symfony\Component\Form\FormEvents;
39			use Symfony\Component\Form\FormInterface;
40			use Symfony\Component\OptionsResolver\OptionsResolver;
41			use Symfony\Component\Validator\Constraints as Assert;
42			use Symfony\Component\Validator\ConstraintViolationListInterface;
43			use Symfony\Component\Validator\Validator\ValidatorInterface;
44
45			class OrderItemType extends AbstractType
46			{
47			/**
48			* @var EntityManagerInterface
49			*/
50			protected $entityManager;
51
52			/**
53			* @var EccubeConfig
54			*/
55			protected $eccubeConfig;
56
57			/**
58			* @var BaseInfo
59			*/
60			protected $BaseInfo;
61
62			/**
63			* @var ProductClassRepository
64			*/
65			protected $productClassRepository;
66
67			/**
68			* @var OrderItemRepository
69			*/
70			protected $orderItemRepository;
71
72			/**
73			* @var OrderItemTypeRepository
74			*/
75			protected $orderItemTypeRepository;
76
77			/**
78			* @var TaxRuleRepository
79			*/
80			protected $taxRuleRepository;
81
82			/**
83			* @var ValidatorInterface
84			*/
85			protected $validator;
86
87			/**
88			* OrderItemType constructor.
89			*
90			* @param EntityManagerInterface $entityManager
91			* @param EccubeConfig $eccubeConfig
92			* @param BaseInfoRepository $baseInfoRepository
93	32		* @param ProductClassRepository $productClassRepository
94			* @param OrderItemRepository $orderItemRepository
95			* @param OrderItemTypeRepository $orderItemTypeRepository
96			* @param TaxRuleRepository $taxRuleRepository
97			* @param ValidatorInterface $validator
98			*
99			* @throws \Exception
100			*/
101			public function __construct(
102			EntityManagerInterface $entityManager,
103	32		EccubeConfig $eccubeConfig,
104	32		BaseInfoRepository $baseInfoRepository,
105	32		ProductClassRepository $productClassRepository,
106	32		OrderItemRepository $orderItemRepository,
107	32		OrderItemTypeRepository $orderItemTypeRepository,
108	32		TaxRuleRepository $taxRuleRepository,
109	32		ValidatorInterface $validator
110	32		) {
111			$this->entityManager = $entityManager;
112			$this->eccubeConfig = $eccubeConfig;
113			$this->BaseInfo = $baseInfoRepository->get();
114			$this->productClassRepository = $productClassRepository;
115			$this->orderItemRepository = $orderItemRepository;
116	32		$this->orderItemTypeRepository = $orderItemTypeRepository;
117			$this->taxRuleRepository = $taxRuleRepository;
118			$this->validator = $validator;
119	32		}
120
121	32		/**
122	32		* {@inheritdoc}
123	32		*/
124			public function buildForm(FormBuilderInterface $builder, array $options)
125			{
126			$builder
127	32		->add('product_name', TextType::class, [
128	32		'constraints' => [
129			new Assert\NotBlank(),
130	32		new Assert\Length([
131			'max' => $this->eccubeConfig['eccube_mtext_len'],
132	32		]),
133	32		],
134	32		])
135			->add('price', PriceType::class, [
136			'accept_minus' => true,
137			])
138			->add('quantity', IntegerType::class, [
139			'constraints' => [
140	32		new Assert\NotBlank(),
141	32		new Assert\Length([
142	32		'max' => $this->eccubeConfig['eccube_int_len'],
143	32		]),
144			],
145	32		])
146	32		->add('tax_rate', IntegerType::class, [
147	32		'required' => true,
148	32		'constraints' => [
149			new Assert\NotBlank(),
150			new Assert\Range(['min' => 0]),
151	32		new Assert\Regex([
152			'pattern' => "/^\d+(\.\d+)?$/u",
153	19		'message' => 'form_error.float_only',
154			]),
155	19		],
156	19		]);
157	19
158	18		$builder
159	18		->add($builder->create('order_item_type', HiddenType::class)
160	18		->addModelTransformer(new DataTransformer\EntityToIdTransformer(
161	18		$this->entityManager,
162	1		OrderItemTypeMaster::class
163			)))
164	18		->add($builder->create('tax_type', HiddenType::class)
165	13		->addModelTransformer(new DataTransformer\EntityToIdTransformer(
166			$this->entityManager,
167	18		TaxType::class
168	13		)))
169	13		->add($builder->create('ProductClass', HiddenType::class)
170	13		->addModelTransformer(new DataTransformer\EntityToIdTransformer(
171			$this->entityManager,
172	18		ProductClass::class
173	8		)));
174	8
175	8		// 受注明細フォームの税率を補完する
176			$builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) {
177			$OrderItem = $event->getData();
178	18
179			if (!isset($OrderItem['tax_rate']) \|\| StringUtil::isBlank($OrderItem['tax_rate'])) {
180			$orderItemTypeId = $OrderItem['order_item_type'];
181	4
182			if ($orderItemTypeId == OrderItemTypeMaster::PRODUCT) {
183	32		/** @var ProductClass $ProductClass */
184			$ProductClass = $this->productClassRepository->find($OrderItem['ProductClass']);
185			$Product = $ProductClass->getProduct();
186	32		$TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass);
187	19
188			if (!isset($OrderItem['tax_type']) \|\| StringUtil::isBlank($OrderItem['tax_type'])) {
189	19		$OrderItem['tax_type'] = TaxType::TAXATION;
190			}
191	19
192	19		} else {
193			if ($orderItemTypeId == OrderItemTypeMaster::DISCOUNT && $OrderItem['tax_type'] == TaxType::NON_TAXABLE) {
194	19		$OrderItem['tax_rate'] = '0';
195	18		$event->setData($OrderItem);
196	18
197	18		return;
198			}
199
200	4		$TaxRule = $this->taxRuleRepository->getByRule();
201	1		}
202	1
203	1		$OrderItem['tax_rate'] = $TaxRule->getTaxRate();
204	1		$event->setData($OrderItem);
205			}
206	1		});
207
208			$builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
209	3		/** @var OrderItem $OrderItem */
210			$OrderItem = $event->getData();
211	3
212	3		$OrderItemType = $OrderItem->getOrderItemType();
213	3
214	3		switch ($OrderItemType->getId()) {
215			case OrderItemTypeMaster::PRODUCT:
216	3		$ProductClass = $OrderItem->getProductClass();
217			$Product = $ProductClass->getProduct();
218			$OrderItem->setProduct($Product);
219			if (null === $OrderItem->getPrice()) {
220			$OrderItem->setPrice($ProductClass->getPrice02());
221	32		}
222			if (null === $OrderItem->getProductCode()) {
223			$OrderItem->setProductCode($ProductClass->getCode());
224			}
225			if (null === $OrderItem->getClassName1() && $ProductClass->hasClassCategory1()) {
226			$ClassCategory1 = $ProductClass->getClassCategory1();
227	32		$OrderItem->setClassName1($ClassCategory1->getClassName()->getName());
228			$OrderItem->setClassCategoryName1($ClassCategory1->getName());
229	32		}
230	32		if (null === $OrderItem->getClassName2() && $ProductClass->hasClassCategory2()) {
231			if ($ClassCategory2 = $ProductClass->getClassCategory2()) {
232			$OrderItem->setClassName2($ClassCategory2->getClassName()->getName());
233			$OrderItem->setClassCategoryName2($ClassCategory2->getName());
234			}
235			}
236		View Code Duplication	if (null === $OrderItem->getRoundingType()) {
237	16		$TaxRule = $this->taxRuleRepository->getByRule($Product, $ProductClass);
238			$OrderItem->setRoundingType($TaxRule->getRoundingType())
239	16		->setTaxAdjust($TaxRule->getTaxAdjust());
240			}
241			break;
242			default:
243		View Code Duplication	if (null === $OrderItem->getRoundingType()) {
244			$TaxRule = $this->taxRuleRepository->getByRule();
245			$OrderItem->setRoundingType($TaxRule->getRoundingType())
246	19		->setTaxAdjust($TaxRule->getTaxAdjust());
247			}
248	19		}
249			});
250
251			// price, quantityのバリデーション
252	19		$builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
253			$form = $event->getForm();
254			/** @var OrderItem $OrderItem */
255			$OrderItem = $event->getData();
256
257			$OrderItemType = $OrderItem->getOrderItemType();
258			switch ($OrderItemType->getId()) {
259			// 商品明細: 金額 -> 正, 個数 -> 正負
260			case OrderItemTypeMaster::PRODUCT:
261			$errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\GreaterThanOrEqual(0)]);
262			$this->addErrorsIfExists($form['price'], $errors);
263			break;
264
265			// 値引き明細: 金額 -> 負, 個数 -> 正
266		View Code Duplication	case OrderItemTypeMaster::DISCOUNT:
267			$errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\LessThanOrEqual(0)]);
268			$this->addErrorsIfExists($form['price'], $errors);
269			$errors = $this->validator->validate($OrderItem->getQuantity(), [new Assert\GreaterThanOrEqual(0)]);
270			$this->addErrorsIfExists($form['quantity'], $errors);
271
272			break;
273
274			// 送料, 手数料: 金額 -> 正, 個数 -> 正
275			case OrderItemTypeMaster::DELIVERY_FEE:
276		View Code Duplication	case OrderItemTypeMaster::CHARGE:
277			$errors = $this->validator->validate($OrderItem->getPrice(), [new Assert\GreaterThanOrEqual(0)]);
278			$this->addErrorsIfExists($form['price'], $errors);
279			$errors = $this->validator->validate($OrderItem->getQuantity(), [new Assert\GreaterThanOrEqual(0)]);
280			$this->addErrorsIfExists($form['quantity'], $errors);
281
282			break;
283
284			default:
285			break;
286			}
287			});
288			}
289
290			/**
291			* {@inheritdoc}
292			*/
293			public function configureOptions(OptionsResolver $resolver)
294			{
295			$resolver->setDefaults([
296			'data_class' => OrderItem::class,
297			]);
298			}
299
300			/**
301			* {@inheritdoc}
302			*/
303			public function getBlockPrefix()
304			{
305			return 'order_item';
306			}
307
308			/**
309			* @param FormInterface $form
310			* @param ConstraintViolationListInterface $errors
311			*/
312			protected function addErrorsIfExists(FormInterface $form, ConstraintViolationListInterface $errors)
313			{
314			if (empty($errors)) {
315			return;
316			}
317
318			foreach ($errors as $error) {
319			$form->addError(new FormError(
320			$error->getMessage(),
321			$error->getMessageTemplate(),
322			$error->getParameters(),
323			$error->getPlural()));
324			}
325			}
326			}
327

EC-CUBE / ec-cube

Push — 4.0 ( f3e983...d5d6e1 )

OrderItemType::buildForm() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like