DeserializeListener::onKernelRequest() - Code Metrics - Inspection of "Merge branch '2.4'" - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2bb6f9...3a8224 )

by Kévin

created 2019-02-14 07:34 UTC

DeserializeListener::onKernelRequest() B

↳ Parent: DeserializeListener

Complexity

Conditions	11
Paths	6

Size

Total Lines	39
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	11
eloc	25
nc	6
nop	1
dl	0
loc	39
rs	7.3166
c	0
b	0
f	0

How to fix Complexity

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <[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 ApiPlatform\Core\EventListener;

use ApiPlatform\Core\Api\FormatMatcher;
use ApiPlatform\Core\Api\FormatsProviderInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\Serializer\SerializerContextBuilderInterface;
use ApiPlatform\Core\Util\RequestAttributesExtractor;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
use Symfony\Component\Serializer\SerializerInterface;

/**
 * Updates the entity retrieved by the data provider with data contained in the request body.
 *
 * @author Kévin Dunglas <[email protected]>
 */
final class DeserializeListener
{
    private $serializer;
    private $serializerContextBuilder;
    private $formats = [];
    private $formatsProvider;
    private $formatMatcher;

    /**
     * @throws InvalidArgumentException
     */
    public function __construct(SerializerInterface $serializer, SerializerContextBuilderInterface $serializerContextBuilder, /* FormatsProviderInterface */ $formatsProvider)
    {
        $this->serializer = $serializer;
        $this->serializerContextBuilder = $serializerContextBuilder;
        if (\is_array($formatsProvider)) {
            @trigger_error('Using an array as formats provider is deprecated since API Platform 2.3 and will not be possible anymore in API Platform 3', E_USER_DEPRECATED);
            $this->formats = $formatsProvider;
        } else {
            if (!$formatsProvider instanceof FormatsProviderInterface) {
                throw new InvalidArgumentException(sprintf('The "$formatsProvider" argument is expected to be an implementation of the "%s" interface.', FormatsProviderInterface::class));
            }

            $this->formatsProvider = $formatsProvider;
        }
    }

    /**
     * Deserializes the data sent in the requested format.
     */
    public function onKernelRequest(GetResponseEvent $event)
    {
        $request = $event->getRequest();
        $method = $request->getMethod();

        if (
            'DELETE' === $method
            || $request->isMethodSafe(false)
            || !($attributes = RequestAttributesExtractor::extractAttributes($request))
            || !$attributes['receive']
            || (
                    '' === ($requestContent = $request->getContent())
                    && ('POST' === $method || 'PUT' === $method)
               )
        ) {
            return;
        }

        $context = $this->serializerContextBuilder->createFromRequest($request, false, $attributes);
        if (false === $context['input_class']) {
            return;
        }

        // BC check to be removed in 3.0
        if (null !== $this->formatsProvider) {
            $this->formats = $this->formatsProvider->getFormatsFromAttributes($attributes);
        }
        $this->formatMatcher = new FormatMatcher($this->formats);
        $format = $this->getFormat($request);

        $data = $request->attributes->get('data');
        if (null !== $data) {
            $context[AbstractNormalizer::OBJECT_TO_POPULATE] = $data;
        }

        $request->attributes->set(
            'data',
            $this->serializer->deserialize(
                $requestContent, $context['input_class'], $format, $context
            )
        );
    }

    /**
     * Extracts the format from the Content-Type header and check that it is supported.
     *
     * @throws NotAcceptableHttpException
     */
    private function getFormat(Request $request): string
    {
        /**
         * @var string|null
         */
        $contentType = $request->headers->get('CONTENT_TYPE');
        if (null === $contentType) {

            throw new NotAcceptableHttpException('The "Content-Type" header must exist.');
        }

        $format = $this->formatMatcher->getFormat($contentType);
        if (null === $format || !isset($this->formats[$format])) {
            $supportedMimeTypes = [];
            foreach ($this->formats as $mimeTypes) {
                foreach ($mimeTypes as $mimeType) {
                    $supportedMimeTypes[] = $mimeType;
                }
            }

            throw new NotAcceptableHttpException(sprintf(
                'The content-type "%s" is not supported. Supported MIME types are "%s".',
                $contentType,
                implode('", "', $supportedMimeTypes)
            ));
        }

        return $format;
    }
}


1			<?php
2
3			/*
4			* This file is part of the API Platform project.
5			*
6			* (c) Kévin Dunglas <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace ApiPlatform\Core\EventListener;
15
16			use ApiPlatform\Core\Api\FormatMatcher;
17			use ApiPlatform\Core\Api\FormatsProviderInterface;
18			use ApiPlatform\Core\Exception\InvalidArgumentException;
19			use ApiPlatform\Core\Serializer\SerializerContextBuilderInterface;
20			use ApiPlatform\Core\Util\RequestAttributesExtractor;
21			use Symfony\Component\HttpFoundation\Request;
22			use Symfony\Component\HttpKernel\Event\GetResponseEvent;
23			use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
24			use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
25			use Symfony\Component\Serializer\SerializerInterface;
26
27			/**
28			* Updates the entity retrieved by the data provider with data contained in the request body.
29			*
30			* @author Kévin Dunglas <[email protected]>
31			*/
32			final class DeserializeListener
33			{
34			private $serializer;
35			private $serializerContextBuilder;
36			private $formats = [];
37			private $formatsProvider;
38			private $formatMatcher;
39
40			/**
41			* @throws InvalidArgumentException
42			*/
43			public function __construct(SerializerInterface $serializer, SerializerContextBuilderInterface $serializerContextBuilder, /* FormatsProviderInterface */ $formatsProvider)
44			{
45			$this->serializer = $serializer;
46			$this->serializerContextBuilder = $serializerContextBuilder;
47			if (\is_array($formatsProvider)) {
48			@trigger_error('Using an array as formats provider is deprecated since API Platform 2.3 and will not be possible anymore in API Platform 3', E_USER_DEPRECATED);
49			$this->formats = $formatsProvider;
50			} else {
51			if (!$formatsProvider instanceof FormatsProviderInterface) {
52			throw new InvalidArgumentException(sprintf('The "$formatsProvider" argument is expected to be an implementation of the "%s" interface.', FormatsProviderInterface::class));
53			}
54
55			$this->formatsProvider = $formatsProvider;
56			}
57			}
58
59			/**
60			* Deserializes the data sent in the requested format.
61			*/
62			public function onKernelRequest(GetResponseEvent $event)
63			{
64			$request = $event->getRequest();
65			$method = $request->getMethod();
66
67			if (
68			'DELETE' === $method
69			\|\| $request->isMethodSafe(false)
70			\|\| !($attributes = RequestAttributesExtractor::extractAttributes($request))
71			\|\| !$attributes['receive']
72			\|\| (
73			'' === ($requestContent = $request->getContent())
74			&& ('POST' === $method \|\| 'PUT' === $method)
75			)
76			) {
77			return;
78			}
79
80			$context = $this->serializerContextBuilder->createFromRequest($request, false, $attributes);
81			if (false === $context['input_class']) {
82			return;
83			}
84
85			// BC check to be removed in 3.0
86			if (null !== $this->formatsProvider) {
87			$this->formats = $this->formatsProvider->getFormatsFromAttributes($attributes);
88			}
89			$this->formatMatcher = new FormatMatcher($this->formats);
90			$format = $this->getFormat($request);
91
92			$data = $request->attributes->get('data');
93			if (null !== $data) {
94			$context[AbstractNormalizer::OBJECT_TO_POPULATE] = $data;
95			}
96
97			$request->attributes->set(
98			'data',
99			$this->serializer->deserialize(
100			$requestContent, $context['input_class'], $format, $context
101			)
102			);
103			}
104
105			/**
106			* Extracts the format from the Content-Type header and check that it is supported.
107			*
108			* @throws NotAcceptableHttpException
109			*/
110			private function getFormat(Request $request): string
111			{
112			/**
113			* @var string\|null
114			*/
115			$contentType = $request->headers->get('CONTENT_TYPE');
116			if (null === $contentType) {
			0 ignored issues – show introduced 2018-10-19 23:13 UTC by Report Bug Copy Issue Report The condition `null === $contentType` is always `false`. Loading history...
117			throw new NotAcceptableHttpException('The "Content-Type" header must exist.');
118			}
119
120			$format = $this->formatMatcher->getFormat($contentType);
121			if (null === $format \|\| !isset($this->formats[$format])) {
122			$supportedMimeTypes = [];
123			foreach ($this->formats as $mimeTypes) {
124			foreach ($mimeTypes as $mimeType) {
125			$supportedMimeTypes[] = $mimeType;
126			}
127			}
128
129			throw new NotAcceptableHttpException(sprintf(
130			'The content-type "%s" is not supported. Supported MIME types are "%s".',
131			$contentType,
132			implode('", "', $supportedMimeTypes)
133			));
134			}
135
136			return $format;
137			}
138			}
139

api-platform / core

Push — master ( 2bb6f9...3a8224 )

DeserializeListener::onKernelRequest() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like