vendor/api-platform/core/src/Symfony/EventListener/AddFormatListener.php line 45

  1. <?php
  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.  */
  12. declare(strict_types=1);
  14. namespace ApiPlatform\Symfony\EventListener;
  16. use ApiPlatform\Api\FormatMatcher;
  17. use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
  18. use ApiPlatform\Util\OperationRequestInitiatorTrait;
  19. use Negotiation\Negotiator;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpKernel\Event\RequestEvent;
  22. use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
  23. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  25. /**
  26.  * Chooses the format to use according to the Accept header and supported formats.
  27.  *
  28.  * @author Kévin Dunglas <dunglas@gmail.com>
  29.  */
  30. final class AddFormatListener
  31. {
  32.     use OperationRequestInitiatorTrait;
  34.     public function __construct(private readonly Negotiator $negotiator, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, private readonly array $formats = [])
  35.     {
  36.         $this->resourceMetadataCollectionFactory = $resourceMetadataCollectionFactory;
  37.     }
  39.     /**
  40.      * Sets the applicable format to the HttpFoundation Request.
  41.      *
  42.      * @throws NotFoundHttpException
  43.      * @throws NotAcceptableHttpException
  44.      */
  45.     public function onKernelRequest(RequestEvent $event): void
  46.     {
  47.         $request = $event->getRequest();
  48.         $operation = $this->initializeOperation($request);
  50.         if (!(
  51.             $request->attributes->has('_api_resource_class')
  52.             || $request->attributes->getBoolean('_api_respond', false)
  53.             || $request->attributes->getBoolean('_graphql', false)
  54.         )) {
  55.             return;
  56.         }
  58.         $formats = $operation?->getOutputFormats() ?? $this->formats;
  60.         $this->addRequestFormats($request, $formats);
  62.         // Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
  63.         if (null === $routeFormat = $request->attributes->get('_format') ?: null) {
  64.             $flattenedMimeTypes = $this->flattenMimeTypes($formats);
  65.             $mimeTypes = array_keys($flattenedMimeTypes);
  66.         } elseif (!isset($formats[$routeFormat])) {
  67.             throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));
  68.         } else {
  69.             $mimeTypes = Request::getMimeTypes($routeFormat);
  70.             $flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);
  71.         }
  73.         // First, try to guess the format from the Accept header
  74.         /** @var string|null $accept */
  75.         $accept = $request->headers->get('Accept');
  76.         if (null !== $accept) {
  77.             if (null === $mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {
  78.                 throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
  79.             }
  81.             $formatMatcher = new FormatMatcher($formats);
  82.             $request->setRequestFormat($formatMatcher->getFormat($mediaType->getType()));
  84.             return;
  85.         }
  87.         // Then use the Symfony request format if available and applicable
  88.         $requestFormat = $request->getRequestFormat('') ?: null;
  89.         if (null !== $requestFormat) {
  90.             $mimeType = $request->getMimeType($requestFormat);
  92.             if (isset($flattenedMimeTypes[$mimeType])) {
  93.                 return;
  94.             }
  96.             throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);
  97.         }
  99.         // Finally, if no Accept header nor Symfony request format is set, return the default format
  100.         foreach ($formats as $format => $mimeType) {
  101.             $request->setRequestFormat($format);
  103.             return;
  104.         }
  105.     }
  107.     /**
  108.      * Adds the supported formats to the request.
  109.      *
  110.      * This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
  111.      */
  112.     private function addRequestFormats(Request $request, array $formats): void
  113.     {
  114.         foreach ($formats as $format => $mimeTypes) {
  115.             $request->setFormat($format, (array) $mimeTypes);
  116.         }
  117.     }
  119.     /**
  120.      * Retries the flattened list of MIME types.
  121.      */
  122.     private function flattenMimeTypes(array $formats): array
  123.     {
  124.         $flattenedMimeTypes = [];
  125.         foreach ($formats as $format => $mimeTypes) {
  126.             foreach ($mimeTypes as $mimeType) {
  127.                 $flattenedMimeTypes[$mimeType] = $format;
  128.             }
  129.         }
  131.         return $flattenedMimeTypes;
  132.     }
  134.     /**
  135.      * Retrieves an instance of NotAcceptableHttpException.
  136.      */
  137.     private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
  138.     {
  139.         return new NotAcceptableHttpException(sprintf(
  140.             'Requested format "%s" is not supported. Supported MIME types are "%s".',
  141.             $accept,
  142.             implode('", "', array_keys($mimeTypes))
  143.         ));
  144.     }
  145. }