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

  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\Exception\InvalidArgument;
  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;
  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.     use OperationRequestInitiatorTrait;
  35.     public function __construct(private readonly Negotiator $negotiator, ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, private readonly array $formats = [])
  36.     {
  37.         $this->resourceMetadataCollectionFactory = $resourceMetadataCollectionFactory;
  38.     }
  40.     /**
  41.      * Sets the applicable format to the HttpFoundation Request.
  42.      *
  43.      * @throws NotFoundHttpException
  44.      * @throws NotAcceptableHttpException
  45.      */
  46.     public function onKernelRequest(RequestEvent $event): void
  47.     {
  48.         $request = $event->getRequest();
  49.         $operation = $this->initializeOperation($request);
  51.         if (!(
  52.             $request->attributes->has('_api_resource_class')
  53.             || $request->attributes->getBoolean('_api_respond', false)
  54.             || $request->attributes->getBoolean('_graphql', false)
  55.         )) {
  56.             return;
  57.         }
  59.         $formats = $operation?->getOutputFormats() ?? $this->formats;
  61.         $this->addRequestFormats($request, $formats);
  63.         // Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
  64.         if (null === $routeFormat = $request->attributes->get('_format') ?: null) {
  65.             $flattenedMimeTypes = $this->flattenMimeTypes($formats);
  66.             $mimeTypes = array_keys($flattenedMimeTypes);
  67.         } elseif (!isset($formats[$routeFormat])) {
  68.             throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));
  69.         } else {
  70.             $mimeTypes = Request::getMimeTypes($routeFormat);
  71.             $flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);
  72.         }
  74.         // First, try to guess the format from the Accept header
  75.         /** @var string|null $accept */
  76.         $accept = $request->headers->get('Accept');
  78.         if (null !== $accept) {
  79.             try {
  80.                 $mediaType = $this->negotiator->getBest($accept, $mimeTypes);
  81.             } catch (InvalidArgument) {
  82.                 throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
  83.             }
  85.             if (null === $mediaType) {
  86.                 throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
  87.             }
  89.             $formatMatcher = new FormatMatcher($formats);
  90.             $request->setRequestFormat($formatMatcher->getFormat($mediaType->getType()));
  92.             return;
  93.         }
  95.         // Then use the Symfony request format if available and applicable
  96.         $requestFormat = $request->getRequestFormat('') ?: null;
  97.         if (null !== $requestFormat) {
  98.             $mimeType = $request->getMimeType($requestFormat);
  100.             if (isset($flattenedMimeTypes[$mimeType])) {
  101.                 return;
  102.             }
  104.             throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);
  105.         }
  107.         // Finally, if no Accept header nor Symfony request format is set, return the default format
  108.         foreach ($formats as $format => $mimeType) {
  109.             $request->setRequestFormat($format);
  111.             return;
  112.         }
  113.     }
  115.     /**
  116.      * Adds the supported formats to the request.
  117.      *
  118.      * This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
  119.      */
  120.     private function addRequestFormats(Request $request, array $formats): void
  121.     {
  122.         foreach ($formats as $format => $mimeTypes) {
  123.             $request->setFormat($format, (array) $mimeTypes);
  124.         }
  125.     }
  127.     /**
  128.      * Retries the flattened list of MIME types.
  129.      */
  130.     private function flattenMimeTypes(array $formats): array
  131.     {
  132.         $flattenedMimeTypes = [];
  133.         foreach ($formats as $format => $mimeTypes) {
  134.             foreach ($mimeTypes as $mimeType) {
  135.                 $flattenedMimeTypes[$mimeType] = $format;
  136.             }
  137.         }
  139.         return $flattenedMimeTypes;
  140.     }
  142.     /**
  143.      * Retrieves an instance of NotAcceptableHttpException.
  144.      */
  145.     private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
  146.     {
  147.         return new NotAcceptableHttpException(sprintf(
  148.             'Requested format "%s" is not supported. Supported MIME types are "%s".',
  149.             $accept,
  150.             implode('", "', array_keys($mimeTypes))
  151.         ));
  152.     }
  153. }