Просмотр файла app/Services/Validator.php

Конкурс дизайнеров на 15000 рублей
контркультура падонки бабруйск
Размер файла: 27.11Kb 
  1. <?php
  2.  
  3. declare(strict_types=1);
  4.  
  5. namespace App\Services;
  6.  
  7. use BadMethodCallException;
  8. use Countable;
  9. use Psr\Http\Message\UploadedFileInterface;
  10. use function DI\value;
  11.  
  12. /**
  13.  * Class Validation data
  14.  *
  15.  * @license Code and contributions have MIT License
  16.  * @link    https://visavi.net
  17.  * @author  Alexander Grigorev <admin@visavi.net>
  18.  *
  19.  * @method $this required(array|string $key, ?string $label = null)
  20.  * @method $this length(array|string $key, int $min, int $max, ?string $label = null)
  21.  * @method $this minLength(array|string $key, int $length, ?string $label = null)
  22.  * @method $this maxLength(array|string $key, int $length, ?string $label = null)
  23.  * @method $this range(array|string $key, int|float $min, int|float $max, ?string $label = null)
  24.  * @method $this gt(array|string $key, int|float $num, ?string $label = null)
  25.  * @method $this gte(array|string $key, int|float $num, ?string $label = null)
  26.  * @method $this lt(array|string $key, int|float $num, ?string $label = null)
  27.  * @method $this lte(array|string $key, int|float $num, ?string $label = null)
  28.  * @method $this same(string $key, mixed $value, string $label = null)
  29.  * @method $this notSame(string $key, mixed $value, string $label = null)
  30.  * @method $this equal(string $key1, string $key2, ?string $label = null)
  31.  * @method $this notEqual(string $key1, string $key2, ?string $label = null)
  32.  * @method $this empty(array|string $key, ?string $label = null)
  33.  * @method $this notEmpty(array|string $key, ?string $label = null)
  34.  * @method $this in(array|string $key, array $haystack, ?string $label = null)
  35.  * @method $this notIn(array|string $key, array $haystack, ?string $label = null)
  36.  * @method $this regex(array|string $key, string $pattern, ?string $label = null)
  37.  * @method $this url(array|string $key, ?string $label = null)
  38.  * @method $this email(array|string $key, ?string $label = null)
  39.  * @method $this ip(array|string $key, ?string $label = null)
  40.  * @method $this phone(array|string $key, ?string $label = null)
  41.  * @method $this boolean(array|string $key, ?string $label = null)
  42.  * @method $this file(string $key, array $rules)
  43.  * @method $this add(string $key, callable $callable, string $label)
  44.  * @method $this custom(bool $compare, array|string $label)
  45.  *
  46.  */
  47. class Validator
  48. {
  49.     private array $rules;
  50.     private array $errors;
  51.     private array $input;
  52.  
  53.     private array $data = [
  54.         'required'      => 'Поле %s является обязательным',
  55.         'length'        => [
  56.             'between' => 'Количество символов в поле %s должно быть от %d до %d',
  57.             'min'     => 'Количество символов в поле %s должно быть не меньше %d',
  58.             'max'     => 'Количество символов в поле %s должно быть не больше %d',
  59.         ],
  60.         'range'         => 'Значение поля %s должно быть между %d и %d',
  61.         'gt'            => 'Значение поля %s должно быть больше %d',
  62.         'gte'           => 'Значение поля %s должно быть больше или равно %d',
  63.         'lt'            => 'Значение поля %s должно быть меньше %d',
  64.         'lte'           => 'Значение поля %s должно быть меньше или равно %d',
  65.  
  66.         'equal'         => 'Значения полей %s и %s должны совпадать',
  67.         'notEqual'      => 'Значения полей %s и %s должны различаться',
  68.         'same'          => 'Значения поля %s должно быть равным %s',
  69.         'notSame'       => 'Значения поля %s должно быть не равным %s',
  70.  
  71.         'empty'         => 'Значение поля %s должно быть пустым',
  72.         'notEmpty'      => 'Значение поля %s не должно быть пустым',
  73.         'in'            => 'Значение поля %s ошибочно',
  74.         'notIn'         => 'Значение поля %s ошибочно',
  75.         'regex'         => 'Значение поля %s имеет ошибочный формат',
  76.         'url'           => 'Значение поля %s содержит недействительный URL',
  77.         'email'         => 'Значение поля %s содержит недействительный email',
  78.         'ip'            => 'Значение поля %s содержит недействительный IP-адрес',
  79.         'phone'         => 'Значение поля %s содержит недействительный номер телефона',
  80.         'file'          => [
  81.             'error'        => 'Ошибка загрузки файла',
  82.             'extension'    => 'Поле %s должно быть файлом одного из следующих типов: %s',
  83.             'size_max'     => 'Размер файла в поле %s должен быть не больше %s',
  84.             'weight_min'   => 'Размер изображения в поле %s не должен быть меньше %s px',
  85.             'weight_max'   => 'Размер изображения в поле %s не должен быть больше %s px',
  86.             'weight_empty' => 'Размер изображения в поле %s слишком маленький!',
  87.         ],
  88.         'boolean'          => 'Поле %s должно быть логического типа',
  89.     ];
  90.  
  91.     private array $images = ['jpg', 'jpeg', 'gif', 'png', 'bmp', 'webp'];
  92.  
  93.     /**
  94.      * Call
  95.      *
  96.      * @param string $name
  97.      * @param array  $arguments
  98.      *
  99.      * @return $this
  100.      */
  101.     public function __call(string $name, array $arguments): self
  102.     {
  103.         $keys = (array) $arguments[0];
  104.  
  105.         foreach ($keys as $key) {
  106.             $arguments[0] = $key;
  107.             $this->rules[$key][$name] = $arguments;
  108.         }
  109.  
  110.         return $this;
  111.     }
  112.  
  113.     /**
  114.      * Возвращает успешность валидации
  115.      *
  116.      * @param array $input
  117.      *
  118.      * @return bool
  119.      */
  120.     public function isValid(array $input): bool
  121.     {
  122.         $this->input = $input;
  123.  
  124.         foreach ($this->rules as $rules) {
  125.             foreach ($rules as $rule => $params) {
  126.                 $method = $rule . 'Rule';
  127.  
  128.                 if (! method_exists($this, $method)) {
  129.                     throw new BadMethodCallException(sprintf('%s() called undefined method. Method "%s" does not exist', __METHOD__, $rule));
  130.                 }
  131.  
  132.                 $this->$method(...$params);
  133.             }
  134.         }
  135.  
  136.         return empty($this->errors);
  137.     }
  138.  
  139.     /**
  140.      * Required
  141.      *
  142.      * @param array|string $key
  143.      * @param string|null  $label
  144.      *
  145.      * @return $this
  146.      */
  147.     private function requiredRule(array|string $key, ?string $label = null): self
  148.     {
  149.         $key = (array) $key;
  150.  
  151.         foreach ($key as $field) {
  152.             $input = $this->getInput($field);
  153.  
  154.             if ($this->blank($input)) {
  155.                 $this->addError($field, sprintf($label ?? $this->data['required'], $field));
  156.             }
  157.         }
  158.  
  159.         return $this;
  160.     }
  161.  
  162.     /**
  163.      * Length
  164.      *
  165.      * @param array|string $key
  166.      * @param int          $min
  167.      * @param int          $max
  168.      * @param string|null  $label
  169.      *
  170.      * @return $this
  171.      */
  172.     private function lengthRule(array|string $key, int $min, int $max, ?string $label = null): self
  173.     {
  174.         $key = (array) $key;
  175.  
  176.         foreach ($key as $field) {
  177.             $input = $this->getInput($field);
  178.  
  179.             if (! $this->isRequired($field) && $this->blank($input)) {
  180.                 return $this;
  181.             }
  182.  
  183.             if (mb_strlen((string) $input, 'UTF-8') < $min || mb_strlen((string) $input, 'UTF-8') > $max) {
  184.                 $this->addError($field, sprintf($label ?? $this->data['length']['between'], $field, $min, $max));
  185.             }
  186.         }
  187.  
  188.         return $this;
  189.     }
  190.  
  191.     /**
  192.      * Min length
  193.      *
  194.      * @param array|string $key
  195.      * @param int          $length
  196.      * @param string|null  $label
  197.      *
  198.      * @return $this
  199.      */
  200.     private function minLengthRule(array|string $key, int $length, ?string $label = null): self
  201.     {
  202.         $key = (array) $key;
  203.  
  204.         foreach ($key as $field) {
  205.             $input = $this->getInput($field);
  206.  
  207.             if (! $this->isRequired($field) && $this->blank($input)) {
  208.                 return $this;
  209.             }
  210.  
  211.             if (mb_strlen((string) $input, 'UTF-8') < $length) {
  212.                 $this->addError($field, sprintf($label ?? $this->data['length']['min'], $field, $length));
  213.             }
  214.         }
  215.  
  216.         return $this;
  217.     }
  218.  
  219.     /**
  220.      * Max length
  221.      *
  222.      * @param array|string $key
  223.      * @param int    $length
  224.      * @param string|null  $label
  225.      *
  226.      * @return $this
  227.      */
  228.     private function maxLengthRule(array|string $key, int $length, ?string $label = null): self
  229.     {
  230.         $key = (array) $key;
  231.  
  232.         foreach ($key as $field) {
  233.             $input = $this->getInput($field);
  234.  
  235.             if (! $this->isRequired($field) && $this->blank($input)) {
  236.                 return $this;
  237.             }
  238.  
  239.             if (mb_strlen((string) $input, 'UTF-8') > $length) {
  240.                 $this->addError($field, sprintf($label ?? $this->data['length']['max'], $field, $length));
  241.             }
  242.         }
  243.  
  244.         return $this;
  245.     }
  246.  
  247.     /**
  248.      * Range
  249.      *
  250.      * @param array|string $key
  251.      * @param int|float    $min
  252.      * @param int|float    $max
  253.      * @param string|null  $label
  254.      *
  255.      * @return $this
  256.      */
  257.     private function rangeRule(array|string $key, int|float $min, int|float $max, ?string $label = null): self
  258.     {
  259.         $key = (array) $key;
  260.  
  261.         foreach ($key as $field) {
  262.             $input = $this->getInput($field);
  263.  
  264.             if (! $this->isRequired($field) && $this->blank($input)) {
  265.                 return $this;
  266.             }
  267.  
  268.             if ($input < $min || $input > $max) {
  269.                 $this->addError($field, sprintf($label ?? $this->data['range'], $field, $min, $max));
  270.             }
  271.         }
  272.  
  273.         return $this;
  274.     }
  275.  
  276.     /**
  277.      * Greater than
  278.      *
  279.      * @param array|string $key
  280.      * @param int|float    $num
  281.      * @param string|null  $label
  282.      *
  283.      * @return $this
  284.      */
  285.     private function gtRule(array|string $key, int|float $num, ?string $label = null): self
  286.     {
  287.         $key = (array) $key;
  288.  
  289.         foreach ($key as $field) {
  290.             $input = $this->getInput($field);
  291.  
  292.             if (! $this->isRequired($field) && $this->blank($input)) {
  293.                 return $this;
  294.             }
  295.  
  296.             if ($input <= $num) {
  297.                 $this->addError($field, sprintf($label ?? $this->data['gt'], $field, $num));
  298.             }
  299.         }
  300.  
  301.         return $this;
  302.     }
  303.  
  304.     /**
  305.      * Greater than or equal
  306.      *
  307.      * @param array|string $key
  308.      * @param int|float    $num
  309.      * @param string|null  $label
  310.      *
  311.      * @return $this
  312.      */
  313.     private function gteRule(array|string $key, int|float $num, ?string $label = null): self
  314.     {
  315.         $key = (array) $key;
  316.  
  317.         foreach ($key as $field) {
  318.             $input = $this->getInput($field);
  319.  
  320.             if (! $this->isRequired($field) && $this->blank($input)) {
  321.                 return $this;
  322.             }
  323.  
  324.             if ($input < $num) {
  325.                 $this->addError($field, sprintf($label ?? $this->data['gte'], $field, $num));
  326.             }
  327.         }
  328.  
  329.         return $this;
  330.     }
  331.  
  332.     /**
  333.      * Less than
  334.      *
  335.      * @param array|string $key
  336.      * @param int|float    $num
  337.      * @param string|null  $label
  338.      *
  339.      * @return $this
  340.      */
  341.     private function ltRule(array|string $key, int|float $num, ?string $label = null): self
  342.     {
  343.         $key = (array) $key;
  344.  
  345.         foreach ($key as $field) {
  346.             $input = $this->getInput($field);
  347.  
  348.             if (! $this->isRequired($field) && $this->blank($input)) {
  349.                 return $this;
  350.             }
  351.  
  352.             if ($input >= $num) {
  353.                 $this->addError($field, sprintf($label ?? $this->data['lt'], $field, $num));
  354.             }
  355.         }
  356.  
  357.         return $this;
  358.     }
  359.  
  360.     /**
  361.      * Less than or equal
  362.      *
  363.      * @param array|string $key
  364.      * @param int|float    $num
  365.      * @param string|null  $label
  366.      *
  367.      * @return $this
  368.      */
  369.     private function lteRule(array|string $key, int|float $num, ?string $label = null): self
  370.     {
  371.         $key = (array) $key;
  372.  
  373.         foreach ($key as $field) {
  374.             $input = $this->getInput($field);
  375.  
  376.             if (! $this->isRequired($field) && $this->blank($input)) {
  377.                 return $this;
  378.             }
  379.  
  380.             if ($input > $num) {
  381.                 $this->addError($field, sprintf($label ?? $this->data['lte'], $field, $num));
  382.             }
  383.         }
  384.  
  385.         return $this;
  386.     }
  387.  
  388.     /**
  389.      * Same rule
  390.      *
  391.      * @param string      $key
  392.      * @param mixed       $value
  393.      * @param string|null $label
  394.      *
  395.      * @return $this
  396.      */
  397.     private function sameRule(string $key, mixed $value, ?string $label = null): self
  398.     {
  399.         $input = $this->getInput($key);
  400.  
  401.         if (! $this->isRequired($key) && $this->blank($input)) {
  402.             return $this;
  403.         }
  404.  
  405.         if ($input !== $value) {
  406.             $this->addError($key, sprintf($label ?? $this->data['same'], $key, $value));
  407.         }
  408.  
  409.         return $this;
  410.     }
  411.  
  412.     /**
  413.      * Not same rule
  414.      *
  415.      * @param string      $key
  416.      * @param mixed       $value
  417.      * @param string|null $label
  418.      *
  419.      * @return $this
  420.      */
  421.     private function notSameRule(string $key, mixed $value, ?string $label = null): self
  422.     {
  423.         $input = $this->getInput($key);
  424.  
  425.         if (! $this->isRequired($key) && $this->blank($input)) {
  426.             return $this;
  427.         }
  428.  
  429.         if ($input === $value) {
  430.             $this->addError($key, sprintf($label ?? $this->data['notSame'], $key, $value));
  431.         }
  432.  
  433.         return $this;
  434.     }
  435.  
  436.     /**
  437.      * Equal
  438.      *
  439.      * @param string      $key1
  440.      * @param string      $key2
  441.      * @param string|null $label
  442.      *
  443.      * @return $this
  444.      */
  445.     private function equalRule(string $key1, string $key2, ?string $label = null): self
  446.     {
  447.         $input1 = $this->getInput($key1);
  448.         $input2 = $this->getInput($key2);
  449.  
  450.         if (! $this->isRequired($key1) && $this->blank($input1)) {
  451.             return $this;
  452.         }
  453.  
  454.         if ($input1 !== $input2) {
  455.             $this->addError($key1, sprintf($label ?? $this->data['equal'], $key1, $key2));
  456.         }
  457.  
  458.         return $this;
  459.     }
  460.  
  461.     /**
  462.      * Not equal
  463.      *
  464.      * @param string      $key1
  465.      * @param string      $key2
  466.      * @param string|null $label
  467.      *
  468.      * @return $this
  469.      */
  470.     private function notEqualRule(string $key1, string $key2, ?string $label = null): self
  471.     {
  472.         $input1 = $this->getInput($key1);
  473.         $input2 = $this->getInput($key2);
  474.  
  475.         if (! $this->isRequired($key1) && $this->blank($input1)) {
  476.             return $this;
  477.         }
  478.  
  479.         if ($input1 === $input2) {
  480.             $this->addError($key1, sprintf($label ?? $this->data['notEqual'], $key1, $key2));
  481.         }
  482.  
  483.         return $this;
  484.     }
  485.  
  486.     /**
  487.      * Empty
  488.      *
  489.      * @param array|string $key
  490.      * @param string|null  $label
  491.      *
  492.      * @return $this
  493.      */
  494.     private function emptyRule(array|string $key, ?string $label = null): self
  495.     {
  496.         $key = (array) $key;
  497.  
  498.         foreach ($key as $field) {
  499.             $input = $this->getInput($field);
  500.  
  501.             if (! $this->isRequired($field) && $this->blank($input)) {
  502.                 return $this;
  503.             }
  504.  
  505.             if (! $this->blank($input)) {
  506.                 $this->addError($field, sprintf($label ?? $this->data['empty'], $field));
  507.             }
  508.         }
  509.  
  510.         return $this;
  511.     }
  512.  
  513.     /**
  514.      * Not empty
  515.      *
  516.      * @param array|string $key
  517.      * @param string|null  $label
  518.      *
  519.      * @return $this
  520.      */
  521.     private function notEmptyRule(array|string $key, ?string $label = null): self
  522.     {
  523.         $key = (array) $key;
  524.  
  525.         foreach ($key as $field) {
  526.             $input = $this->getInput($field);
  527.  
  528.             if (! $this->isRequired($field) && $this->blank($input)) {
  529.                 return $this;
  530.             }
  531.  
  532.             if ($this->blank($input)) {
  533.                 $this->addError($field, sprintf($label ?? $this->data['notEmpty'], $field));
  534.             }
  535.         }
  536.  
  537.         return $this;
  538.     }
  539.  
  540.     /**
  541.      * In
  542.      *
  543.      * @param array|string $key
  544.      * @param array        $haystack
  545.      * @param string|null  $label
  546.      *
  547.      * @return $this
  548.      */
  549.     private function inRule(array|string $key, array $haystack, ?string $label = null): self
  550.     {
  551.         $key = (array) $key;
  552.  
  553.         foreach ($key as $field) {
  554.             $input = $this->getInput($field);
  555.  
  556.             if (! $this->isRequired($field) && $this->blank($input)) {
  557.                 return $this;
  558.             }
  559.  
  560.             if (! in_array($input, $haystack, true)) {
  561.                 $this->addError($field, sprintf($label ?? $this->data['in'], $field));
  562.             }
  563.         }
  564.  
  565.         return $this;
  566.     }
  567.  
  568.     /**
  569.      * Not in
  570.      *
  571.      * @param array|string $key
  572.      * @param array        $haystack
  573.      * @param string|null  $label
  574.      *
  575.      * @return $this
  576.      */
  577.     private function notInRule(array|string $key, array $haystack, ?string $label = null): self
  578.     {
  579.         $key = (array) $key;
  580.  
  581.         foreach ($key as $field) {
  582.             $input = $this->getInput($field);
  583.  
  584.             if (! $this->isRequired($field) && $this->blank($input)) {
  585.                 return $this;
  586.             }
  587.  
  588.             if (in_array($input, $haystack, true)) {
  589.                 $this->addError($field, sprintf($label ?? $this->data['notIn'], $field));
  590.             }
  591.         }
  592.  
  593.         return $this;
  594.     }
  595.  
  596.     /**
  597.      * Regex
  598.      *
  599.      * @param array|string $key
  600.      * @param string       $pattern
  601.      * @param string|null  $label
  602.      *
  603.      * @return $this
  604.      */
  605.     private function regexRule(array|string $key, string $pattern, ?string $label = null): self
  606.     {
  607.         $key = (array) $key;
  608.  
  609.         foreach ($key as $field) {
  610.             $input = $this->getInput($field);
  611.  
  612.             if (! $this->isRequired($field) && $this->blank($input)) {
  613.                 return $this;
  614.             }
  615.  
  616.             if (! preg_match($pattern, $input)) {
  617.                 $this->addError($field, sprintf($label ?? $this->data['regex'], $field));
  618.             }
  619.         }
  620.  
  621.         return $this;
  622.     }
  623.  
  624.     /**
  625.      * Check url
  626.      *
  627.      * @param array|string $key
  628.      * @param string|null  $label
  629.      *
  630.      * @return $this
  631.      */
  632.     private function urlRule(array|string $key, ?string $label = null): self
  633.     {
  634.         $key = (array) $key;
  635.  
  636.         foreach ($key as $field) {
  637.             $input = $this->getInput($field);
  638.  
  639.             if (! $this->isRequired($field) && $this->blank($input)) {
  640.                 return $this;
  641.             }
  642.  
  643.             if (! preg_match('|^https?://([а-яa-z0-9_\-.])+(\.([а-яa-z0-9/\-?_=#])+)+$|iu', $input)) {
  644.                 $this->addError($field, sprintf($label ?? $this->data['url'], $field));
  645.             }
  646.         }
  647.  
  648.         return $this;
  649.     }
  650.  
  651.     /**
  652.      * Check email
  653.      *
  654.      * @param array|string $key
  655.      * @param string|null  $label
  656.      *
  657.      * @return $this
  658.      */
  659.     private function emailRule(array|string $key, ?string $label = null): self
  660.     {
  661.         $key = (array) $key;
  662.  
  663.         foreach ($key as $field) {
  664.             $input = $this->getInput($field);
  665.  
  666.             if (! $this->isRequired($field) && $this->blank($input)) {
  667.                 return $this;
  668.             }
  669.  
  670.             if (filter_var($input, FILTER_VALIDATE_EMAIL) === false) {
  671.                 $this->addError($field, sprintf($label ?? $this->data['email'], $field));
  672.             }
  673.         }
  674.  
  675.         return $this;
  676.     }
  677.  
  678.     /**
  679.      * Check IP address
  680.      *
  681.      * @param array|string $key
  682.      * @param string|null  $label
  683.      *
  684.      * @return $this
  685.      */
  686.     private function ipRule(array|string $key, ?string $label = null): self
  687.     {
  688.         $key = (array) $key;
  689.  
  690.         foreach ($key as $field) {
  691.             $input = $this->getInput($field);
  692.  
  693.             if (! $this->isRequired($field) && $this->blank($input)) {
  694.                 return $this;
  695.             }
  696.  
  697.             if (filter_var($input, FILTER_VALIDATE_IP) === false) {
  698.                 $this->addError($field, sprintf($label ?? $this->data['ip'], $field));
  699.             }
  700.         }
  701.  
  702.         return $this;
  703.     }
  704.  
  705.     /**
  706.      * Check phone
  707.      *
  708.      * @param array|string $key
  709.      * @param string|null  $label
  710.      *
  711.      * @return $this
  712.      */
  713.     private function phoneRule(array|string $key, ?string $label = null): self
  714.     {
  715.         $key = (array) $key;
  716.  
  717.         foreach ($key as $field) {
  718.             $input = $this->getInput($field);
  719.  
  720.             if (! $this->isRequired($field) && $this->blank($input)) {
  721.                 return $this;
  722.             }
  723.  
  724.             if (! preg_match('#^\d{8,13}$#', $input)) {
  725.                 $this->addError($field, sprintf($label ?? $this->data['phone'], $field));
  726.             }
  727.         }
  728.  
  729.         return $this;
  730.     }
  731.  
  732.     /**
  733.      * Boolean rule
  734.      *
  735.      * @param array|string $key
  736.      * @param string|null  $label
  737.      *
  738.      * @return $this
  739.      */
  740.     private function booleanRule(array|string $key, ?string $label = null): self
  741.     {
  742.         $key = (array) $key;
  743.  
  744.         foreach ($key as $field) {
  745.             $input = $this->getInput($field);
  746.  
  747.             if (! $this->isRequired($field) && $this->blank($input)) {
  748.                 return $this;
  749.             }
  750.  
  751.             if (! in_array($input, [1, '1', 0, '0', true, false], true)) {
  752.                 $this->addError($field, sprintf($label ?? $this->data['boolean'], $field));
  753.             }
  754.         }
  755.  
  756.         return $this;
  757.     }
  758.  
  759.     /**
  760.      * Add rule
  761.      *
  762.      * @param string   $key
  763.      * @param callable $callable
  764.      * @param string   $label
  765.      *
  766.      * @return $this
  767.      */
  768.     private function addRule(string $key, callable $callable, string $label): self
  769.     {
  770.         $input = $this->getInput($key);
  771.  
  772.         if (! $callable($input)) {
  773.             $this->addError($key, $label);
  774.         }
  775.  
  776.         return $this;
  777.     }
  778.  
  779.     /**
  780.      * Custom rule
  781.      *
  782.      * @param bool         $compare
  783.      * @param array|string $label
  784.      *
  785.      * @return $this
  786.      */
  787.     private function customRule(bool $compare, array|string $label): self
  788.     {
  789.         $key = '';
  790.  
  791.         if (is_array($label)) {
  792.             $key = key($label);
  793.             $label = $label[$key];
  794.         }
  795.  
  796.         if (! $compare) {
  797.             $this->addError($key, $label);
  798.         }
  799.  
  800.         return $this;
  801.     }
  802.  
  803.     /**
  804.      * Проверяет файл
  805.      *
  806.      * @param string $key
  807.      * @param array  $rules
  808.      *
  809.      * @return $this
  810.      */
  811.     private function fileRule(string $key, array $rules): self
  812.     {
  813.         $input = $this->getInput($key);
  814.  
  815.         if (! $this->isRequired($key) && $this->blank($input)) {
  816.             return $this;
  817.         }
  818.  
  819.         if (! $input instanceof UploadedFileInterface) {
  820.             $this->addError($key, sprintf($this->data['file']['error'], $key));
  821.             return $this;
  822.         }
  823.  
  824.         if ($input->getError() !== UPLOAD_ERR_OK) {
  825.             $this->addError($key, $this->getUploadErrorByCode($input->getError()));
  826.             return $this;
  827.         }
  828.  
  829.         if (empty($rules['extensions'])) {
  830.             $rules['extensions'] = $this->images;
  831.         }
  832.  
  833.         $extension = strtolower(pathinfo($input->getClientFilename(), PATHINFO_EXTENSION));
  834.         if (! in_array($extension, $rules['extensions'], true)) {
  835.             $this->addError($key, sprintf($this->data['file']['extension'], $key, implode(', ', $rules['extensions'])));
  836.         }
  837.  
  838.         if (isset($rules['size_max']) && $input->getSize() > $rules['size_max']) {
  839.             $this->addError($key, sprintf($this->data['file']['size_max'], $key, formatSize($rules['size_max'])));
  840.         }
  841.  
  842.         if (in_array($extension, $this->images, true)) {
  843.             [$width, $height] = getimagesize($input->getFilePath());
  844.  
  845.             if (isset($rules['weight_max'])) {
  846.                 if ($width > $rules['weight_max'] || $height > $rules['weight_max']) {
  847.                     $this->addError($key, sprintf($this->data['file']['weight_max'], $key, $rules['weight_max']));
  848.                 }
  849.             }
  850.  
  851.             if (isset($rules['weight_min'])) {
  852.                 if ($width < $rules['weight_min'] || $height < $rules['weight_min']) {
  853.                     $this->addError($key, sprintf($this->data['file']['weight_min'], $key, $rules['weight_min']));
  854.                 }
  855.             } elseif (empty($width) || empty($height)) {
  856.                 $this->addError($key, sprintf($this->data['file']['weight_empty'], $key));
  857.             }
  858.         }
  859.  
  860.         return $this;
  861.     }
  862.  
  863.     /**
  864.      * Add error
  865.      *
  866.      * @param string $key   Field name
  867.      * @param string $label Text error
  868.      *
  869.      * @return void
  870.      */
  871.     public function addError(string $key, string $label): void
  872.     {
  873.         if (isset($this->errors[$key])) {
  874.             $this->errors[] = $label;
  875.         } else {
  876.             $this->errors[$key] = $label;
  877.         }
  878.     }
  879.  
  880.     /**
  881.      * Get errors
  882.      *
  883.      * @return array
  884.      */
  885.     public function getErrors(): array
  886.     {
  887.         return $this->errors;
  888.     }
  889.  
  890.     /**
  891.      * Determine if the given value is "blank".
  892.      *
  893.      * @param  mixed  $value
  894.      * @return bool
  895.      */
  896.     private function blank(mixed $value): bool
  897.     {
  898.         if (is_null($value)) {
  899.             return true;
  900.         }
  901.  
  902.         if (is_string($value)) {
  903.             return trim($value) === '';
  904.         }
  905.  
  906.         if (is_numeric($value) || is_bool($value)) {
  907.             return false;
  908.         }
  909.  
  910.         if ($value instanceof Countable) {
  911.             return count($value) === 0;
  912.         }
  913.  
  914.         if ($value instanceof UploadedFileInterface) {
  915.             return $value->getError() === UPLOAD_ERR_NO_FILE;
  916.         }
  917.  
  918.         return empty($value);
  919.     }
  920.  
  921.     /**
  922.      * Is required
  923.      *
  924.      * @param string $key
  925.      * @return bool
  926.      */
  927.     private function isRequired(string $key): bool
  928.     {
  929.         return isset($this->rules[$key]['required']);
  930.     }
  931.  
  932.     /**
  933.      * Get input
  934.      *
  935.      * @param string     $key
  936.      * @param mixed|null $default
  937.      *
  938.      * @return mixed
  939.      */
  940.     private function getInput(string $key, mixed $default = null): mixed
  941.     {
  942.         return $this->input[$key] ?? $default;
  943.     }
  944.  
  945.     /**
  946.      * Get upload error by code
  947.      *
  948.      * @param int $code
  949.      *
  950.      * @return string
  951.      */
  952.     private function getUploadErrorByCode(int $code): string
  953.     {
  954.         return match ($code) {
  955.             UPLOAD_ERR_INI_SIZE   => 'Размер файла превысил значение upload_max_filesize',
  956.             UPLOAD_ERR_FORM_SIZE  => 'Размер файла превысил значение MAX_FILE_SIZE',
  957.             UPLOAD_ERR_PARTIAL    => 'Загруженный файл был загружен только частично',
  958.             UPLOAD_ERR_NO_FILE    => 'Файл не был загружен',
  959.             UPLOAD_ERR_NO_TMP_DIR => 'Отсутствует временная папка',
  960.             UPLOAD_ERR_CANT_WRITE => 'Не удалось записать файл на диск',
  961.             UPLOAD_ERR_EXTENSION  => 'Модуль PHP остановил загрузку файла',
  962.             default               => 'Неизвестная ошибка загрузки',
  963.         };
  964.     }
  965. }