vendor/symfony/serializer/Normalizer/DateTimeNormalizer.php line 53

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.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. namespace Symfony\Component\Serializer\Normalizer;
  14. use Symfony\Component\PropertyInfo\Type;
  15. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  16. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  18. /**
  19.  * Normalizes an object implementing the {@see \DateTimeInterface} to a date string.
  20.  * Denormalizes a date string to an instance of {@see \DateTime} or {@see \DateTimeImmutable}.
  21.  *
  22.  * @author Kévin Dunglas <dunglas@gmail.com>
  23.  */
  24. class DateTimeNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
  25. {
  26.     public const FORMAT_KEY = 'datetime_format';
  27.     public const TIMEZONE_KEY = 'datetime_timezone';
  29.     private $defaultContext = [
  30.         self::FORMAT_KEY => \DateTime::RFC3339,
  31.         self::TIMEZONE_KEY => null,
  32.     ];
  34.     private const SUPPORTED_TYPES = [
  35.         \DateTimeInterface::class => true,
  36.         \DateTimeImmutable::class => true,
  37.         \DateTime::class => true,
  38.     ];
  40.     public function __construct(array $defaultContext = [])
  41.     {
  42.         $this->setDefaultContext($defaultContext);
  43.     }
  45.     public function setDefaultContext(array $defaultContext): void
  46.     {
  47.         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
  48.     }
  50.     /**
  51.      * @throws InvalidArgumentException
  52.      */
  53.     public function normalize(mixed $object, string $format = null, array $context = []): string
  54.     {
  55.         if (!$object instanceof \DateTimeInterface) {
  56.             throw new InvalidArgumentException('The object must implement the "\DateTimeInterface".');
  57.         }
  59.         $dateTimeFormat = $context[self::FORMAT_KEY] ?? $this->defaultContext[self::FORMAT_KEY];
  60.         $timezone = $this->getTimezone($context);
  62.         if (null !== $timezone) {
  63.             $object = clone $object;
  64.             $object = $object->setTimezone($timezone);
  65.         }
  67.         return $object->format($dateTimeFormat);
  68.     }
  70.     /**
  71.      * @param array $context
  72.      */
  73.     public function supportsNormalization(mixed $data, string $format = null /* , array $context = [] */): bool
  74.     {
  75.         return $data instanceof \DateTimeInterface;
  76.     }
  78.     /**
  79.      * @throws NotNormalizableValueException
  80.      */
  81.     public function denormalize(mixed $data, string $type, string $format = null, array $context = []): \DateTimeInterface
  82.     {
  83.         $dateTimeFormat = $context[self::FORMAT_KEY] ?? null;
  84.         $timezone = $this->getTimezone($context);
  86.         if (null === $data || !\is_string($data) || '' === trim($data)) {
  87.             throw NotNormalizableValueException::createForUnexpectedDataType('The data is either not an string, an empty string, or null; you should pass a string that can be parsed with the passed format or a valid DateTime string.', $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
  88.         }
  90.         try {
  91.             if (null !== $dateTimeFormat) {
  92.                 $object = \DateTime::class === $type ? \DateTime::createFromFormat($dateTimeFormat, $data, $timezone) : \DateTimeImmutable::createFromFormat($dateTimeFormat, $data, $timezone);
  94.                 if (false !== $object) {
  95.                     return $object;
  96.                 }
  98.                 $dateTimeErrors = \DateTime::class === $type ? \DateTime::getLastErrors() : \DateTimeImmutable::getLastErrors();
  100.                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Parsing datetime string "%s" using format "%s" resulted in %d errors: ', $data, $dateTimeFormat, $dateTimeErrors['error_count'])."\n".implode("\n", $this->formatDateTimeErrors($dateTimeErrors['errors'])), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
  101.             }
  103.             $defaultDateTimeFormat = $this->defaultContext[self::FORMAT_KEY] ?? null;
  105.             if (null !== $defaultDateTimeFormat) {
  106.                 $object = \DateTime::class === $type ? \DateTime::createFromFormat($defaultDateTimeFormat, $data, $timezone) : \DateTimeImmutable::createFromFormat($defaultDateTimeFormat, $data, $timezone);
  108.                 if (false !== $object) {
  109.                     return $object;
  110.                 }
  111.             }
  113.             return \DateTime::class === $type ? new \DateTime($data, $timezone) : new \DateTimeImmutable($data, $timezone);
  114.         } catch (NotNormalizableValueException $e) {
  115.             throw $e;
  116.         } catch (\Exception $e) {
  117.             throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, false, $e->getCode(), $e);
  118.         }
  119.     }
  121.     /**
  122.      * @param array $context
  123.      */
  124.     public function supportsDenormalization(mixed $data, string $type, string $format = null /* , array $context = [] */): bool
  125.     {
  126.         return isset(self::SUPPORTED_TYPES[$type]);
  127.     }
  129.     public function hasCacheableSupportsMethod(): bool
  130.     {
  131.         return __CLASS__ === static::class;
  132.     }
  134.     /**
  135.      * Formats datetime errors.
  136.      *
  137.      * @return string[]
  138.      */
  139.     private function formatDateTimeErrors(array $errors): array
  140.     {
  141.         $formattedErrors = [];
  143.         foreach ($errors as $pos => $message) {
  144.             $formattedErrors[] = sprintf('at position %d: %s', $pos, $message);
  145.         }
  147.         return $formattedErrors;
  148.     }
  150.     private function getTimezone(array $context): ?\DateTimeZone
  151.     {
  152.         $dateTimeZone = $context[self::TIMEZONE_KEY] ?? $this->defaultContext[self::TIMEZONE_KEY];
  154.         if (null === $dateTimeZone) {
  155.             return null;
  156.         }
  158.         return $dateTimeZone instanceof \DateTimeZone ? $dateTimeZone : new \DateTimeZone($dateTimeZone);
  159.     }
  160. }