FormSubmitHandler::__construct() - Code Metrics - Inspection of "Form submissions and events" - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — v2 ( 7912ef...ccc702 )

by Daniel
created 2020-03-09 22:04 UTC
FormSubmitHandler::__construct() A

↳ Parent: FormSubmitHandler
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	5
rs	10
<?php

/*
 * This file is part of the Silverback API Component Bundle Project
 *
 * (c) Daniel West <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentBundle\Form\Handler;

use InvalidArgumentException;
use Silverback\ApiComponentBundle\ApiComponentBundleEvents;
use Silverback\ApiComponentBundle\Dto\Form\FormView;
use Silverback\ApiComponentBundle\Entity\Component\Form;
use Silverback\ApiComponentBundle\Event\FormSuccessEvent;
use Silverback\ApiComponentBundle\Form\Factory\FormFactory;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\Serializer\SerializerInterface;
use function json_decode;

/**
 * @author Daniel West <[email protected]>
 */
class FormSubmitHandler
{
    private FormFactory $formFactory;
    private EventDispatcher $eventDispatcher;
    private SerializerInterface $serializer;

    public function __construct(FormFactory $formFactory, EventDispatcher $eventDispatcher, SerializerInterface $serializer)
    {
        $this->formFactory = $formFactory;
        $this->eventDispatcher = $eventDispatcher;
        $this->serializer = $serializer;
    }

    public function handle(Request $request, Form $formResource): Response
    {
        $contentType = $request->headers->get('CONTENT_TYPE');
        $builder = $this->formFactory->create($formResource);
        $form = $builder->getForm();
        $formData = $this->deserializeFormData($form, $request->getContent());
        $isPatchRequest = Request::METHOD_PATCH === $request->getMethod();
        $form->submit($formData, !$isPatchRequest);
        $_format = $request->attributes->get('_format') ?: $request->getFormat($contentType);
        if ($isPatchRequest) {
            return $this->handlePatch($formResource, $form, $_format, $formData);
        }

        return $this->handlePost($formResource, $form, $_format);
    }

    private function handlePatch(Form $formResource, FormInterface $form, $_format, array $formData): Response
    {
        $isFormViewValid = static function (FormView $formView): bool {
            return $formView->getVars()['valid'];
        };

        $dataCount = \count($formData);
        if (1 === $dataCount) {
            $formItem = $this->getChildFormByKey($form, $formData);
            $formResource->form = $formView = new FormView($formItem);

            return $this->getResponse($formResource, $_format, $isFormViewValid($formView));
        }

        $formResources = [];
        $valid = true;
        foreach ($formData as $key => $value) {
            $dataItem = clone $formResource;
            $formItem = $this->getChildFormByKey($form, $formData[$key]);
            $dataItem->form = $formView = new FormView($formItem);
            $formResources[] = $dataItem;
            if ($valid && !$isFormViewValid($formView)) {
                $valid = false;
            }
        }

        return $this->getResponse($formResources, $_format, $valid);
    }

    private function handlePost(Form $formResource, FormInterface $form, $_format): Response
    {
        $valid = $form->isValid();
        $formResource->form = new FormView($form);
        $context = null;
        if ($valid) {
            $event = new FormSuccessEvent($formResource, $form);
            $this->eventDispatcher->dispatch($event, ApiComponentBundleEvents::FORM_SUCCESS);
            $context = $event->serializerContext;
        }

        return $this->getResponse($formResource, $_format, $valid, $context);
    }

    private function deserializeFormData(FormInterface $form, $content): array
    {
        try {
            $decoded = json_decode($content, true, 512, JSON_THROW_ON_ERROR | 0);
        } catch (\JsonException $exception) {
            throw new InvalidArgumentException('json_decode error: ' . $exception->getMessage());
        }
        if (!isset($decoded[$form->getName()])) {
            throw new BadRequestHttpException(sprintf('Form object key could not be found. Expected: <b>%s</b>: { "input_name": "input_value" }', $form->getName()));
        }

        return $decoded[$form->getName()];
    }

    private function getChildFormByKey(FormInterface $form, array $formData): FormInterface
    {
        $child = $form->get($key = key($formData));
        while (\is_array($formData = $formData[$key]) && $count = \count($formData)) {
            if (!$this->isAssocArray($formData) && $this->arrayIsStrings($formData)) {
                break;
            }

            if (1 === $count) {
                $child = $child->get($key = key($formData));
                continue;
            }
            // front-end should submit empty objects for each item in a collection up to the one we are trying to validate
            // so let us just get the last item to validate
            // key should be numeric, if not it is probably first and second for repeated field. These should both be checked...
            $key = ($count - 1);
            if (!$child->has($key)) {
                break;
            }
            $child = $child->get($key);
        }

        return $child;
    }

    private function isAssocArray(array $arr): bool
    {
        if ([] === $arr) {
            return false;
        }

        return array_keys($arr) !== range(0, \count($arr) - 1);
    }

    private function arrayIsStrings(array $arr): bool
    {
        foreach ($arr as $item) {
            if (!\is_string($item)) {
                return false;
            }
        }

        return true;
    }

    private function getResponse(
        $data,
        $_format,
        $valid,
        ?array $context = null
    ): Response {
        $response = new Response();
//        if (!$context) {
//            $context = ['groups' => ['component']];
//        }
        $response->setStatusCode($valid ? Response::HTTP_OK : Response::HTTP_BAD_REQUEST);
        $response->setContent($this->serializer->serialize($data, $_format, $context));
        $response->setContent($this->serializer->serialize($data, $_format, /** @scrutinizer ignore-type */ $context));

        return $response;
    }
}

components-web-app / api-components-bundle

Push — v2 ( 7912ef...ccc702 )

FormSubmitHandler::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
