PutItemsToCartAction::__invoke() - Code Metrics - Sylius/SyliusShopApiPlugin - Measure and Improve Code Quality continuously with Scrutinizer

PutItemsToCartAction::__invoke() B
last analyzed 2018-08-20 13:37 UTC

↳ Parent: PutItemsToCartAction

Complexity

Conditions	9
Paths	42

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	56
rs	7.4044
c	0
b	0
f	0
cc	9
nc	42
nop	1

How to fix Long Method

<?php

declare(strict_types=1);

namespace Sylius\ShopApiPlugin\Controller\Cart;

use FOS\RestBundle\View\View;
use FOS\RestBundle\View\ViewHandlerInterface;
use League\Tactician\CommandBus;
use Sylius\ShopApiPlugin\Request\PutOptionBasedConfigurableItemToCartRequest;
use Sylius\ShopApiPlugin\Request\PutSimpleItemToCartRequest;
use Sylius\ShopApiPlugin\Request\PutVariantBasedConfigurableItemToCartRequest;
use Sylius\ShopApiPlugin\View\ValidationErrorView;
use Sylius\ShopApiPlugin\ViewRepository\CartViewRepositoryInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Validator\ConstraintViolationInterface;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

final class PutItemsToCartAction
{
    /** @var ViewHandlerInterface */
    private $viewHandler;

    /** @var CommandBus */
    private $bus;

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

    /** @var CartViewRepositoryInterface */
    private $cartQuery;

    /** @var string */
    private $validationErrorViewClass;

    public function __construct(
        ViewHandlerInterface $viewHandler,
        CommandBus $bus,
        ValidatorInterface $validator,
        CartViewRepositoryInterface $cartQuery,
        string $validationErrorViewClass
    ) {
        $this->viewHandler = $viewHandler;
        $this->bus = $bus;
        $this->validator = $validator;
        $this->cartQuery = $cartQuery;
        $this->validationErrorViewClass = $validationErrorViewClass;
    }

    public function __invoke(Request $request): Response
    {
        /** @var ConstraintViolationListInterface[] $validationResults */
        $validationResults = [];
        $commandRequests = [];
        $commandsToExecute = [];
        $token = $request->attributes->get('token');

        foreach ($request->request->all() as $item) {
            $item['token'] = $token;
            $commandRequests[] = $this->provideCommandRequest($item);
        }

        foreach ($commandRequests as $commandRequest) {
            $validationResult = $this->validator->validate($commandRequest);

            if (0 === count($validationResult)) {
                $commandsToExecute[] = $commandRequest->getCommand();
            }

            $validationResults[] = $validationResult;
        }

        if (!$this->isValid($validationResults)) {
            /** @var ValidationErrorView $errorMessage */
            $errorMessage = new $this->validationErrorViewClass();

            $errorMessage->code = Response::HTTP_BAD_REQUEST;
            $errorMessage->message = 'Validation failed';

            foreach ($validationResults as $validationResult) {
                $errors = [];

                /** @var ConstraintViolationInterface $result */
                foreach ($validationResult as $result) {
                    $errors[$result->getPropertyPath()][] = $result->getMessage();
                }

                $errorMessage->errors[] = $errors;
            }

            return $this->viewHandler->handle(View::create($errorMessage, Response::HTTP_BAD_REQUEST));
        }

        foreach ($commandsToExecute as $commandToExecute) {
            $this->bus->handle($commandToExecute);
        }

        try {
            return $this->viewHandler->handle(
                View::create($this->cartQuery->getOneByToken($token), Response::HTTP_CREATED)
            );
        } catch (\InvalidArgumentException $exception) {
            throw new BadRequestHttpException($exception->getMessage());
        }
    }

    /**
     * @param array $item
     *
     * @return PutOptionBasedConfigurableItemToCartRequest|PutSimpleItemToCartRequest|PutVariantBasedConfigurableItemToCartRequest
     */
    private function provideCommandRequest(array $item)
    {
        if (!isset($item['variantCode']) && !isset($item['options'])) {
            return PutSimpleItemToCartRequest::fromArray($item);
        }

        if (isset($item['variantCode']) && !isset($item['options'])) {
            return PutVariantBasedConfigurableItemToCartRequest::fromArray($item);
        }

        if (!isset($item['variantCode']) && isset($item['options'])) {
            return PutOptionBasedConfigurableItemToCartRequest::fromArray($item);
        }

        throw new NotFoundHttpException('Variant not found for given configuration');
    }

    private function isValid(array $validationResults): bool
    {
        foreach ($validationResults as $validationResult) {
            if (0 !== count($validationResult)) {
                return false;
            }
        }

        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Sylius\ShopApiPlugin\Controller\Cart;
6
7			use FOS\RestBundle\View\View;
8			use FOS\RestBundle\View\ViewHandlerInterface;
9			use League\Tactician\CommandBus;
10			use Sylius\ShopApiPlugin\Request\PutOptionBasedConfigurableItemToCartRequest;
11			use Sylius\ShopApiPlugin\Request\PutSimpleItemToCartRequest;
12			use Sylius\ShopApiPlugin\Request\PutVariantBasedConfigurableItemToCartRequest;
13			use Sylius\ShopApiPlugin\View\ValidationErrorView;
14			use Sylius\ShopApiPlugin\ViewRepository\CartViewRepositoryInterface;
15			use Symfony\Component\HttpFoundation\Request;
16			use Symfony\Component\HttpFoundation\Response;
17			use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
18			use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
19			use Symfony\Component\Validator\ConstraintViolationInterface;
20			use Symfony\Component\Validator\ConstraintViolationListInterface;
21			use Symfony\Component\Validator\Validator\ValidatorInterface;
22
23			final class PutItemsToCartAction
24			{
25			/** @var ViewHandlerInterface */
26			private $viewHandler;
27
28			/** @var CommandBus */
29			private $bus;
30
31			/** @var ValidatorInterface */
32			private $validator;
33
34			/** @var CartViewRepositoryInterface */
35			private $cartQuery;
36
37			/** @var string */
38			private $validationErrorViewClass;
39
40			public function __construct(
41			ViewHandlerInterface $viewHandler,
42			CommandBus $bus,
43			ValidatorInterface $validator,
44			CartViewRepositoryInterface $cartQuery,
45			string $validationErrorViewClass
46			) {
47			$this->viewHandler = $viewHandler;
48			$this->bus = $bus;
49			$this->validator = $validator;
50			$this->cartQuery = $cartQuery;
51			$this->validationErrorViewClass = $validationErrorViewClass;
52			}
53
54			public function __invoke(Request $request): Response
55			{
56			/** @var ConstraintViolationListInterface[] $validationResults */
57			$validationResults = [];
58			$commandRequests = [];
59			$commandsToExecute = [];
60			$token = $request->attributes->get('token');
61
62			foreach ($request->request->all() as $item) {
63			$item['token'] = $token;
64			$commandRequests[] = $this->provideCommandRequest($item);
65			}
66
67			foreach ($commandRequests as $commandRequest) {
68			$validationResult = $this->validator->validate($commandRequest);
69
70			if (0 === count($validationResult)) {
71			$commandsToExecute[] = $commandRequest->getCommand();
72			}
73
74			$validationResults[] = $validationResult;
75			}
76
77			if (!$this->isValid($validationResults)) {
78			/** @var ValidationErrorView $errorMessage */
79			$errorMessage = new $this->validationErrorViewClass();
80
81			$errorMessage->code = Response::HTTP_BAD_REQUEST;
82			$errorMessage->message = 'Validation failed';
83
84			foreach ($validationResults as $validationResult) {
85			$errors = [];
86
87			/** @var ConstraintViolationInterface $result */
88			foreach ($validationResult as $result) {
89			$errors[$result->getPropertyPath()][] = $result->getMessage();
90			}
91
92			$errorMessage->errors[] = $errors;
93			}
94
95			return $this->viewHandler->handle(View::create($errorMessage, Response::HTTP_BAD_REQUEST));
96			}
97
98			foreach ($commandsToExecute as $commandToExecute) {
99			$this->bus->handle($commandToExecute);
100			}
101
102			try {
103			return $this->viewHandler->handle(
104			View::create($this->cartQuery->getOneByToken($token), Response::HTTP_CREATED)
105			);
106			} catch (\InvalidArgumentException $exception) {
107			throw new BadRequestHttpException($exception->getMessage());
108			}
109			}
110
111			/**
112			* @param array $item
113			*
114			* @return PutOptionBasedConfigurableItemToCartRequest\|PutSimpleItemToCartRequest\|PutVariantBasedConfigurableItemToCartRequest
115			*/
116			private function provideCommandRequest(array $item)
117			{
118			if (!isset($item['variantCode']) && !isset($item['options'])) {
119			return PutSimpleItemToCartRequest::fromArray($item);
120			}
121
122			if (isset($item['variantCode']) && !isset($item['options'])) {
123			return PutVariantBasedConfigurableItemToCartRequest::fromArray($item);
124			}
125
126			if (!isset($item['variantCode']) && isset($item['options'])) {
127			return PutOptionBasedConfigurableItemToCartRequest::fromArray($item);
128			}
129
130			throw new NotFoundHttpException('Variant not found for given configuration');
131			}
132
133			private function isValid(array $validationResults): bool
134			{
135			foreach ($validationResults as $validationResult) {
136			if (0 !== count($validationResult)) {
137			return false;
138			}
139			}
140
141			return true;
142			}
143			}
144

Sylius / SyliusShopApiPlugin

PutItemsToCartAction::__invoke() B last analyzed 2018-08-20 13:37 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

PutItemsToCartAction::__invoke() B
last analyzed 2018-08-20 13:37 UTC