Просмотр файла app/classes/Validation.php

Конкурс дизайнеров на 15000 рублей
Скрипты | CMS | Боты
Размер файла: 10.77Kb 
  1. <?php
  2. /**
  3.  * Класс валидации данных
  4.  * Выполняет простейшую валидацию данных, длина строк, размеры чисел, сравнение, наличие в списке итд
  5.  * @license Code and contributions have MIT License
  6.  * @link    http://visavi.net
  7.  * @author  Alexander Grigorev <visavi.net@mail.ru>
  8.  */
  9. class Validation
  10. {
  11.     /**
  12.      * @var array validation errors
  13.      */
  14.     private $errors = [];
  15.  
  16.     /**
  17.      * @var array validation rules
  18.      */
  19.     private $validation_rules = [];
  20.  
  21.     /**
  22.      * the constructor, duh!
  23.      */
  24.     public function __construct()
  25.     {
  26.     }
  27.  
  28.     /**
  29.      * run the validation rules
  30.      * @return bool;
  31.      */
  32.     public function run()
  33.     {
  34.         foreach (new ArrayIterator($this->validation_rules) as $opt) {
  35.             switch ($opt['type']) {
  36.                 case 'string':
  37.                     $this->validateString($opt['var'], $opt['label'], $opt['min'], $opt['max'], $opt['required']);
  38.                     break;
  39.  
  40.                 case 'numeric':
  41.                     $this->validateNumeric($opt['var'], $opt['label'], $opt['min'], $opt['max'], $opt['required']);
  42.                     break;
  43.  
  44.                 case 'max':
  45.                     $this->validateMax($opt['var'], $opt['label']);
  46.                     break;
  47.  
  48.                 case 'min':
  49.                     $this->validateMin($opt['var'], $opt['label']);
  50.                     break;
  51.  
  52.                 case 'equal':
  53.                     $this->validateEqual($opt['var'], $opt['label']);
  54.                     break;
  55.  
  56.                 case 'not_equal':
  57.                     $this->validateNotEqual($opt['var'], $opt['label']);
  58.                     break;
  59.  
  60.                 case 'empty':
  61.                     $this->validateEmpty($opt['var'], $opt['label']);
  62.                     break;
  63.  
  64.                 case 'not_empty':
  65.                     $this->validateNotEmpty($opt['var'], $opt['label']);
  66.                     break;
  67.  
  68.                 case 'in':
  69.                     $this->validateIn($opt['var'], $opt['label']);
  70.                     break;
  71.  
  72.                 case 'regex':
  73.                     $this->validateRegex($opt['var'], $opt['label'], $opt['required']);
  74.                     break;
  75.  
  76.                 case 'float':
  77.                     $this->validateFloat($opt['var'], $opt['label'], $opt['required']);
  78.                     break;
  79.  
  80.                 case 'url':
  81.                     $this->validateUrl($opt['var'], $opt['label'], $opt['required']);
  82.                     break;
  83.  
  84.                 case 'email':
  85.                     $this->validateEmail($opt['var'], $opt['label'], $opt['required']);
  86.                     break;
  87.  
  88.                 case 'bool':
  89.                     $this->validateBool($opt['var'], $opt['label']);
  90.                     break;
  91.  
  92.                 case 'custom':
  93.                     $this->validateCustom($opt['var'], $opt['label']);
  94.                     break;
  95.  
  96.                 default:
  97.                     $this->addError('Ошибка! Не найден тип правила "' . $opt['type'] . '"');
  98.             }
  99.         }
  100.  
  101.         if ($this->getErrors()) {
  102.             return false;
  103.         }
  104.  
  105.         return true;
  106.     }
  107.  
  108.     /**
  109.      * add a rule to the validation rules array
  110.      * @param string $type The type of variable
  111.      * @param string $var The variable
  112.      * @param mixed $label The label of variable
  113.      * @param bool $required If the field is required
  114.      * @param int $min The minimum length or range
  115.      * @param int $max The maximum length or range
  116.      * @return $this
  117.      */
  118.     public function addRule($type, $var, $label, $required = false, $min = 0, $max = 0)
  119.     {
  120.         $this->validation_rules[] = compact('type', 'var', 'label', 'required', 'min', 'max');
  121.         return $this;
  122.     }
  123.  
  124.     /**
  125.      * displays an error
  126.      * @param string $error The error text
  127.      * @param null $description
  128.      */
  129.     public function addError($error, $description = null)
  130.     {
  131.         $key = 0;
  132.  
  133.         if (is_array($error)) {
  134.             $key   = key($error);
  135.             $error = current($error);
  136.         }
  137.  
  138.         if (isset($this->errors[$key])) {
  139.             $this->errors[] = $error.$description;
  140.         } else {
  141.             $this->errors[$key] = $error.$description;
  142.         }
  143.  
  144.     }
  145.  
  146.     /**
  147.      * Возвращает список ошибок
  148.      * @return array
  149.      */
  150.     public function getErrors()
  151.     {
  152.         return $this->errors;
  153.     }
  154.  
  155.     /**
  156.      * validate a string
  157.      * @param string $var The variable
  158.      * @param mixed $label The label of variable
  159.      * @param int $min The minimum string length
  160.      * @param int $max The maximum string length
  161.      * @param bool $required
  162.      * @return bool
  163.      */
  164.     private function validateString($var, $label, $min = 0, $max = 0, $required = false)
  165.     {
  166.         if ($required == false && mb_strlen($var, 'utf-8') == 0) {
  167.             return true;
  168.         }
  169.  
  170.         if (mb_strlen($var, 'utf-8') < $min) {
  171.             $this->addError($label, ' (Не менее ' . $min . ' симв.)');
  172.         } elseif (mb_strlen($var, 'utf-8') > $max) {
  173.             $this->addError($label, ' (Не более ' . $max . ' симв.)');
  174.         }
  175.     }
  176.  
  177.     /**
  178.      * Checks whether numeric input has a minimum value
  179.      * @param  array $var   The variable
  180.      * @param  mixed $label The label of variable
  181.      * @return bool
  182.      */
  183.     private function validateMin($var, $label)
  184.     {
  185.         if (is_array($var) && count($var) == 2 && $var[0] <= $var[1]) {
  186.             return true;
  187.         } else {
  188.             $this->addError($label);
  189.         }
  190.     }
  191.  
  192.     /**
  193.      * Checks whether numeric input has a maximum value
  194.      * @param  array $var   The variable
  195.      * @param  mixed $label The label of variable
  196.      * @return bool
  197.      */
  198.     private function validateMax($var, $label)
  199.     {
  200.         if (is_array($var) && count($var) == 2 && $var[0] >= $var[1]) {
  201.             return true;
  202.         } else {
  203.             $this->addError($label);
  204.         }
  205.     }
  206.  
  207.     /**
  208.      * validate an number
  209.      * @param int $var The variable
  210.      * @param mixed $label The label of variable
  211.      * @param int $min The minimum number range
  212.      * @param int $max The maximum number range
  213.      * @param bool $required
  214.      *
  215.      * @return bool
  216.      */
  217.     private function validateNumeric($var, $label, $min = 0, $max = 0, $required = false)
  218.     {
  219.         if ($required == false && mb_strlen($var, 'utf-8') == 0) {
  220.             return true;
  221.         }
  222.  
  223.         if (filter_var($var, FILTER_VALIDATE_INT, ['options' => ['min_range' => $min, 'max_range' => $max]]) === false) {
  224.             $this->addError($label);
  225.         }
  226.     }
  227.  
  228.     /**
  229.      * validate a equality
  230.      * @param array $var List of variables
  231.      * @param mixed $label The label of variable
  232.      * @return bool
  233.      */
  234.     private function validateEqual($var, $label)
  235.     {
  236.         if (is_array($var) && count($var) == 2 && $var[0] === $var[1]) {
  237.             return true;
  238.         } else {
  239.             $this->addError($label);
  240.         }
  241.     }
  242.  
  243.     /**
  244.      * validate the inequality
  245.      * @param array $var List of variables
  246.      * @param mixed $label The label of variable
  247.      * @return bool
  248.      */
  249.     private function validateNotEqual($var, $label)
  250.     {
  251.         if (is_array($var) && count($var) == 2 && $var[0] !== $var[1]) {
  252.             return true;
  253.         } else {
  254.             $this->addError($label);
  255.         }
  256.     }
  257.  
  258.     /**
  259.      * validate is empty
  260.      * @param string $var The variable
  261.      * @param mixed $label The label of variable
  262.      */
  263.     private function validateEmpty($var, $label)
  264.     {
  265.         if (!empty($var)) {
  266.             $this->addError($label);
  267.         }
  268.     }
  269.  
  270.     /**
  271.      * validate is not empty
  272.      * @param string $var The variable
  273.      * @param mixed $label The label of variable
  274.      */
  275.     private function validateNotEmpty($var, $label)
  276.     {
  277.         if (empty($var)) {
  278.             $this->addError($label);
  279.         }
  280.     }
  281.  
  282.     /**
  283.      * validate is InArray
  284.      * @param array $var List of variables
  285.      * @param mixed $label The label of variable
  286.      * @return bool
  287.      */
  288.     private function validateIn($var, $label)
  289.     {
  290.         if (is_array($var) && count($var) == 2 && in_array($var[0], $var[1], true)) {
  291.             return true;
  292.         } else {
  293.             $this->addError($label);
  294.         }
  295.     }
  296.  
  297.     /**
  298.      * validate on a regular expression
  299.      * @param string $var The variable
  300.      * @param mixed $label The label of variable
  301.      * @param bool $required
  302.      * @return bool
  303.      */
  304.     private function validateRegex($var, $label, $required = false)
  305.     {
  306.         if (is_array($var) && count($var) == 2 && $required == false && mb_strlen($var[0], 'utf-8') == 0) {
  307.             return true;
  308.         }
  309.  
  310.         if (!preg_match($var[1], $var[0])) {
  311.             $this->addError($label);
  312.         }
  313.     }
  314.  
  315.     /**
  316.      * validate a floating point number
  317.      * @param string $var The variable
  318.      * @param mixed $label The label of variable
  319.      * @param bool $required
  320.      * @return bool
  321.      */
  322.  
  323.     private function validateFloat($var, $label, $required = false)
  324.     {
  325.         if ($required == false && mb_strlen($var, 'utf-8') == 0) {
  326.             return true;
  327.         }
  328.  
  329.         if (filter_var($var, FILTER_VALIDATE_FLOAT) === false) {
  330.             $this->addError($label);
  331.         }
  332.     }
  333.  
  334.     /**
  335.      * validate a url
  336.      * @param string $var The variable
  337.      * @param mixed $label The label of variable
  338.      * @param bool $required
  339.      * @return bool
  340.      */
  341.     private function validateUrl($var, $label, $required = false)
  342.     {
  343.         if ($required == false && mb_strlen($var, 'utf-8') == 0) {
  344.             return true;
  345.         }
  346.  
  347.         if (!preg_match('#^https?://([а-яa-z0-9_\-\.])+(\.([а-яa-z0-9\/])+)+$#u', $var)) {
  348.             $this->addError($label);
  349.         }
  350.     }
  351.  
  352.     /**
  353.      * validate a email address
  354.      * @param string $var The variable
  355.      * @param mixed $label The label of variable
  356.      * @param bool $required
  357.      * @return bool
  358.      */
  359.     private function validateEmail($var, $label, $required = false)
  360.     {
  361.         if ($required == false && mb_strlen($var, 'utf-8') == 0) {
  362.             return true;
  363.         }
  364.  
  365.         if (!preg_match('#^([a-z0-9_\-\.])+\@([a-z0-9_\-\.])+(\.([a-z0-9])+)+$#', $var)) {
  366.             $this->addError($label);
  367.         }
  368.     }
  369.  
  370.     /**
  371.      * validate a boolean
  372.      * @param string $var The variable
  373.      * @param mixed $label The label of variable
  374.      * @internal param bool $required
  375.      */
  376.     private function validateBool($var, $label)
  377.     {
  378.         if (filter_var($var, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE) === false) {
  379.             $this->addError($label);
  380.         }
  381.     }
  382.  
  383.     /**
  384.      * validate custom
  385.      * @param string $condition The condition
  386.      * @param mixed $label The label of variable
  387.      */
  388.     private function validateCustom($condition, $label)
  389.     {
  390.         if (!$condition) {
  391.             $this->addError($label);
  392.         }
  393.     }
  394. }