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 (\is_int($data) || \is_float($data)) {
  87.             switch ($dateTimeFormat) {
  88.                 case 'U': $data = sprintf('%d', $data); break;
  89.                 case 'U.u': $data = sprintf('%.6F', $data); break;
  90.             }
  91.         }
  93.         if (!\is_string($data) || '' === trim($data)) {
  94.             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);
  95.         }
  97.         try {
  98.             if (null !== $dateTimeFormat) {
  99.                 $object = \DateTime::class === $type ? \DateTime::createFromFormat($dateTimeFormat, $data, $timezone) : \DateTimeImmutable::createFromFormat($dateTimeFormat, $data, $timezone);
  101.                 if (false !== $object) {
  102.                     return $object;
  103.                 }
  105.                 $dateTimeErrors = \DateTime::class === $type ? \DateTime::getLastErrors() : \DateTimeImmutable::getLastErrors();
  107.                 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);
  108.             }
  110.             $defaultDateTimeFormat = $this->defaultContext[self::FORMAT_KEY] ?? null;
  112.             if (null !== $defaultDateTimeFormat) {
  113.                 $object = \DateTime::class === $type ? \DateTime::createFromFormat($defaultDateTimeFormat, $data, $timezone) : \DateTimeImmutable::createFromFormat($defaultDateTimeFormat, $data, $timezone);
  115.                 if (false !== $object) {
  116.                     return $object;
  117.                 }
  118.             }
  120.             return \DateTime::class === $type ? new \DateTime($data, $timezone) : new \DateTimeImmutable($data, $timezone);
  121.         } catch (NotNormalizableValueException $e) {
  122.             throw $e;
  123.         } catch (\Exception $e) {
  124.             throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, false, $e->getCode(), $e);
  125.         }
  126.     }
  128.     /**
  129.      * @param array $context
  130.      */
  131.     public function supportsDenormalization(mixed $data, string $type, string $format = null /* , array $context = [] */): bool
  132.     {
  133.         return isset(self::SUPPORTED_TYPES[$type]);
  134.     }
  136.     public function hasCacheableSupportsMethod(): bool
  137.     {
  138.         return __CLASS__ === static::class;
  139.     }
  141.     /**
  142.      * Formats datetime errors.
  143.      *
  144.      * @return string[]
  145.      */
  146.     private function formatDateTimeErrors(array $errors): array
  147.     {
  148.         $formattedErrors = [];
  150.         foreach ($errors as $pos => $message) {
  151.             $formattedErrors[] = sprintf('at position %d: %s', $pos, $message);
  152.         }
  154.         return $formattedErrors;
  155.     }
  157.     private function getTimezone(array $context): ?\DateTimeZone
  158.     {
  159.         $dateTimeZone = $context[self::TIMEZONE_KEY] ?? $this->defaultContext[self::TIMEZONE_KEY];
  161.         if (null === $dateTimeZone) {
  162.             return null;
  163.         }
  165.         return $dateTimeZone instanceof \DateTimeZone ? $dateTimeZone : new \DateTimeZone($dateTimeZone);
  166.     }
  167. }