vendor/api-platform/core/src/Symfony/EventListener/DeserializeListener.php line 64

  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\HttpOperation;
  18. use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
  19. use ApiPlatform\Serializer\SerializerContextBuilderInterface;
  20. use ApiPlatform\Symfony\Validator\Exception\ValidationException;
  21. use ApiPlatform\Util\OperationRequestInitiatorTrait;
  22. use ApiPlatform\Util\RequestAttributesExtractor;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\HttpKernel\Event\RequestEvent;
  25. use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
  26. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  27. use Symfony\Component\Serializer\Exception\PartialDenormalizationException;
  28. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  29. use Symfony\Component\Serializer\SerializerInterface;
  30. use Symfony\Component\Validator\Constraints\Type;
  31. use Symfony\Component\Validator\ConstraintViolation;
  32. use Symfony\Component\Validator\ConstraintViolationList;
  33. use Symfony\Contracts\Translation\LocaleAwareInterface;
  34. use Symfony\Contracts\Translation\TranslatorInterface;
  35. use Symfony\Contracts\Translation\TranslatorTrait;
  37. /**
  38.  * Updates the entity retrieved by the data provider with data contained in the request body.
  39.  *
  40.  * @author Kévin Dunglas <dunglas@gmail.com>
  41.  */
  42. final class DeserializeListener
  43. {
  44.     use OperationRequestInitiatorTrait;
  46.     public const OPERATION_ATTRIBUTE_KEY = 'deserialize';
  48.     public function __construct(private readonly SerializerInterface $serializer, private readonly SerializerContextBuilderInterface $serializerContextBuilder, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory = null, private ?TranslatorInterface $translator = null)
  49.     {
  50.         $this->resourceMetadataCollectionFactory = $resourceMetadataFactory;
  51.         if (null === $this->translator) {
  52.             $this->translator = new class() implements TranslatorInterface, LocaleAwareInterface {
  53.                 use TranslatorTrait;
  54.             };
  55.             $this->translator->setLocale('en');
  56.         }
  57.     }
  59.     /**
  60.      * Deserializes the data sent in the requested format.
  61.      *
  62.      * @throws UnsupportedMediaTypeHttpException
  63.      */
  64.     public function onKernelRequest(RequestEvent $event): void
  65.     {
  66.         $request = $event->getRequest();
  67.         $method = $request->getMethod();
  69.         if (
  70.             'DELETE' === $method
  71.             || $request->isMethodSafe()
  72.             || !($attributes = RequestAttributesExtractor::extractAttributes($request))
  73.             || !$attributes['receive']
  74.         ) {
  75.             return;
  76.         }
  78.         $operation = $this->initializeOperation($request);
  80.         if (!($operation?->canDeserialize() ?? true)) {
  81.             return;
  82.         }
  84.         $context = $this->serializerContextBuilder->createFromRequest($request, false, $attributes);
  86.         $format = $this->getFormat($request, $operation?->getInputFormats() ?? []);
  87.         $data = $request->attributes->get('data');
  88.         if (
  89.             null !== $data &&
  90.             (
  91.                 HttpOperation::METHOD_POST === $method ||
  92.                 HttpOperation::METHOD_PATCH === $method ||
  93.                 (HttpOperation::METHOD_PUT === $method && !($operation->getExtraProperties()['standard_put'] ?? false))
  94.             )
  95.         ) {
  96.             $context[AbstractNormalizer::OBJECT_TO_POPULATE] = $data;
  97.         }
  98.         try {
  99.             $request->attributes->set(
  100.                 'data',
  101.                 $this->serializer->deserialize($request->getContent(), $context['resource_class'], $format, $context)
  102.             );
  103.         } catch (PartialDenormalizationException $e) {
  104.             $violations = new ConstraintViolationList();
  105.             foreach ($e->getErrors() as $exception) {
  106.                 if (!$exception instanceof NotNormalizableValueException) {
  107.                     continue;
  108.                 }
  109.                 $message = (new Type($exception->getExpectedTypes() ?? []))->message;
  110.                 $parameters = [];
  111.                 if ($exception->canUseMessageForUser()) {
  112.                     $parameters['hint'] = $exception->getMessage();
  113.                 }
  114.                 $violations->add(new ConstraintViolation($this->translator->trans($message, ['{{ type }}' => implode('|', $exception->getExpectedTypes() ?? [])], 'validators'), $message, $parameters, null, $exception->getPath(), null, null, (string) $exception->getCode()));
  115.             }
  116.             if (0 !== \count($violations)) {
  117.                 throw new ValidationException($violations);
  118.             }
  119.         }
  120.     }
  122.     /**
  123.      * Extracts the format from the Content-Type header and check that it is supported.
  124.      *
  125.      * @throws UnsupportedMediaTypeHttpException
  126.      */
  127.     private function getFormat(Request $request, array $formats): string
  128.     {
  129.         /** @var ?string $contentType */
  130.         $contentType = $request->headers->get('CONTENT_TYPE');
  131.         if (null === $contentType) {
  132.             throw new UnsupportedMediaTypeHttpException('The "Content-Type" header must exist.');
  133.         }
  135.         $formatMatcher = new FormatMatcher($formats);
  136.         $format = $formatMatcher->getFormat($contentType);
  137.         if (null === $format) {
  138.             $supportedMimeTypes = [];
  139.             foreach ($formats as $mimeTypes) {
  140.                 foreach ($mimeTypes as $mimeType) {
  141.                     $supportedMimeTypes[] = $mimeType;
  142.                 }
  143.             }
  145.             throw new UnsupportedMediaTypeHttpException(sprintf('The content-type "%s" is not supported. Supported MIME types are "%s".', $contentType, implode('", "', $supportedMimeTypes)));
  146.         }
  148.         return $format;
  149.     }
  150. }