vendor/symfony/form/Extension/Core/Type/FileType.php line 26

  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\FileUploadError;
  16. use Symfony\Component\Form\FormBuilderInterface;
  17. use Symfony\Component\Form\FormEvent;
  18. use Symfony\Component\Form\FormEvents;
  19. use Symfony\Component\Form\FormInterface;
  20. use Symfony\Component\Form\FormView;
  21. use Symfony\Component\HttpFoundation\File\File;
  22. use Symfony\Component\OptionsResolver\Options;
  23. use Symfony\Component\OptionsResolver\OptionsResolver;
  24. use Symfony\Contracts\Translation\TranslatorInterface;
  26. class FileType extends AbstractType
  27. {
  28.     public const KIB_BYTES = 1024;
  29.     public const MIB_BYTES = 1048576;
  31.     private const SUFFIXES = [
  32.         1 => 'bytes',
  33.         self::KIB_BYTES => 'KiB',
  34.         self::MIB_BYTES => 'MiB',
  35.     ];
  37.     private ?TranslatorInterface $translator;
  39.     public function __construct(TranslatorInterface $translator = null)
  40.     {
  41.         $this->translator = $translator;
  42.     }
  44.     public function buildForm(FormBuilderInterface $builder, array $options)
  45.     {
  46.         // Ensure that submitted data is always an uploaded file or an array of some
  47.         $builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) use ($options) {
  48.             $form = $event->getForm();
  49.             $requestHandler = $form->getConfig()->getRequestHandler();
  51.             if ($options['multiple']) {
  52.                 $data = [];
  53.                 $files = $event->getData();
  55.                 if (!\is_array($files)) {
  56.                     $files = [];
  57.                 }
  59.                 foreach ($files as $file) {
  60.                     if ($requestHandler->isFileUpload($file)) {
  61.                         $data[] = $file;
  63.                         if (method_exists($requestHandler, 'getUploadFileError') && null !== $errorCode = $requestHandler->getUploadFileError($file)) {
  64.                             $form->addError($this->getFileUploadError($errorCode));
  65.                         }
  66.                     }
  67.                 }
  69.                 // Since the array is never considered empty in the view data format
  70.                 // on submission, we need to evaluate the configured empty data here
  71.                 if ([] === $data) {
  72.                     $emptyData = $form->getConfig()->getEmptyData();
  73.                     $data = $emptyData instanceof \Closure ? $emptyData($form, $data) : $emptyData;
  74.                 }
  76.                 $event->setData($data);
  77.             } elseif ($requestHandler->isFileUpload($event->getData()) && method_exists($requestHandler, 'getUploadFileError') && null !== $errorCode = $requestHandler->getUploadFileError($event->getData())) {
  78.                 $form->addError($this->getFileUploadError($errorCode));
  79.             } elseif (!$requestHandler->isFileUpload($event->getData())) {
  80.                 $event->setData(null);
  81.             }
  82.         });
  83.     }
  85.     public function buildView(FormView $view, FormInterface $form, array $options)
  86.     {
  87.         if ($options['multiple']) {
  88.             $view->vars['full_name'] .= '[]';
  89.             $view->vars['attr']['multiple'] = 'multiple';
  90.         }
  92.         $view->vars = array_replace($view->vars, [
  93.             'type' => 'file',
  94.             'value' => '',
  95.         ]);
  96.     }
  98.     public function finishView(FormView $view, FormInterface $form, array $options)
  99.     {
  100.         $view->vars['multipart'] = true;
  101.     }
  103.     public function configureOptions(OptionsResolver $resolver)
  104.     {
  105.         $dataClass = null;
  106.         if (class_exists(File::class)) {
  107.             $dataClass = function (Options $options) {
  108.                 return $options['multiple'] ? null : File::class;
  109.             };
  110.         }
  112.         $emptyData = function (Options $options) {
  113.             return $options['multiple'] ? [] : null;
  114.         };
  116.         $resolver->setDefaults([
  117.             'compound' => false,
  118.             'data_class' => $dataClass,
  119.             'empty_data' => $emptyData,
  120.             'multiple' => false,
  121.             'allow_file_upload' => true,
  122.             'invalid_message' => 'Please select a valid file.',
  123.         ]);
  124.     }
  126.     public function getBlockPrefix(): string
  127.     {
  128.         return 'file';
  129.     }
  131.     private function getFileUploadError(int $errorCode)
  132.     {
  133.         $messageParameters = [];
  135.         if (\UPLOAD_ERR_INI_SIZE === $errorCode) {
  136.             [$limitAsString, $suffix] = $this->factorizeSizes(0, self::getMaxFilesize());
  137.             $messageTemplate = 'The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.';
  138.             $messageParameters = [
  139.                 '{{ limit }}' => $limitAsString,
  140.                 '{{ suffix }}' => $suffix,
  141.             ];
  142.         } elseif (\UPLOAD_ERR_FORM_SIZE === $errorCode) {
  143.             $messageTemplate = 'The file is too large.';
  144.         } else {
  145.             $messageTemplate = 'The file could not be uploaded.';
  146.         }
  148.         if (null !== $this->translator) {
  149.             $message = $this->translator->trans($messageTemplate, $messageParameters, 'validators');
  150.         } else {
  151.             $message = strtr($messageTemplate, $messageParameters);
  152.         }
  154.         return new FileUploadError($message, $messageTemplate, $messageParameters);
  155.     }
  157.     /**
  158.      * Returns the maximum size of an uploaded file as configured in php.ini.
  159.      *
  160.      * This method should be kept in sync with Symfony\Component\HttpFoundation\File\UploadedFile::getMaxFilesize().
  161.      */
  162.     private static function getMaxFilesize(): int|float
  163.     {
  164.         $iniMax = strtolower(\ini_get('upload_max_filesize'));
  166.         if ('' === $iniMax) {
  167.             return \PHP_INT_MAX;
  168.         }
  170.         $max = ltrim($iniMax, '+');
  171.         if (str_starts_with($max, '0x')) {
  172.             $max = \intval($max, 16);
  173.         } elseif (str_starts_with($max, '0')) {
  174.             $max = \intval($max, 8);
  175.         } else {
  176.             $max = (int) $max;
  177.         }
  179.         switch (substr($iniMax, -1)) {
  180.             case 't': $max *= 1024;
  181.                 // no break
  182.             case 'g': $max *= 1024;
  183.                 // no break
  184.             case 'm': $max *= 1024;
  185.                 // no break
  186.             case 'k': $max *= 1024;
  187.         }
  189.         return $max;
  190.     }
  192.     /**
  193.      * Converts the limit to the smallest possible number
  194.      * (i.e. try "MB", then "kB", then "bytes").
  195.      *
  196.      * This method should be kept in sync with Symfony\Component\Validator\Constraints\FileValidator::factorizeSizes().
  197.      */
  198.     private function factorizeSizes(int $size, int|float $limit)
  199.     {
  200.         $coef = self::MIB_BYTES;
  201.         $coefFactor = self::KIB_BYTES;
  203.         $limitAsString = (string) ($limit / $coef);
  205.         // Restrict the limit to 2 decimals (without rounding! we
  206.         // need the precise value)
  207.         while (self::moreDecimalsThan($limitAsString, 2)) {
  208.             $coef /= $coefFactor;
  209.             $limitAsString = (string) ($limit / $coef);
  210.         }
  212.         // Convert size to the same measure, but round to 2 decimals
  213.         $sizeAsString = (string) round($size / $coef, 2);
  215.         // If the size and limit produce the same string output
  216.         // (due to rounding), reduce the coefficient
  217.         while ($sizeAsString === $limitAsString) {
  218.             $coef /= $coefFactor;
  219.             $limitAsString = (string) ($limit / $coef);
  220.             $sizeAsString = (string) round($size / $coef, 2);
  221.         }
  223.         return [$limitAsString, self::SUFFIXES[$coef]];
  224.     }
  226.     /**
  227.      * This method should be kept in sync with Symfony\Component\Validator\Constraints\FileValidator::moreDecimalsThan().
  228.      */
  229.     private static function moreDecimalsThan(string $double, int $numberOfDecimals): bool
  230.     {
  231.         return \strlen($double) > \strlen(round($double, $numberOfDecimals));
  232.     }
  233. }