vendor/symfony/form/Extension/Core/Type/DateType.php line 29

  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\Form\Extension\Core\Type;
  14. use Symfony\Component\Form\AbstractType;
  15. use Symfony\Component\Form\Exception\LogicException;
  16. use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeImmutableToDateTimeTransformer;
  17. use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToArrayTransformer;
  18. use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToLocalizedStringTransformer;
  19. use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToStringTransformer;
  20. use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToTimestampTransformer;
  21. use Symfony\Component\Form\FormBuilderInterface;
  22. use Symfony\Component\Form\FormInterface;
  23. use Symfony\Component\Form\FormView;
  24. use Symfony\Component\Form\ReversedTransformer;
  25. use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
  26. use Symfony\Component\OptionsResolver\Options;
  27. use Symfony\Component\OptionsResolver\OptionsResolver;
  29. class DateType extends AbstractType
  30. {
  31.     public const DEFAULT_FORMAT = \IntlDateFormatter::MEDIUM;
  32.     public const HTML5_FORMAT = 'yyyy-MM-dd';
  34.     private const ACCEPTED_FORMATS = [
  35.         \IntlDateFormatter::FULL,
  36.         \IntlDateFormatter::LONG,
  37.         \IntlDateFormatter::MEDIUM,
  38.         \IntlDateFormatter::SHORT,
  39.     ];
  41.     private const WIDGETS = [
  42.         'text' => TextType::class,
  43.         'choice' => ChoiceType::class,
  44.     ];
  46.     public function buildForm(FormBuilderInterface $builder, array $options)
  47.     {
  48.         $dateFormat = \is_int($options['format']) ? $options['format'] : self::DEFAULT_FORMAT;
  49.         $timeFormat = \IntlDateFormatter::NONE;
  50.         $calendar = \IntlDateFormatter::GREGORIAN;
  51.         $pattern = \is_string($options['format']) ? $options['format'] : '';
  53.         if (!\in_array($dateFormat, self::ACCEPTED_FORMATS, true)) {
  54.             throw new InvalidOptionsException('The "format" option must be one of the IntlDateFormatter constants (FULL, LONG, MEDIUM, SHORT) or a string representing a custom format.');
  55.         }
  57.         if ('single_text' === $options['widget']) {
  58.             if ('' !== $pattern && !str_contains($pattern, 'y') && !str_contains($pattern, 'M') && !str_contains($pattern, 'd')) {
  59.                 throw new InvalidOptionsException(sprintf('The "format" option should contain the letters "y", "M" or "d". Its current value is "%s".', $pattern));
  60.             }
  62.             $builder->addViewTransformer(new DateTimeToLocalizedStringTransformer(
  63.                 $options['model_timezone'],
  64.                 $options['view_timezone'],
  65.                 $dateFormat,
  66.                 $timeFormat,
  67.                 $calendar,
  68.                 $pattern
  69.             ));
  70.         } else {
  71.             if ('' !== $pattern && (!str_contains($pattern, 'y') || !str_contains($pattern, 'M') || !str_contains($pattern, 'd'))) {
  72.                 throw new InvalidOptionsException(sprintf('The "format" option should contain the letters "y", "M" and "d". Its current value is "%s".', $pattern));
  73.             }
  75.             $yearOptions = $monthOptions = $dayOptions = [
  76.                 'error_bubbling' => true,
  77.                 'empty_data' => '',
  78.             ];
  79.             // when the form is compound the entries of the array are ignored in favor of children data
  80.             // so we need to handle the cascade setting here
  81.             $emptyData = $builder->getEmptyData() ?: [];
  83.             if ($emptyData instanceof \Closure) {
  84.                 $lazyEmptyData = static function ($option) use ($emptyData) {
  85.                     return static function (FormInterface $form) use ($emptyData, $option) {
  86.                         $emptyData = $emptyData($form->getParent());
  88.                         return $emptyData[$option] ?? '';
  89.                     };
  90.                 };
  92.                 $yearOptions['empty_data'] = $lazyEmptyData('year');
  93.                 $monthOptions['empty_data'] = $lazyEmptyData('month');
  94.                 $dayOptions['empty_data'] = $lazyEmptyData('day');
  95.             } else {
  96.                 if (isset($emptyData['year'])) {
  97.                     $yearOptions['empty_data'] = $emptyData['year'];
  98.                 }
  99.                 if (isset($emptyData['month'])) {
  100.                     $monthOptions['empty_data'] = $emptyData['month'];
  101.                 }
  102.                 if (isset($emptyData['day'])) {
  103.                     $dayOptions['empty_data'] = $emptyData['day'];
  104.                 }
  105.             }
  107.             if (isset($options['invalid_message'])) {
  108.                 $dayOptions['invalid_message'] = $options['invalid_message'];
  109.                 $monthOptions['invalid_message'] = $options['invalid_message'];
  110.                 $yearOptions['invalid_message'] = $options['invalid_message'];
  111.             }
  113.             if (isset($options['invalid_message_parameters'])) {
  114.                 $dayOptions['invalid_message_parameters'] = $options['invalid_message_parameters'];
  115.                 $monthOptions['invalid_message_parameters'] = $options['invalid_message_parameters'];
  116.                 $yearOptions['invalid_message_parameters'] = $options['invalid_message_parameters'];
  117.             }
  119.             $formatter = new \IntlDateFormatter(
  120.                 \Locale::getDefault(),
  121.                 $dateFormat,
  122.                 $timeFormat,
  123.                 // see https://bugs.php.net/66323
  124.                 class_exists(\IntlTimeZone::class, false) ? \IntlTimeZone::createDefault() : null,
  125.                 $calendar,
  126.                 $pattern
  127.             );
  129.             // new \IntlDateFormatter may return null instead of false in case of failure, see https://bugs.php.net/66323
  130.             if (!$formatter) {
  131.                 throw new InvalidOptionsException(intl_get_error_message(), intl_get_error_code());
  132.             }
  134.             $formatter->setLenient(false);
  136.             if ('choice' === $options['widget']) {
  137.                 // Only pass a subset of the options to children
  138.                 $yearOptions['choices'] = $this->formatTimestamps($formatter, '/y+/', $this->listYears($options['years']));
  139.                 $yearOptions['placeholder'] = $options['placeholder']['year'];
  140.                 $yearOptions['choice_translation_domain'] = $options['choice_translation_domain']['year'];
  141.                 $monthOptions['choices'] = $this->formatTimestamps($formatter, '/[M|L]+/', $this->listMonths($options['months']));
  142.                 $monthOptions['placeholder'] = $options['placeholder']['month'];
  143.                 $monthOptions['choice_translation_domain'] = $options['choice_translation_domain']['month'];
  144.                 $dayOptions['choices'] = $this->formatTimestamps($formatter, '/d+/', $this->listDays($options['days']));
  145.                 $dayOptions['placeholder'] = $options['placeholder']['day'];
  146.                 $dayOptions['choice_translation_domain'] = $options['choice_translation_domain']['day'];
  147.             }
  149.             // Append generic carry-along options
  150.             foreach (['required', 'translation_domain'] as $passOpt) {
  151.                 $yearOptions[$passOpt] = $monthOptions[$passOpt] = $dayOptions[$passOpt] = $options[$passOpt];
  152.             }
  154.             $builder
  155.                 ->add('year', self::WIDGETS[$options['widget']], $yearOptions)
  156.                 ->add('month', self::WIDGETS[$options['widget']], $monthOptions)
  157.                 ->add('day', self::WIDGETS[$options['widget']], $dayOptions)
  158.                 ->addViewTransformer(new DateTimeToArrayTransformer(
  159.                     $options['model_timezone'], $options['view_timezone'], ['year', 'month', 'day']
  160.                 ))
  161.                 ->setAttribute('formatter', $formatter)
  162.             ;
  163.         }
  165.         if ('datetime_immutable' === $options['input']) {
  166.             $builder->addModelTransformer(new DateTimeImmutableToDateTimeTransformer());
  167.         } elseif ('string' === $options['input']) {
  168.             $builder->addModelTransformer(new ReversedTransformer(
  169.                 new DateTimeToStringTransformer($options['model_timezone'], $options['model_timezone'], $options['input_format'])
  170.             ));
  171.         } elseif ('timestamp' === $options['input']) {
  172.             $builder->addModelTransformer(new ReversedTransformer(
  173.                 new DateTimeToTimestampTransformer($options['model_timezone'], $options['model_timezone'])
  174.             ));
  175.         } elseif ('array' === $options['input']) {
  176.             $builder->addModelTransformer(new ReversedTransformer(
  177.                 new DateTimeToArrayTransformer($options['model_timezone'], $options['model_timezone'], ['year', 'month', 'day'])
  178.             ));
  179.         }
  180.     }
  182.     public function finishView(FormView $view, FormInterface $form, array $options)
  183.     {
  184.         $view->vars['widget'] = $options['widget'];
  186.         // Change the input to an HTML5 date input if
  187.         //  * the widget is set to "single_text"
  188.         //  * the format matches the one expected by HTML5
  189.         //  * the html5 is set to true
  190.         if ($options['html5'] && 'single_text' === $options['widget'] && self::HTML5_FORMAT === $options['format']) {
  191.             $view->vars['type'] = 'date';
  192.         }
  194.         if ($form->getConfig()->hasAttribute('formatter')) {
  195.             $pattern = $form->getConfig()->getAttribute('formatter')->getPattern();
  197.             // remove special characters unless the format was explicitly specified
  198.             if (!\is_string($options['format'])) {
  199.                 // remove quoted strings first
  200.                 $pattern = preg_replace('/\'[^\']+\'/', '', $pattern);
  202.                 // remove remaining special chars
  203.                 $pattern = preg_replace('/[^yMd]+/', '', $pattern);
  204.             }
  206.             // set right order with respect to locale (e.g.: de_DE=dd.MM.yy; en_US=M/d/yy)
  207.             // lookup various formats at http://userguide.icu-project.org/formatparse/datetime
  208.             if (preg_match('/^([yMd]+)[^yMd]*([yMd]+)[^yMd]*([yMd]+)$/', $pattern)) {
  209.                 $pattern = preg_replace(['/y+/', '/M+/', '/d+/'], ['{{ year }}', '{{ month }}', '{{ day }}'], $pattern);
  210.             } else {
  211.                 // default fallback
  212.                 $pattern = '{{ year }}{{ month }}{{ day }}';
  213.             }
  215.             $view->vars['date_pattern'] = $pattern;
  216.         }
  217.     }
  219.     public function configureOptions(OptionsResolver $resolver)
  220.     {
  221.         $compound = function (Options $options) {
  222.             return 'single_text' !== $options['widget'];
  223.         };
  225.         $placeholderDefault = function (Options $options) {
  226.             return $options['required'] ? null : '';
  227.         };
  229.         $placeholderNormalizer = function (Options $options, $placeholder) use ($placeholderDefault) {
  230.             if (\is_array($placeholder)) {
  231.                 $default = $placeholderDefault($options);
  233.                 return array_merge(
  234.                     ['year' => $default, 'month' => $default, 'day' => $default],
  235.                     $placeholder
  236.                 );
  237.             }
  239.             return [
  240.                 'year' => $placeholder,
  241.                 'month' => $placeholder,
  242.                 'day' => $placeholder,
  243.             ];
  244.         };
  246.         $choiceTranslationDomainNormalizer = function (Options $options, $choiceTranslationDomain) {
  247.             if (\is_array($choiceTranslationDomain)) {
  248.                 $default = false;
  250.                 return array_replace(
  251.                     ['year' => $default, 'month' => $default, 'day' => $default],
  252.                     $choiceTranslationDomain
  253.                 );
  254.             }
  256.             return [
  257.                 'year' => $choiceTranslationDomain,
  258.                 'month' => $choiceTranslationDomain,
  259.                 'day' => $choiceTranslationDomain,
  260.             ];
  261.         };
  263.         $format = function (Options $options) {
  264.             return 'single_text' === $options['widget'] ? self::HTML5_FORMAT : self::DEFAULT_FORMAT;
  265.         };
  267.         $resolver->setDefaults([
  268.             'years' => range((int) date('Y') - 5, (int) date('Y') + 5),
  269.             'months' => range(1, 12),
  270.             'days' => range(1, 31),
  271.             'widget' => 'choice',
  272.             'input' => 'datetime',
  273.             'format' => $format,
  274.             'model_timezone' => null,
  275.             'view_timezone' => null,
  276.             'placeholder' => $placeholderDefault,
  277.             'html5' => true,
  278.             // Don't modify \DateTime classes by reference, we treat
  279.             // them like immutable value objects
  280.             'by_reference' => false,
  281.             'error_bubbling' => false,
  282.             // If initialized with a \DateTime object, FormType initializes
  283.             // this option to "\DateTime". Since the internal, normalized
  284.             // representation is not \DateTime, but an array, we need to unset
  285.             // this option.
  286.             'data_class' => null,
  287.             'compound' => $compound,
  288.             'empty_data' => function (Options $options) {
  289.                 return $options['compound'] ? [] : '';
  290.             },
  291.             'choice_translation_domain' => false,
  292.             'input_format' => 'Y-m-d',
  293.             'invalid_message' => 'Please enter a valid date.',
  294.         ]);
  296.         $resolver->setNormalizer('placeholder', $placeholderNormalizer);
  297.         $resolver->setNormalizer('choice_translation_domain', $choiceTranslationDomainNormalizer);
  299.         $resolver->setAllowedValues('input', [
  300.             'datetime',
  301.             'datetime_immutable',
  302.             'string',
  303.             'timestamp',
  304.             'array',
  305.         ]);
  306.         $resolver->setAllowedValues('widget', [
  307.             'single_text',
  308.             'text',
  309.             'choice',
  310.         ]);
  312.         $resolver->setAllowedTypes('format', ['int', 'string']);
  313.         $resolver->setAllowedTypes('years', 'array');
  314.         $resolver->setAllowedTypes('months', 'array');
  315.         $resolver->setAllowedTypes('days', 'array');
  316.         $resolver->setAllowedTypes('input_format', 'string');
  318.         $resolver->setNormalizer('html5', function (Options $options, $html5) {
  319.             if ($html5 && 'single_text' === $options['widget'] && self::HTML5_FORMAT !== $options['format']) {
  320.                 throw new LogicException(sprintf('Cannot use the "format" option of "%s" when the "html5" option is enabled.', self::class));
  321.             }
  323.             return $html5;
  324.         });
  325.     }
  327.     public function getBlockPrefix(): string
  328.     {
  329.         return 'date';
  330.     }
  332.     private function formatTimestamps(\IntlDateFormatter $formatter, string $regex, array $timestamps)
  333.     {
  334.         $pattern = $formatter->getPattern();
  335.         $timezone = $formatter->getTimeZoneId();
  336.         $formattedTimestamps = [];
  338.         $formatter->setTimeZone('UTC');
  340.         if (preg_match($regex, $pattern, $matches)) {
  341.             $formatter->setPattern($matches[0]);
  343.             foreach ($timestamps as $timestamp => $choice) {
  344.                 $formattedTimestamps[$formatter->format($timestamp)] = $choice;
  345.             }
  347.             // I'd like to clone the formatter above, but then we get a
  348.             // segmentation fault, so let's restore the old state instead
  349.             $formatter->setPattern($pattern);
  350.         }
  352.         $formatter->setTimeZone($timezone);
  354.         return $formattedTimestamps;
  355.     }
  357.     private function listYears(array $years)
  358.     {
  359.         $result = [];
  361.         foreach ($years as $year) {
  362.             $result[\PHP_INT_SIZE === 4 ? \DateTime::createFromFormat('Y e', $year.' UTC')->format('U') : gmmktime(0, 0, 0, 6, 15, $year)] = $year;
  363.         }
  365.         return $result;
  366.     }
  368.     private function listMonths(array $months)
  369.     {
  370.         $result = [];
  372.         foreach ($months as $month) {
  373.             $result[gmmktime(0, 0, 0, $month, 15)] = $month;
  374.         }
  376.         return $result;
  377.     }
  379.     private function listDays(array $days)
  380.     {
  381.         $result = [];
  383.         foreach ($days as $day) {
  384.             $result[gmmktime(0, 0, 0, 5, $day)] = $day;
  385.         }
  387.         return $result;
  388.     }
  389. }