#24064

pending completion

Build # #24064

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/0abac07703ecf588c3d582a1cd35d63c8b130902">0abac0770<a href="https://github.com/api-platform/core/commit/0abac07703ecf588c3d582a1cd35d63c8b130902">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/fbfa61558ede5808aba0deb6f1ca13d4e4e81b80">fbfa61558</a>">fbfa61558</a><a href="https://github.com/api-platform/core/commit/0abac07703ecf588c3d582a1cd35d63c8b130902"> into dd497cf52">dd497cf52</a>

Run Details

2 of 2 new or added lines in 2 files covered. (100.0%)

8616 of 10144 relevant lines covered (84.94%)

14.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.8

/src/EventListener/AddFormatListener.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * 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\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Util\RequestAttributesExtractor;
use Negotiation\Negotiator;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Chooses the format to use according to the Accept header and supported formats.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
final class AddFormatListener
{
    private $negotiator;
    private $resourceMetadataFactory;
    private $formats = [];
    private $formatsProvider;
    private $formatMatcher;

    /**
     * @param ResourceMetadataFactoryInterface|FormatsProviderInterface|array $resourceMetadataFactory
     */
    public function __construct(Negotiator $negotiator, $resourceMetadataFactory, array $formats = [])
    {
        $this->negotiator = $negotiator;
        $this->resourceMetadataFactory = $resourceMetadataFactory instanceof ResourceMetadataFactoryInterface ? $resourceMetadataFactory : null;
        $this->formats = $formats;

        if (!$resourceMetadataFactory instanceof ResourceMetadataFactoryInterface) {
            @trigger_error(sprintf('Passing an array or an instance of "%s" as 2nd parameter of the constructor of "%s" is deprecated since API Platform 2.5, pass an instance of "%s" instead', FormatsProviderInterface::class, __CLASS__, ResourceMetadataFactoryInterface::class), E_USER_DEPRECATED);
        }

        if (\is_array($resourceMetadataFactory)) {
            $this->formats = $resourceMetadataFactory;
        } elseif ($resourceMetadataFactory instanceof FormatsProviderInterface) {
            $this->formatsProvider = $resourceMetadataFactory;
        }
    }

    /**
     * Sets the applicable format to the HttpFoundation Request.
     *
     * @throws NotFoundHttpException
     * @throws NotAcceptableHttpException
     */
    public function onKernelRequest(RequestEvent $event): void
    {
        $request = $event->getRequest();
        if (
                !($request->attributes->has('_api_resource_class')
                || $request->attributes->getBoolean('_api_respond', false)
                || $request->attributes->getBoolean('_graphql', false))
        ) {
            return;
        }

        $attributes = RequestAttributesExtractor::extractAttributes($request);

        // BC check to be removed in 3.0
        if ($this->resourceMetadataFactory) {
            if ($attributes) {
                // TODO: Subresource operation metadata aren't available by default, for now we have to fallback on default formats.
                // TODO: A better approach would be to always populate the subresource operation array.
                $formats = $this
                    ->resourceMetadataFactory
                    ->create($attributes['resource_class'])
                    ->getOperationAttribute($attributes, 'output_formats', $this->formats, true);
            } else {
                $formats = $this->formats;
            }
        } elseif ($this->formatsProvider instanceof FormatsProviderInterface) {
            $formats = $this->formatsProvider->getFormatsFromAttributes($attributes);
        } else {
            $formats = $this->formats;
        }

        $this->addRequestFormats($request, $formats);
        $this->formatMatcher = new FormatMatcher($formats);

        // Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
        if (null === $routeFormat = $request->attributes->get('_format') ?: null) {
            $flattenedMimeTypes = $this->flattenMimeTypes($formats);
            $mimeTypes = array_keys($flattenedMimeTypes);
        } elseif (!isset($formats[$routeFormat])) {
            throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));
        } else {
            $mimeTypes = Request::getMimeTypes($routeFormat);
            $flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);
        }

        // First, try to guess the format from the Accept header
        /** @var string|null $accept */
        $accept = $request->headers->get('Accept');
        if (null !== $accept) {
            if (null === $mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {
                throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
            }

            $request->setRequestFormat($this->formatMatcher->getFormat($mediaType->getType()));

            return;
        }

        // Then use the Symfony request format if available and applicable
        $requestFormat = $request->getRequestFormat('') ?: null;
        if (null !== $requestFormat) {
            $mimeType = $request->getMimeType($requestFormat);

            if (isset($flattenedMimeTypes[$mimeType])) {
                return;
            }

            throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);
        }

        // Finally, if no Accept header nor Symfony request format is set, return the default format
        foreach ($formats as $format => $mimeType) {
            $request->setRequestFormat($format);

            return;
        }
    }

    /**
     * Adds the supported formats to the request.
     *
     * This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
     */
    private function addRequestFormats(Request $request, array $formats): void
    {
        foreach ($formats as $format => $mimeTypes) {
            $request->setFormat($format, (array) $mimeTypes);
        }
    }

    /**
     * Retries the flattened list of MIME types.
     */
    private function flattenMimeTypes(array $formats): array
    {
        $flattenedMimeTypes = [];
        foreach ($formats as $format => $mimeTypes) {
            foreach ($mimeTypes as $mimeType) {
                $flattenedMimeTypes[$mimeType] = $format;
            }
        }

        return $flattenedMimeTypes;
    }

    /**
     * Retrieves an instance of NotAcceptableHttpException.
     */
    private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
    {
        return new NotAcceptableHttpException(sprintf(
            'Requested format "%s" is not supported. Supported MIME types are "%s".',
            $accept,
            implode('", "', array_keys($mimeTypes))
        ));
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
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\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
19	use ApiPlatform\Core\Util\RequestAttributesExtractor;
20	use Negotiation\Negotiator;
21	use Symfony\Component\HttpFoundation\Request;
22	use Symfony\Component\HttpKernel\Event\RequestEvent;
23	use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
24	use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
25
26	/**
27	* Chooses the format to use according to the Accept header and supported formats.
28	*
29	* @author Kévin Dunglas <dunglas@gmail.com>
30	*/
31	final class AddFormatListener
32	{
33	private $negotiator;
34	private $resourceMetadataFactory;
35	private $formats = [];
36	private $formatsProvider;
37	private $formatMatcher;
38
39	/**
40	* @param ResourceMetadataFactoryInterface\|FormatsProviderInterface\|array $resourceMetadataFactory
41	*/
42	public function __construct(Negotiator $negotiator, $resourceMetadataFactory, array $formats = [])
43	{
44	$this->negotiator = $negotiator;	39✔
45	$this->resourceMetadataFactory = $resourceMetadataFactory instanceof ResourceMetadataFactoryInterface ? $resourceMetadataFactory : null;	39✔
46	$this->formats = $formats;	39✔
47
48	if (!$resourceMetadataFactory instanceof ResourceMetadataFactoryInterface) {	39✔
49	@trigger_error(sprintf('Passing an array or an instance of "%s" as 2nd parameter of the constructor of "%s" is deprecated since API Platform 2.5, pass an instance of "%s" instead', FormatsProviderInterface::class, __CLASS__, ResourceMetadataFactoryInterface::class), E_USER_DEPRECATED);	3✔
50	}
51
52	if (\is_array($resourceMetadataFactory)) {	39✔
53	$this->formats = $resourceMetadataFactory;	1✔
54	} elseif ($resourceMetadataFactory instanceof FormatsProviderInterface) {	38✔
55	$this->formatsProvider = $resourceMetadataFactory;	2✔
56	}
57	}	39✔
58
59	/**
60	* Sets the applicable format to the HttpFoundation Request.
61	*
62	* @throws NotFoundHttpException
63	* @throws NotAcceptableHttpException
64	*/
65	public function onKernelRequest(RequestEvent $event): void
66	{
67	$request = $event->getRequest();	37✔
68	if (
69	!($request->attributes->has('_api_resource_class')	37✔
70	\|\| $request->attributes->getBoolean('_api_respond', false)	37✔
71	\|\| $request->attributes->getBoolean('_graphql', false))	37✔
72	) {
73	return;	8✔
74	}
75
76	$attributes = RequestAttributesExtractor::extractAttributes($request);	36✔
77
78	// BC check to be removed in 3.0
79	if ($this->resourceMetadataFactory) {	36✔
80	if ($attributes) {	35✔
81	// TODO: Subresource operation metadata aren't available by default, for now we have to fallback on default formats.
82	// TODO: A better approach would be to always populate the subresource operation array.
83	$formats = $this
84	->resourceMetadataFactory	24✔
85	->create($attributes['resource_class'])	24✔
86	->getOperationAttribute($attributes, 'output_formats', $this->formats, true);	24✔
87	} else {
88	$formats = $this->formats;	35✔
89	}
90	} elseif ($this->formatsProvider instanceof FormatsProviderInterface) {	1✔
91	$formats = $this->formatsProvider->getFormatsFromAttributes($attributes);	1✔
92	} else {
93	$formats = $this->formats;	×
94	}
95
96	$this->addRequestFormats($request, $formats);	36✔
97	$this->formatMatcher = new FormatMatcher($formats);	36✔
98
99	// Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
100	if (null === $routeFormat = $request->attributes->get('_format') ?: null) {	36✔
101	$flattenedMimeTypes = $this->flattenMimeTypes($formats);	32✔
102	$mimeTypes = array_keys($flattenedMimeTypes);	32✔
103	} elseif (!isset($formats[$routeFormat])) {	4✔
104	throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));	1✔
105	} else {
106	$mimeTypes = Request::getMimeTypes($routeFormat);	3✔
107	$flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);	3✔
108	}
109
110	// First, try to guess the format from the Accept header
111	/** @var string\|null $accept */
112	$accept = $request->headers->get('Accept');	35✔
113	if (null !== $accept) {	35✔
114	if (null === $mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {	30✔
115	throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);	3✔
116	}
117
118	$request->setRequestFormat($this->formatMatcher->getFormat($mediaType->getType()));	27✔
119
120	return;	27✔
121	}
122
123	// Then use the Symfony request format if available and applicable
124	$requestFormat = $request->getRequestFormat('') ?: null;	5✔
125	if (null !== $requestFormat) {	5✔
126	$mimeType = $request->getMimeType($requestFormat);	5✔
127
128	if (isset($flattenedMimeTypes[$mimeType])) {	5✔
129	return;	4✔
130	}
131
132	throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);	1✔
133	}
134
135	// Finally, if no Accept header nor Symfony request format is set, return the default format
136	foreach ($formats as $format => $mimeType) {	×
137	$request->setRequestFormat($format);	×
138
139	return;	×
140	}
141	}	×
142
143	/**
144	* Adds the supported formats to the request.
145	*
146	* This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
147	*/
148	private function addRequestFormats(Request $request, array $formats): void
149	{
150	foreach ($formats as $format => $mimeTypes) {	36✔
151	$request->setFormat($format, (array) $mimeTypes);	35✔
152	}
153	}	36✔
154
155	/**
156	* Retries the flattened list of MIME types.
157	*/
158	private function flattenMimeTypes(array $formats): array
159	{
160	$flattenedMimeTypes = [];	35✔
161	foreach ($formats as $format => $mimeTypes) {	35✔
162	foreach ($mimeTypes as $mimeType) {	35✔
163	$flattenedMimeTypes[$mimeType] = $format;	35✔
164	}
165	}
166
167	return $flattenedMimeTypes;	35✔
168	}
169
170	/**
171	* Retrieves an instance of NotAcceptableHttpException.
172	*/
173	private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
174	{
175	return new NotAcceptableHttpException(sprintf(	4✔
176	'Requested format "%s" is not supported. Supported MIME types are "%s".',	4✔
177	$accept,
178	implode('", "', array_keys($mimeTypes))	4✔
179	));
180	}
181	}

api-platform / core / #24064

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous