Validations   A
last analyzed

Complexity

Total Complexity 30

Size/Duplication

Total Lines 241
Duplicated Lines 0 %

Coupling/Cohesion

Components 0
Dependencies 0

Importance

Changes 0
Metric Value
dl 0
loc 241
rs 10
c 0
b 0
f 0
wmc 30
lcom 0
cbo 0

17 Methods

Rating   Name   Duplication   Size   Complexity  
A numeric() 0 3 1
A int() 0 4 1
A maxlength() 0 5 2
A length() 0 8 2
A range() 0 7 3
A select() 0 5 3
A email() 0 4 1
A url() 0 5 2
A ip() 0 4 1
A required() 0 4 1
A alphanum() 0 4 1
A alpha() 0 4 1
A date() 0 6 3
A pattern() 0 5 3
A decimal() 0 5 2
A equal() 0 5 2
A getMessage() 0 12 1
1
<?php
2
/**
3
 * KumbiaPHP web & app Framework
4
 *
5
 * LICENSE
6
 *
7
 * This source file is subject to the new BSD license that is bundled
8
 * with this package in the file LICENSE.
9
 *
10
 * @category   Kumbia
11
 * @package    Validate
12
 *
13
 * @copyright  Copyright (c) 2005 - 2019 KumbiaPHP Team (http://www.kumbiaphp.com)
14
 * @license    https://github.com/KumbiaPHP/KumbiaPHP/blob/master/LICENSE   New BSD License
15
 */
16
17
/**
18
 * Validate es una Clase que realiza validaciones Lógicas
19
 *
20
 * @category   KumbiaPHP
21
 * @package    validate
22
 */
23
class Validations
24
{
25
    /**
26
     * Constantes para definir los patrones
27
     */
28
29
    /*
30
     * El valor deber ser solo letras y números
31
     */
32
    const IS_ALPHANUM = '/^[\p{Ll}\p{Lm}\p{Lo}\p{Lt}\p{Lu}\p{Nd}]*$/mu';
33
34
    /**
35
     * Solo letras
36
     */
37
    const IS_ALPHA    = '/^(?:[^\W\d_]|([ ]))*$/mu';
38
39
    /**
40
     * Almacena la Expresion Regular
41
     *
42
     * @var String
43
     */
44
    public static $regex = NULL;
45
46
47
    /**
48
     * Valida que sea numérico
49
     * @param  mixed $check Valor a ser chequeado
50
     * @return bool
51
     */
52
    public static function numeric($check){
53
        return is_numeric($check);
54
    }
55
56
    /**
57
     * Valida que int
58
     *
59
     * @param int $check
60
     * @return bool
61
     */
62
    public static function int($check)
63
    {
64
        return filter_var($check, FILTER_VALIDATE_INT);
65
    }
66
67
    /**
68
     * Valida que una cadena este entre un rango.
69
     * Los espacios son contados
70
     * Retorna true si el string $value se encuentra entre min and max
71
     *
72
     * @param string $value
73
     * @param array $param
74
     * @return bool
75
     */
76
    public static function maxlength($value, $param)
77
    {
78
        $max= isset($param['max'])?$param['max']:0;
79
        return !isset($value[$max]);
80
    }
81
82
    /**
83
     * Valida longitud de la cadena
84
     */
85
    public static function length($value, $param){
86
        $param = array_merge(array(
87
            'min' => 0,
88
            'max' => 9e100,
89
        ), $param);
90
        $length = strlen($value);
91
        return ($length >= $param['min'] && $length <= $param['max']);
92
    }
93
94
    /**
95
     * Valida que es un número se encuentre
96
     * en un rango minímo y máximo
97
     *
98
     * @param int $value
99
     * @param array $param min, max
100
     */
101
    public static function range($value, $param)
102
    {
103
        $min = isset($param['min']) ? $param['min'] : 0;
104
        $max = isset($param['max']) ? $param['max'] : 10;
105
        $int_options = array('options' => array('min_range'=>$min, 'max_range'=>$max));
106
        return filter_var($value, FILTER_VALIDATE_INT, $int_options);
107
    }
108
109
    /**
110
     * Valida que un valor se encuentre en una lista
111
     * Retorna true si el string $value se encuentra en la lista $list
112
     *
113
     * @param string $value
114
     * @param array $param
115
     * @return bool
116
     */
117
    public static function select($value, $param)
118
    {
119
        $list = isset($param['list']) && is_array($param['list']) ? $param['list'] : array();
120
        return in_array($value, array_keys($list));
121
    }
122
123
    /**
124
     * Valida que una cadena sea un mail
125
     * @param string $mail
126
     * @return bool
127
     */
128
    public static function email($mail)
129
    {
130
        return filter_var($mail, FILTER_VALIDATE_EMAIL);
131
    }
132
133
    /**
134
     * Valida URL
135
     *
136
     * @param string $url
137
     * @return bool
138
     */
139
    public static function url($url, $param)
140
    {
141
        $flag = isset($param['flag'])? $param['flag'] : 0;
142
        return filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED | $flag);
143
    }
144
145
    /**
146
     * Valida que sea una IP, por defecto v4
147
     * TODO: Revisar este método
148
     * @param String $ip
149
     * @return bool
150
     */
151
    public static function ip($ip, $flags = FILTER_FLAG_IPV4)
152
    {
153
        return filter_var($ip, FILTER_VALIDATE_IP, $flags);
154
    }
155
156
    /**
157
     * Valida que un string no sea null
158
     *
159
     * @param string $check
160
     * @return bool
161
     */
162
    public static function required($check)
163
    {
164
        return (boolean) strlen(trim($check));
165
    }
166
167
    /**
168
     * Valida que un String sea alpha-num (incluye caracteres acentuados)
169
     * TODO: Revisar este método
170
     *
171
     * @param string $string
172
     * @return bool
173
     */
174
    public static function alphanum($string)
175
    {
176
        return self::pattern($string, array('regexp' => self::IS_ALPHANUM));
177
    }
178
179
180
181
    /**
182
     * Valida que un String sea alpha (incluye caracteres acentuados y espacio)
183
     *
184
     * @param string $string
185
     * @return bool
186
     */
187
    public static function alpha($string)
188
    {
189
        return self::pattern($string, array('regexp' => self::IS_ALPHA));
190
    }
191
192
193
    /**
194
     * Valida una fecha
195
     * @param string $value fecha a validar acorde al formato indicado
196
     * @param array $param como en DateTime
197
     * @return boolean
198
     */
199
    public static function date($value, $param)
200
    {
201
        $format = isset($param['format'])? $param['format'] : 'Y-m-d';
202
        $date = DateTime::createFromFormat($format, $value);
203
        return $date && $date->format($format) == $value;
204
    }
205
206
    /**
207
     * Valida un string dada una Expresion Regular
208
     *
209
     * @param string $check
210
     * @param array $param  regex
211
     * @return bool
212
     */
213
    public static function pattern($check, $param)
214
    {
215
        $regex = isset($param['regexp'])? $param['regexp'] : '/.*/';
216
        return empty($check) || FALSE !== filter_var($check, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => $regex)));
217
    }
218
219
    /**
220
     * Valida si es un número decimal
221
     *
222
     * @param string $value
223
     * @param array $param
224
     * @return boolean
225
     */
226
    public static function decimal($value, $param)
227
    {
228
        $decimal = isset($param['decimal'])? $param['decimal'] : ',';
229
        return filter_var($value, FILTER_VALIDATE_FLOAT, array('options' => array('decimal' => $decimal)));
230
    }
231
232
    /**
233
     * Valida si los valores son iguales
234
     *
235
     * @param string $value
236
     * @param array $param
237
     * @param object $obj
238
     * @return boolean
239
     */
240
    public static function equal($value, $param, $obj)
241
    {
242
        $equal = isset($param['to'])? $param['to'] : '';
243
        return ($obj->$equal == $value);
244
    }
245
246
    /**
247
     * Devuelve el mensaje por defecto de una validación
248
     * @param string $key
249
     * @return string
250
     */
251
    public static function getMessage($key){
252
        $arr  = array(
253
            'required' => 'Este campo es requerido',
254
            'alphanum' => 'Debe ser un valor alfanumérico',
255
            'alpha'    => 'Solo caracteres alfabeticos',
256
            'length'   => 'Longitud incorrecta',
257
            'email'    => 'Email no válido',
258
            'pattern'  => 'El valor no posee el formato correcto',
259
            'date'     => 'Fecha no valida'
260
        );
261
        return $arr[$key];
262
    }
263
}
264