PageRenderTime 45ms CodeModel.GetById 17ms RepoModel.GetById 1ms app.codeStats 0ms

/cake/libs/validation.php

https://github.com/msadouni/cakephp2x
PHP | 839 lines | 564 code | 39 blank | 236 comment | 56 complexity | b4c23644938eeb0293bb159a77ab237f MD5 | raw file
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * Validation Class.  Used for validation of model data
    4. 

  4.  *
    5. 

  5.  * Long description for file
    6. 

  6.  *
    7. 

  7.  * PHP Version 5.x
    8. 

  8.  *
    9. 

  9.  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
    10. 

  10.  * Copyright 2005-2009, Cake Software Foundation, Inc. (http://cakefoundation.org)
    11. 

  11.  *
    12. 

  12.  * Licensed under The MIT License
    13. 

  13.  * Redistributions of files must retain the above copyright notice.
    14. 

  14.  *
    15. 

  15.  * @copyright     Copyright 2005-2009, Cake Software Foundation, Inc. (http://cakefoundation.org)
    16. 

  16.  * @link          http://cakephp.org CakePHP(tm) Project
    17. 

  17.  * @package       cake
    18. 

  18.  * @subpackage    cake.cake.libs
    19. 

  19.  * @since         CakePHP(tm) v 1.2.0.3830
    20. 

  20.  * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
    21. 

  21.  */
    22. 

  22. if (!class_exists('Multibyte')) {
    23. 

  23. 	App::import('Core', 'Multibyte', false);
    24. 

  24. }
    25. 

  25. 

  26. /**
    27. 

  27.  * Offers different validation methods.
    28. 

  28.  *
    29. 

  29.  * Long description for file
    30. 

  30.  *
    31. 

  31.  * @package       cake
    32. 

  32.  * @subpackage    cake.cake.libs
    33. 

  33.  * @since         CakePHP v 1.2.0.3830
    34. 

  34.  */
    35. 

  35. class Validation extends Object {
    36. 

  36. 

  37. /**
    38. 

  38.  * Some complex patterns needed in multiple places
    39. 

  39.  *
    40. 

  40.  * @var array
    41. 

  41.  * @access private
    42. 

  42.  */
    43. 

  43. 	private static $__pattern = array(
    44. 

  44. 		'ipv4' => '(?:(?:25[0-5]|2[0-4][0-9]|(?:(?:1[0-9])?|[1-9]?)[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|(?:(?:1[0-9])?|[1-9]?)[0-9])',
    45. 

  45. 		'ipv6' => '(?:(?:[a-f0-9]{1,4}:){7}[a-f0-9]{1,4}|[a-f0-9]{0,4}::|:(?::[a-f0-9]{1,4}){1,6}|(?:[a-f0-9]{1,4}:){1,6}:|(?:[a-f0-9]{1,4}:)(?::[a-f0-9]{1,4}){1,6})|(?:[a-f0-9]{1,4}:){2}(?::[a-f0-9]{1,4}){1,5}|(?:[a-f0-9]{1,4}:){3}(?::[a-f0-9]{1,4}){1,4}|(?:[a-f0-9]{1,4}:){4}(?::[a-f0-9]{1,4}){1,3}|(?:[a-f0-9]{1,4}:){5}(?::[a-f0-9]{1,4}){1,2}|(?:[a-f0-9]{1,4}:){6}(?::[a-f0-9]{1,4})|(?:0:){5}ffff:(?:\d{1,3}\.){3}\d{1,3}|(?:0:){6}(?:\d{1,3}\.){3}\d{1,3}|::(?:ffff:)?(?:\d{1,3}\.){3}\d{1,3}',
    46. 

  46. 		'hostname' => '(?:[a-z0-9][-a-z0-9]*\.)*(?:[a-z0-9][-a-z0-9]{0,62})\.(?:(?:[a-z]{2}\.)?[a-z]{2,4}|museum|travel)'
    47. 

  47. 	);
    48. 

  48. 

  49. /**
    50. 

  50.  * Holds an array of errors messages set in this class.
    51. 

  51.  * These are used for debugging purposes
    52. 

  52.  *
    53. 

  53.  * @var array
    54. 

  54.  * @access public
    55. 

  55.  */
    56. 

  56. 	private static $errors = array();
    57. 

  57. 

  58. /**
    59. 

  59.  * Checks that a string contains something other than whitespace
    60. 

  60.  *
    61. 

  61.  * Returns true if string contains something other than whitespace
    62. 

  62.  *
    63. 

  63.  * $check can be passed as an array:
    64. 

  64.  * array('check' => 'valueToCheck');
    65. 

  65.  *
    66. 

  66.  * @param mixed $check Value to check
    67. 

  67.  * @return boolean Success
    68. 

  68.  * @access public
    69. 

  69.  */
    70. 

  70. 	public static function notEmpty($check) {
    71. 

  71. 		if (is_array($check)) {
    72. 

  72. 			extract(self::_defaults($check));
    73. 

  73. 		}
    74. 

  74. 

  75. 		if (empty($check) && $check != '0') {
    76. 

  76. 			return false;
    77. 

  77. 		}
    78. 

  78. 		return self::_check($check, '/[^\s]+/m');
    79. 

  79. 	}
    80. 

  80. 

  81. /**
    82. 

  82.  * Checks that a string contains only integer or letters
    83. 

  83.  *
    84. 

  84.  * Returns true if string contains only integer or letters
    85. 

  85.  *
    86. 

  86.  * $check can be passed as an array:
    87. 

  87.  * array('check' => 'valueToCheck');
    88. 

  88.  *
    89. 

  89.  * @param mixed $check Value to check
    90. 

  90.  * @return boolean Success
    91. 

  91.  * @access public
    92. 

  92.  */
    93. 

  93. 	public static function alphaNumeric($check) {
    94. 

  94. 		if (is_array($check)) {
    95. 

  95. 			extract(self::_defaults($check));
    96. 

  96. 		}
    97. 

  97. 

  98. 		if (empty($check) && $check != '0') {
    99. 

  99. 			return false;
    100. 

  100. 		}
    101. 

  101. 		return self::_check($check, '/^[\p{Ll}\p{Lm}\p{Lo}\p{Lt}\p{Lu}\p{Nd}]+$/mu');
    102. 

  102. 	}
    103. 

  103. 

  104. /**
    105. 

  105.  * Checks that a string length is within s specified range.
    106. 

  106.  * Spaces are included in the character count.
    107. 

  107.  * Returns true is string matches value min, max, or between min and max,
    108. 

  108.  *
    109. 

  109.  * @param string $check Value to check for length
    110. 

  110.  * @param integer $min Minimum value in range (inclusive)
    111. 

  111.  * @param integer $max Maximum value in range (inclusive)
    112. 

  112.  * @return boolean Success
    113. 

  113.  * @access public
    114. 

  114.  */
    115. 

  115. 	public static function between($check, $min, $max) {
    116. 

  116. 		$length = mb_strlen($check);
    117. 

  117. 		return ($length >= $min && $length <= $max);
    118. 

  118. 	}
    119. 

  119. 

  120. /**
    121. 

  121.  * Returns true if field is left blank -OR- only whitespace characters are present in it's value
    122. 

  122.  * Whitespace characters include Space, Tab, Carriage Return, Newline
    123. 

  123.  *
    124. 

  124.  * $check can be passed as an array:
    125. 

  125.  * array('check' => 'valueToCheck');
    126. 

  126.  *
    127. 

  127.  * @param mixed $check Value to check
    128. 

  128.  * @return boolean Success
    129. 

  129.  * @access public
    130. 

  130.  */
    131. 

  131. 	public static function blank($check) {
    132. 

  132. 		if (is_array($check)) {
    133. 

  133. 			extract(self::_defaults($check));
    134. 

  134. 		}
    135. 

  135. 		return !self::_check($check, '/[^\\s]/');
    136. 

  136. 	}
    137. 

  137. 

  138. /**
    139. 

  139.  * Validation of credit card numbers.
    140. 

  140.  * Returns true if $check is in the proper credit card format.
    141. 

  141.  *
    142. 

  142.  * @param mixed $check credit card number to validate
    143. 

  143.  * @param mixed $type 'all' may be passed as a sting, defaults to fast which checks format of most major credit cards
    144. 

  144.  *    if an array is used only the values of the array are checked.
    145. 

  145.  *    Example: array('amex', 'bankcard', 'maestro')
    146. 

  146.  * @param boolean $deep set to true this will check the Luhn algorithm of the credit card.
    147. 

  147.  * @param string $regex A custom regex can also be passed, this will be used instead of the defined regex values
    148. 

  148.  * @return boolean Success
    149. 

  149.  * @access public
    150. 

  150.  * @see Validation::_luhn()
    151. 

  151.  */
    152. 

  152. 	public static function cc($check, $type = 'fast', $deep = false, $regex = null) {
    153. 

  153. 		if (is_array($check)) {
    154. 

  154. 			extract(self::_defaults($check));
    155. 

  155. 		}
    156. 

  156. 

  157. 		$check = str_replace(array('-', ' '), '', $check);
    158. 

  158. 		if (mb_strlen($check) < 13) {
    159. 

  159. 			return false;
    160. 

  160. 		}
    161. 

  161. 

  162. 		if (!is_null($regex)) {
    163. 

  163. 			if (self::_check($check, $regex)) {
    164. 

  164. 				return self::luhn($check, $deep);
    165. 

  165. 			}
    166. 

  166. 		}
    167. 

  167. 		$cards = array(
    168. 

  168. 			'all' => array(
    169. 

  169. 				'amex' => '/^3[4|7]\\d{13}$/',
    170. 

  170. 				'bankcard' => '/^56(10\\d\\d|022[1-5])\\d{10}$/',
    171. 

  171. 				'diners'   => '/^(?:3(0[0-5]|[68]\\d)\\d{11})|(?:5[1-5]\\d{14})$/',
    172. 

  172. 				'disc'     => '/^(?:6011|650\\d)\\d{12}$/',
    173. 

  173. 				'electron' => '/^(?:417500|4917\\d{2}|4913\\d{2})\\d{10}$/',
    174. 

  174. 				'enroute'  => '/^2(?:014|149)\\d{11}$/',
    175. 

  175. 				'jcb'      => '/^(3\\d{4}|2100|1800)\\d{11}$/',
    176. 

  176. 				'maestro'  => '/^(?:5020|6\\d{3})\\d{12}$/',
    177. 

  177. 				'mc'       => '/^5[1-5]\\d{14}$/',
    178. 

  178. 				'solo'     => '/^(6334[5-9][0-9]|6767[0-9]{2})\\d{10}(\\d{2,3})?$/',
    179. 

  179. 				'switch'   => '/^(?:49(03(0[2-9]|3[5-9])|11(0[1-2]|7[4-9]|8[1-2])|36[0-9]{2})\\d{10}(\\d{2,3})?)|(?:564182\\d{10}(\\d{2,3})?)|(6(3(33[0-4][0-9])|759[0-9]{2})\\d{10}(\\d{2,3})?)$/',
    180. 

  180. 				'visa'     => '/^4\\d{12}(\\d{3})?$/',
    181. 

  181. 				'voyager'  => '/^8699[0-9]{11}$/'),
    182. 

  182. 			'fast'   => '/^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6011[0-9]{12}|3(?:0[0-5]|[68][0-9])[0-9]{11}|3[47][0-9]{13})$/');
    183. 

  183. 

  184. 		if (is_array($type)) {
    185. 

  185. 			foreach ($type as $value) {
    186. 

  186. 				$regex = $cards['all'][strtolower($value)];
    187. 

  187. 

  188. 				if (self::_check($check, $regex)) {
    189. 

  189. 					return self::luhn($check, $deep);
    190. 

  190. 				}
    191. 

  191. 			}
    192. 

  192. 		} elseif ($type == 'all') {
    193. 

  193. 			foreach ($cards['all'] as $value) {
    194. 

  194. 				$regex = $value;
    195. 

  195. 

  196. 				if (self::_check($check, $regex)) {
    197. 

  197. 					return self::luhn($check, $deep);
    198. 

  198. 				}
    199. 

  199. 			}
    200. 

  200. 		} else {
    201. 

  201. 			$regex = $cards['fast'];
    202. 

  202. 

  203. 			if (self::_check($check, $regex)) {
    204. 

  204. 				return self::luhn($check, $deep);
    205. 

  205. 			}
    206. 

  206. 		}
    207. 

  207. 	}
    208. 

  208. 

  209. /**
    210. 

  210.  * Used to compare 2 numeric values.
    211. 

  211.  *
    212. 

  212.  * @param mixed $check1 if string is passed for a string must also be passed for $check2
    213. 

  213.  *    used as an array it must be passed as array('check1' => value, 'operator' => 'value', 'check2' -> value)
    214. 

  214.  * @param string $operator Can be either a word or operand
    215. 

  215.  *    is greater >, is less <, greater or equal >=
    216. 

  216.  *    less or equal <=, is less <, equal to ==, not equal !=
    217. 

  217.  * @param integer $check2 only needed if $check1 is a string
    218. 

  218.  * @return boolean Success
    219. 

  219.  * @access public
    220. 

  220.  */
    221. 

  221. 	public static function comparison($check1, $operator = null, $check2 = null) {
    222. 

  222. 		if (is_array($check1)) {
    223. 

  223. 			extract($check1, EXTR_OVERWRITE);
    224. 

  224. 		}
    225. 

  225. 		$operator = str_replace(array(' ', "\t", "\n", "\r", "\0", "\x0B"), '', strtolower($operator));
    226. 

  226. 

  227. 		switch ($operator) {
    228. 

  228. 			case 'isgreater':
    229. 

  229. 			case '>':
    230. 

  230. 				if ($check1 > $check2) {
    231. 

  231. 					return true;
    232. 

  232. 				}
    233. 

  233. 				break;
    234. 

  234. 			case 'isless':
    235. 

  235. 			case '<':
    236. 

  236. 				if ($check1 < $check2) {
    237. 

  237. 					return true;
    238. 

  238. 				}
    239. 

  239. 				break;
    240. 

  240. 			case 'greaterorequal':
    241. 

  241. 			case '>=':
    242. 

  242. 				if ($check1 >= $check2) {
    243. 

  243. 					return true;
    244. 

  244. 				}
    245. 

  245. 				break;
    246. 

  246. 			case 'lessorequal':
    247. 

  247. 			case '<=':
    248. 

  248. 				if ($check1 <= $check2) {
    249. 

  249. 					return true;
    250. 

  250. 				}
    251. 

  251. 				break;
    252. 

  252. 			case 'equalto':
    253. 

  253. 			case '==':
    254. 

  254. 				if ($check1 == $check2) {
    255. 

  255. 					return true;
    256. 

  256. 				}
    257. 

  257. 				break;
    258. 

  258. 			case 'notequal':
    259. 

  259. 			case '!=':
    260. 

  260. 				if ($check1 != $check2) {
    261. 

  261. 					return true;
    262. 

  262. 				}
    263. 

  263. 				break;
    264. 

  264. 			default:
    265. 

  265. 				self::$errors[] = __('You must define the $operator parameter for Validation::comparison()', true);
    266. 

  266. 				break;
    267. 

  267. 		}
    268. 

  268. 		return false;
    269. 

  269. 	}
    270. 

  270. 

  271. /**
    272. 

  272.  * Used when a custom regular expression is needed.
    273. 

  273.  *
    274. 

  274.  * @param mixed $check When used as a string, $regex must also be a valid regular expression.
    275. 

  275.  *								As and array: array('check' => value, 'regex' => 'valid regular expression')
    276. 

  276.  * @param string $regex If $check is passed as a string, $regex must also be set to valid regular expression
    277. 

  277.  * @return boolean Success
    278. 

  278.  * @access public
    279. 

  279.  */
    280. 

  280. 	public static function custom($check, $regex = null) {
    281. 

  281. 		if (is_array($check)) {
    282. 

  282. 			extract(self::_defaults($check));
    283. 

  283. 		}
    284. 

  284. 		if ($regex === null) {
    285. 

  285. 			self::$errors[] = __('You must define a regular expression for Validation::custom()', true);
    286. 

  286. 			return false;
    287. 

  287. 		}
    288. 

  288. 		return self::_check($check, $regex);
    289. 

  289. 	}
    290. 

  290. 

  291. /**
    292. 

  292.  * Date validation, determines if the string passed is a valid date.
    293. 

  293.  * keys that expect full month, day and year will validate leap years
    294. 

  294.  *
    295. 

  295.  * @param string $check a valid date string
    296. 

  296.  * @param mixed $format Use a string or an array of the keys below. Arrays should be passed as array('dmy', 'mdy', etc)
    297. 

  297.  * 	      Keys: dmy 27-12-2006 or 27-12-06 separators can be a space, period, dash, forward slash
    298. 

  298.  * 	            mdy 12-27-2006 or 12-27-06 separators can be a space, period, dash, forward slash
    299. 

  299.  * 	            ymd 2006-12-27 or 06-12-27 separators can be a space, period, dash, forward slash
    300. 

  300.  * 	            dMy 27 December 2006 or 27 Dec 2006
    301. 

  301.  * 	            Mdy December 27, 2006 or Dec 27, 2006 comma is optional
    302. 

  302.  * 	            My December 2006 or Dec 2006
    303. 

  303.  * 	            my 12/2006 separators can be a space, period, dash, forward slash
    304. 

  304.  * @param string $regex If a custom regular expression is used this is the only validation that will occur.
    305. 

  305.  * @return boolean Success
    306. 

  306.  * @access public
    307. 

  307.  */
    308. 

  308. 	public static function date($check, $format = 'ymd', $regex = null) {
    309. 

  309. 		if (!is_null($regex)) {
    310. 

  310. 			return self::_check($check, $regex);
    311. 

  311. 		}
    312. 

  312. 

  313. 		$regex = array();
    314. 

  314. 		$regex['dmy'] = '%^(?:(?:31(\\/|-|\\.|\\x20)(?:0?[13578]|1[02]))\\1|(?:(?:29|30)(\\/|-|\\.|\\x20)(?:0?[1,3-9]|1[0-2])\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:29(\\/|-|\\.|\\x20)0?2\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\\d|2[0-8])(\\/|-|\\.|\\x20)(?:(?:0?[1-9])|(?:1[0-2]))\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$%';
    315. 

  315. 		$regex['mdy'] = '%^(?:(?:(?:0?[13578]|1[02])(\\/|-|\\.|\\x20)31)\\1|(?:(?:0?[13-9]|1[0-2])(\\/|-|\\.|\\x20)(?:29|30)\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:0?2(\\/|-|\\.|\\x20)29\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:(?:0?[1-9])|(?:1[0-2]))(\\/|-|\\.|\\x20)(?:0?[1-9]|1\\d|2[0-8])\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$%';
    316. 

  316. 		$regex['ymd'] = '%^(?:(?:(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\\/|-|\\.|\\x20)(?:0?2\\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\\d)?\\d{2})(\\/|-|\\.|\\x20)(?:(?:(?:0?[13578]|1[02])\\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\\2(?:0?[1-9]|1\\d|2[0-8]))))$%';
    317. 

  317. 		$regex['dMy'] = '/^((31(?!\\ (Feb(ruary)?|Apr(il)?|June?|(Sep(?=\\b|t)t?|Nov)(ember)?)))|((30|29)(?!\\ Feb(ruary)?))|(29(?=\\ Feb(ruary)?\\ (((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)))))|(0?[1-9])|1\\d|2[0-8])\\ (Jan(uary)?|Feb(ruary)?|Ma(r(ch)?|y)|Apr(il)?|Ju((ly?)|(ne?))|Aug(ust)?|Oct(ober)?|(Sep(?=\\b|t)t?|Nov|Dec)(ember)?)\\ ((1[6-9]|[2-9]\\d)\\d{2})$/';
    318. 

  318. 		$regex['Mdy'] = '/^(?:(((Jan(uary)?|Ma(r(ch)?|y)|Jul(y)?|Aug(ust)?|Oct(ober)?|Dec(ember)?)\\ 31)|((Jan(uary)?|Ma(r(ch)?|y)|Apr(il)?|Ju((ly?)|(ne?))|Aug(ust)?|Oct(ober)?|(Sept|Nov|Dec)(ember)?)\\ (0?[1-9]|([12]\\d)|30))|(Feb(ruary)?\\ (0?[1-9]|1\\d|2[0-8]|(29(?=,?\\ ((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)))))))\\,?\\ ((1[6-9]|[2-9]\\d)\\d{2}))$/';
    319. 

  319. 		$regex['My'] = '%^(Jan(uary)?|Feb(ruary)?|Ma(r(ch)?|y)|Apr(il)?|Ju((ly?)|(ne?))|Aug(ust)?|Oct(ober)?|(Sep(?=\\b|t)t?|Nov|Dec)(ember)?)[ /]((1[6-9]|[2-9]\\d)\\d{2})$%';
    320. 

  320. 		$regex['my'] = '%^(((0[123456789]|10|11|12)([- /.])(([1][9][0-9][0-9])|([2][0-9][0-9][0-9]))))$%';
    321. 

  321. 

  322. 		$format = (is_array($format)) ? array_values($format) : array($format);
    323. 

  323. 		foreach ($format as $key) {
    324. 

  324. 			$regex = $regex[$key];
    325. 

  325. 

  326. 			if (self::_check($check, $regex) === true) {
    327. 

  327. 				return true;
    328. 

  328. 			}
    329. 

  329. 		}
    330. 

  330. 		return false;
    331. 

  331. 	}
    332. 

  332. 

  333. /**
    334. 

  334.  * Time validation, determines if the string passed is a valid time.
    335. 

  335.  * Validates time as 24hr (HH:MM) or am/pm ([H]H:MM[a|p]m)
    336. 

  336.  * Does not allow/validate seconds.
    337. 

  337.  *
    338. 

  338.  * @param string $check a valid time string
    339. 

  339.  * @return boolean Success
    340. 

  340.  * @access public
    341. 

  341.  */
    342. 

  342. 	public static function time($check) {
    343. 

  343. 		return self::_check($check, '%^((0?[1-9]|1[012])(:[0-5]\d){0,2}([AP]M|[ap]m))$|^([01]\d|2[0-3])(:[0-5]\d){0,2}$%');
    344. 

  344. 	}
    345. 

  345. 

  346. /**
    347. 

  347.  * Boolean validation, determines if value passed is a boolean integer or true/false.
    348. 

  348.  *
    349. 

  349.  * @param string $check a valid boolean
    350. 

  350.  * @return boolean Success
    351. 

  351.  * @access public
    352. 

  352.  */
    353. 

  353. 	public static function boolean($check) {
    354. 

  354. 		$booleanList = array(0, 1, '0', '1', true, false);
    355. 

  355. 		return in_array($check, $booleanList, true);
    356. 

  356. 	}
    357. 

  357. 

  358. /**
    359. 

  359.  * Checks that a value is a valid decimal. If $places is null, the $check is allowed to be a scientific float
    360. 

  360.  * If no decimal point is found a false will be returned. Both the sign and exponent are optional.
    361. 

  361.  *
    362. 

  362.  * @param integer $check The value the test for decimal
    363. 

  363.  * @param integer $places if set $check value must have exactly $places after the decimal point
    364. 

  364.  * @param string $regex If a custom regular expression is used this is the only validation that will occur.
    365. 

  365.  * @return boolean Success
    366. 

  366.  * @access public
    367. 

  367.  */
    368. 

  368. 	public static function decimal($check, $places = null, $regex = null) {
    369. 

  369. 		if (is_null($regex)) {
    370. 

  370. 			if (is_null($places)) {
    371. 

  371. 				$regex = '/^[-+]?[0-9]*\\.{1}[0-9]+(?:[eE][-+]?[0-9]+)?$/';
    372. 

  372. 			} else {
    373. 

  373. 				$regex = '/^[-+]?[0-9]*\\.{1}[0-9]{'.$places.'}$/';
    374. 

  374. 			}
    375. 

  375. 		}
    376. 

  376. 		return self::_check($check, $regex);
    377. 

  377. 	}
    378. 

  378. 

  379. /**
    380. 

  380.  * Validates for an email address.
    381. 

  381.  *
    382. 

  382.  * Only uses getmxrr() checking for deep validation if PHP 5.3.0+ is used, or
    383. 

  383.  * any PHP version on a non-windows distribution
    384. 

  384.  *
    385. 

  385.  * @param string $check Value to check
    386. 

  386.  * @param boolean $deep Perform a deeper validation (if true), by also checking availability of host
    387. 

  387.  * @param string $regex Regex to use (if none it will use built in regex)
    388. 

  388.  * @return boolean Success
    389. 

  389.  * @access public
    390. 

  390.  */
    391. 

  391. 	public static function email($check, $deep = false, $regex = null) {
    392. 

  392. 		if (is_array($check)) {
    393. 

  393. 			extract(self::_defaults($check));
    394. 

  394. 		}
    395. 

  395. 

  396. 		if (is_null($regex)) {
    397. 

  397. 			$regex = '/^[a-z0-9!#$%&\'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&\'*+\/=?^_`{|}~-]+)*@' . self::$__pattern['hostname'] . '$/i';
    398. 

  398. 		}
    399. 

  399. 		$return = self::_check($check, $regex);
    400. 

  400. 		if ($deep === false || $deep === null) {
    401. 

  401. 			return $return;
    402. 

  402. 		}
    403. 

  403. 

  404. 		if ($return === true && preg_match('/@(' . self::$__pattern['hostname'] . ')$/i', $check, $regs)) {
    405. 

  405. 			$host = gethostbynamel($regs[1]);
    406. 

  406. 			$return = is_array($host);
    407. 

  407. 			$isWindows = (DIRECTORY_SEPARATOR === '\\');
    408. 

  408. 			if (!$isWindows || (version_compare(PHP_VERSION, '5.3.0', '>=') && $isWindows)) {
    409. 

  409. 				$return = $return && getmxrr($regs[1], $mxhosts);
    410. 

  410. 			}
    411. 

  411. 			return $return;
    412. 

  412. 		}
    413. 

  413. 		return false;
    414. 

  414. 	}
    415. 

  415. 

  416. /**
    417. 

  417.  * Check that value is exactly $comparedTo.
    418. 

  418.  *
    419. 

  419.  * @param mixed $check Value to check
    420. 

  420.  * @param mixed $comparedTo Value to compare
    421. 

  421.  * @return boolean Success
    422. 

  422.  * @access public
    423. 

  423.  */
    424. 

  424. 	public static function equalTo($check, $comparedTo) {
    425. 

  425. 		return ($check === $comparedTo);
    426. 

  426. 	}
    427. 

  427. 

  428. /**
    429. 

  429.  * Check that value has a valid file extension.
    430. 

  430.  *
    431. 

  431.  * @param mixed $check Value to check
    432. 

  432.  * @param array $extensions file extenstions to allow
    433. 

  433.  * @return boolean Success
    434. 

  434.  * @access public
    435. 

  435.  */
    436. 

  436. 	public static function extension($check, $extensions = array('gif', 'jpeg', 'png', 'jpg')) {
    437. 

  437. 		if (is_array($check)) {
    438. 

  438. 			return self::extension(array_shift($check), $extensions);
    439. 

  439. 		}
    440. 

  440. 		$extension = strtolower(array_pop(explode('.', $check)));
    441. 

  441. 		foreach ($extensions as $value) {
    442. 

  442. 			if ($extension == strtolower($value)) {
    443. 

  443. 				return true;
    444. 

  444. 			}
    445. 

  445. 		}
    446. 

  446. 		return false;
    447. 

  447. 	}
    448. 

  448. 

  449. /**
    450. 

  450.  * Validation of an IP address.
    451. 

  451.  *
    452. 

  452.  * @param string $check The string to test.
    453. 

  453.  * @param string $ipVersion The IP Protocol version to validate against
    454. 

  454.  * @return boolean Success
    455. 

  455.  * @access public
    456. 

  456.  */
    457. 

  457. 	public static function ip($check, $ipVersion = '4') {
    458. 

  458. 		$regex = '/^' . self::$__pattern['ipv'.$ipVersion] . '$/i';
    459. 

  459. 		return self::_check($check, $regex);
    460. 

  460. 	}
    461. 

  461. 

  462. /**
    463. 

  463.  * Checks whether the length of a string is greater or equal to a minimal length.
    464. 

  464.  *
    465. 

  465.  * @param string $check The string to test
    466. 

  466.  * @param integer $min The minimal string length
    467. 

  467.  * @return boolean Success
    468. 

  468.  * @access public
    469. 

  469.  */
    470. 

  470. 	public static function minLength($check, $min) {
    471. 

  471. 		return mb_strlen($check) >= $min;
    472. 

  472. 	}
    473. 

  473. 

  474. /**
    475. 

  475.  * Checks whether the length of a string is smaller or equal to a maximal length..
    476. 

  476.  *
    477. 

  477.  * @param string $check The string to test
    478. 

  478.  * @param integer $max The maximal string length
    479. 

  479.  * @return boolean Success
    480. 

  480.  * @access public
    481. 

  481.  */
    482. 

  482. 	public static function maxLength($check, $max) {
    483. 

  483. 		return mb_strlen($check) <= $max;
    484. 

  484. 	}
    485. 

  485. 

  486. /**
    487. 

  487.  * Checks that a value is a monetary amount.
    488. 

  488.  *
    489. 

  489.  * @param string $check Value to check
    490. 

  490.  * @param string $symbolPosition Where symbol is located (left/right)
    491. 

  491.  * @return boolean Success
    492. 

  492.  * @access public
    493. 

  493.  */
    494. 

  494. 	public static function money($check, $symbolPosition = 'left') {
    495. 

  495. 		if ($symbolPosition == 'right') {
    496. 

  496. 			$regex = '/^(?!0,?\d)(?:\d{1,3}(?:([, .])\d{3})?(?:\1\d{3})*|(?:\d+))((?!\1)[,.]\d{2})?(?<!\x{00a2})\p{Sc}?$/u';
    497. 

  497. 		} else {
    498. 

  498. 			$regex = '/^(?!\x{00a2})\p{Sc}?(?!0,?\d)(?:\d{1,3}(?:([, .])\d{3})?(?:\1\d{3})*|(?:\d+))((?!\1)[,.]\d{2})?$/u';
    499. 

  499. 		}
    500. 

  500. 		return self::_check($check, $regex);
    501. 

  501. 	}
    502. 

  502. 

  503. /**
    504. 

  504.  * Validate a multiple select.
    505. 

  505.  *
    506. 

  506.  * Valid Options 
    507. 

  507.  * 
    508. 

  508.  * - in => provide a list of choices that selections must be made from
    509. 

  509.  * - max => maximun number of non-zero choices that can be made
    510. 

  510.  * - min => minimum number of non-zero choices that can be made
    511. 

  511.  *
    512. 

  512.  * @param mixed $check Value to check
    513. 

  513.  * @param mixed $options Options for the check.
    514. 

  514.  * @return boolean Success
    515. 

  515.  * @access public
    516. 

  516.  */
    517. 

  517. 	public static function multiple($check, $options = array()) {
    518. 

  518. 		$defaults = array('in' => null, 'max' => null, 'min' => null);
    519. 

  519. 		$options = array_merge($defaults, $options);
    520. 

  520. 		$check = array_filter((array)$check);
    521. 

  521. 		if (empty($check)) {
    522. 

  522. 			return false;
    523. 

  523. 		}
    524. 

  524. 		if ($options['max'] && count($check) > $options['max']) {
    525. 

  525. 			return false;
    526. 

  526. 		}
    527. 

  527. 		if ($options['min'] && count($check) < $options['min']) {
    528. 

  528. 			return false;
    529. 

  529. 		}
    530. 

  530. 		if ($options['in'] && is_array($options['in'])) {
    531. 

  531. 			foreach ($check as $val) {
    532. 

  532. 				if (!in_array($val, $options['in'])) {
    533. 

  533. 					return false;
    534. 

  534. 				}
    535. 

  535. 			}
    536. 

  536. 		}
    537. 

  537. 		return true;
    538. 

  538. 	}
    539. 

  539. 

  540. /**
    541. 

  541.  * Checks if a value is numeric.
    542. 

  542.  *
    543. 

  543.  * @param string $check Value to check
    544. 

  544.  * @return boolean Succcess
    545. 

  545.  * @access public
    546. 

  546.  */
    547. 

  547. 	public static function numeric($check) {
    548. 

  548. 		return is_numeric($check);
    549. 

  549. 	}
    550. 

  550. 

  551. /**
    552. 

  552.  * Check that a value is a valid phone number.
    553. 

  553.  *
    554. 

  554.  * @param mixed $check Value to check (string or array)
    555. 

  555.  * @param string $regex Regular expression to use
    556. 

  556.  * @param string $country Country code (defaults to 'all')
    557. 

  557.  * @return boolean Success
    558. 

  558.  * @access public
    559. 

  559.  */
    560. 

  560. 	public static function phone($check, $regex = null, $country = 'all') {
    561. 

  561. 		if (is_array($check)) {
    562. 

  562. 			extract(self::_defaults($check));
    563. 

  563. 		}
    564. 

  564. 

  565. 		if (is_null($regex)) {
    566. 

  566. 			switch ($country) {
    567. 

  567. 				case 'us':
    568. 

  568. 				case 'all':
    569. 

  569. 				case 'can':
    570. 

  570. 				// includes all NANPA members. see http://en.wikipedia.org/wiki/North_American_Numbering_Plan#List_of_NANPA_countries_and_territories
    571. 

  571. 					$regex  = '/^(?:\+?1)?[-. ]?\\(?[2-9][0-8][0-9]\\)?[-. ]?[2-9][0-9]{2}[-. ]?[0-9]{4}$/';
    572. 

  572. 				break;
    573. 

  573. 			}
    574. 

  574. 		}
    575. 

  575. 		if (empty($regex)) {
    576. 

  576. 			return self::_pass('phone', $check, $country);
    577. 

  577. 		}
    578. 

  578. 		return self::_check($check, $regex);
    579. 

  579. 	}
    580. 

  580. 

  581. /**
    582. 

  582.  * Checks that a given value is a valid postal code.
    583. 

  583.  *
    584. 

  584.  * @param mixed $check Value to check
    585. 

  585.  * @param string $regex Regular expression to use
    586. 

  586.  * @param string $country Country to use for formatting
    587. 

  587.  * @return boolean Success
    588. 

  588.  * @access public
    589. 

  589.  */
    590. 

  590. 	public static function postal($check, $regex = null, $country = 'us') {
    591. 

  591. 		if (is_array($check)) {
    592. 

  592. 			extract(self::_defaults($check));
    593. 

  593. 		}
    594. 

  594. 

  595. 		if (is_null($regex)) {
    596. 

  596. 			switch ($country) {
    597. 

  597. 				case 'uk':
    598. 

  598. 					$regex  = '/\\A\\b[A-Z]{1,2}[0-9][A-Z0-9]? [0-9][ABD-HJLNP-UW-Z]{2}\\b\\z/i';
    599. 

  599. 					break;
    600. 

  600. 				case 'ca':
    601. 

  601. 					$regex  = '/\\A\\b[ABCEGHJKLMNPRSTVXY][0-9][A-Z] [0-9][A-Z][0-9]\\b\\z/i';
    602. 

  602. 					break;
    603. 

  603. 				case 'it':
    604. 

  604. 				case 'de':
    605. 

  605. 					$regex  = '/^[0-9]{5}$/i';
    606. 

  606. 					break;
    607. 

  607. 				case 'be':
    608. 

  608. 					$regex  = '/^[1-9]{1}[0-9]{3}$/i';
    609. 

  609. 					break;
    610. 

  610. 				case 'us':
    611. 

  611. 					$regex  = '/\\A\\b[0-9]{5}(?:-[0-9]{4})?\\b\\z/i';
    612. 

  612. 					break;
    613. 

  613. 			}
    614. 

  614. 		}
    615. 

  615. 		if (empty($regex)) {
    616. 

  616. 			return self::_pass('postal', $check, $country);
    617. 

  617. 		}
    618. 

  618. 		return self::_check($check, $regex);
    619. 

  619. 	}
    620. 

  620. 

  621. /**
    622. 

  622.  * Validate that a number is in specified range.
    623. 

  623.  * if $lower and $upper are not set, will return true if
    624. 

  624.  * $check is a legal finite on this platform
    625. 

  625.  *
    626. 

  626.  * @param string $check Value to check
    627. 

  627.  * @param integer $lower Lower limit
    628. 

  628.  * @param integer $upper Upper limit
    629. 

  629.  * @return boolean Success
    630. 

  630.  * @access public
    631. 

  631.  */
    632. 

  632. 	public static function range($check, $lower = null, $upper = null) {
    633. 

  633. 		if (!is_numeric($check)) {
    634. 

  634. 			return false;
    635. 

  635. 		}
    636. 

  636. 		if (isset($lower) && isset($upper)) {
    637. 

  637. 			return ($check > $lower && $check < $upper);
    638. 

  638. 		}
    639. 

  639. 		return is_finite($check);
    640. 

  640. 	}
    641. 

  641. 

  642. /**
    643. 

  643.  * Checks that a value is a valid Social Security Number.
    644. 

  644.  *
    645. 

  645.  * @param mixed $check Value to check
    646. 

  646.  * @param string $regex Regular expression to use
    647. 

  647.  * @param string $country Country
    648. 

  648.  * @return boolean Success
    649. 

  649.  * @access public
    650. 

  650.  */
    651. 

  651. 	public static function ssn($check, $regex = null, $country = null) {
    652. 

  652. 		if (is_array($check)) {
    653. 

  653. 			extract(self::_defaults($check));
    654. 

  654. 		}
    655. 

  655. 

  656. 		if (is_null($regex)) {
    657. 

  657. 			switch ($country) {
    658. 

  658. 				case 'dk':
    659. 

  659. 					$regex  = '/\\A\\b[0-9]{6}-[0-9]{4}\\b\\z/i';
    660. 

  660. 					break;
    661. 

  661. 				case 'nl':
    662. 

  662. 					$regex  = '/\\A\\b[0-9]{9}\\b\\z/i';
    663. 

  663. 					break;
    664. 

  664. 				case 'us':
    665. 

  665. 					$regex  = '/\\A\\b[0-9]{3}-[0-9]{2}-[0-9]{4}\\b\\z/i';
    666. 

  666. 					break;
    667. 

  667. 			}
    668. 

  668. 		}
    669. 

  669. 		if (empty($regex)) {
    670. 

  670. 			return self::_pass('ssn', $check, $country);
    671. 

  671. 		}
    672. 

  672. 		return self::_check($check, $regex);
    673. 

  673. 	}
    674. 

  674. 

  675. /**
    676. 

  676.  * Checks that a value is a valid URL according to http://www.w3.org/Addressing/URL/url-spec.txt
    677. 

  677.  *
    678. 

  678.  * The regex checks for the following component parts:
    679. 

  679.  *
    680. 

  680.  * - a valid, optional, scheme
    681. 

  681.  * - a valid ip address OR 
    682. 

  682.  *   a valid domain name as defined by section 2.3.1 of http://www.ietf.org/rfc/rfc1035.txt
    683. 

  683.  *   with an optional port number
    684. 

  684.  * - an optional valid path
    685. 

  685.  * - an optional query string (get parameters)
    686. 

  686.  * - an optional fragment (anchor tag)
    687. 

  687.  *
    688. 

  688.  * @param string $check Value to check
    689. 

  689.  * @param boolean $strict Require URL to be prefixed by a valid scheme (one of http(s)/ftp(s)/file/news/gopher)
    690. 

  690.  * @param string $ipVersion The IP Protocol version to validate against
    691. 

  691.  * @return boolean Success
    692. 

  692.  * @access public
    693. 

  693.  */
    694. 

  694. 	public static function url($check, $strict = false, $ipVersion = '4') {
    695. 

  695. 		$validChars = '([' . preg_quote('!"$&\'()*+,-.@_:;=~') . '\/0-9a-z]|(%[0-9a-f]{2}))';
    696. 

  696. 		$regex = '/^(?:(?:https?|ftps?|file|news|gopher):\/\/)' . (!empty($strict) ? '' : '?') .
    697. 

  697. 			'(?:' . self::$__pattern['ipv'.$ipVersion] . '|' . self::$__pattern['hostname'] . ')(?::[1-9][0-9]{0,3})?' .
    698. 

  698. 			'(?:\/?|\/' . $validChars . '*)?' .
    699. 

  699. 			'(?:\?' . $validChars . '*)?' .
    700. 

  700. 			'(?:#' . $validChars . '*)?$/i';
    701. 

  701. 		return self::_check($check, $regex);
    702. 

  702. 	}
    703. 

  703. 

  704. /**
    705. 

  705.  * Checks if a value is in a given list.
    706. 

  706.  *
    707. 

  707.  * @param string $check Value to check
    708. 

  708.  * @param array $list List to check against
    709. 

  709.  * @return boolean Succcess
    710. 

  710.  * @access public
    711. 

  711.  */
    712. 

  712. 	public static function inList($check, $list) {
    713. 

  713. 		return in_array($check, $list);
    714. 

  714. 	}
    715. 

  715. 

  716. /**
    717. 

  717.  * Runs an user-defined validation.
    718. 

  718.  *
    719. 

  719.  * @param mixed $check value that will be validated in user-defined methods.
    720. 

  720.  * @param object $object class that holds validation method
    721. 

  721.  * @param string $method class method name for validation to run
    722. 

  722.  * @param array $args arguments to send to method
    723. 

  723.  * @return mixed user-defined class class method returns
    724. 

  724.  * @access public
    725. 

  725.  */
    726. 

  726. 	public static function userDefined($check, $object, $method, $args = null) {
    727. 

  727. 		return call_user_func_array(array($object, $method), array($check, $args));
    728. 

  728. 	}
    729. 

  729. 

  730. /**
    731. 

  731.  * Attempts to pass unhandled Validation locales to a class starting with $classPrefix
    732. 

  732.  * and ending with Validation.  For example $classPrefix = 'nl', the class would be
    733. 

  733.  * `NlValidation`.
    734. 

  734.  *
    735. 

  735.  * @param string $method The method to call on the other class.
    736. 

  736.  * @param mixed $check The value to check or an array of parameters for the method to be called.
    737. 

  737.  * @param string $classPrefix The prefix for the class to do the validation.
    738. 

  738.  * @return mixed Return of Passed method, false on failure
    739. 

  739.  * @access protected
    740. 

  740.  **/
    741. 

  741. 	protected static function _pass($method, $check, $classPrefix) {
    742. 

  742. 		$className = ucwords($classPrefix) . 'Validation';
    743. 

  743. 		if (!class_exists($className)) {
    744. 

  744. 			trigger_error(sprintf(__('Could not find %s class, unable to complete validation.', true), $className), E_USER_WARNING);
    745. 

  745. 			return false;
    746. 

  746. 		}
    747. 

  747. 		if (!method_exists($className, $method)) {
    748. 

  748. 			trigger_error(sprintf(__('Method %s does not exist on %s unable to complete validation.', true), $method, $className), E_USER_WARNING);
    749. 

  749. 			return false;
    750. 

  750. 		}
    751. 

  751. 		$check = (array)$check;
    752. 

  752. 		return call_user_func_array(array($className, $method), $check);
    753. 

  753. 	}
    754. 

  754. 

  755. /**
    756. 

  756.  * Runs a regular expression match.
    757. 

  757.  *
    758. 

  758.  * @param mixed $check Value to check against the $regex expression
    759. 

  759.  * @param string $regex Regular expression
    760. 

  760.  * @return boolean Success of match
    761. 

  761.  * @access protected
    762. 

  762.  */
    763. 

  763. 	protected static function _check($check, $regex) {
    764. 

  764. 		if (preg_match($regex, $check)) {
    765. 

  765. 			self::$errors[] = false;
    766. 

  766. 			return true;
    767. 

  767. 		} else {
    768. 

  768. 			self::$errors[] = true;
    769. 

  769. 			return false;
    770. 

  770. 		}
    771. 

  771. 	}
    772. 

  772. 

  773. /**
    774. 

  774.  * Get the values to use when value sent to validation method is
    775. 

  775.  * an array.
    776. 

  776.  *
    777. 

  777.  * @param array $params Parameters sent to validation method
    778. 

  778.  * @return void
    779. 

  779.  * @access protected
    780. 

  780.  */
    781. 

  781. 	protected static function _defaults($params) {
    782. 

  782. 		self::__reset();
    783. 

  783. 		$defaults = array(
    784. 

  784. 			'check' => null,
    785. 

  785. 			'regex' => null,
    786. 

  786. 			'country' => null,
    787. 

  787. 			'deep' => false,
    788. 

  788. 			'type' => null
    789. 

  789. 		);
    790. 

  790. 		$params = array_merge($defaults, $params);
    791. 

  791. 		if ($params['country'] !== null) {
    792. 

  792. 			$params['country'] = mb_strtolower($params['country']);
    793. 

  793. 		}
    794. 

  794. 		return $params;
    795. 

  795. 	}
    796. 

  796. 

  797. /**
    798. 

  798.  * Luhn algorithm
    799. 

  799.  *
    800. 

  800.  * @see http://en.wikipedia.org/wiki/Luhn_algorithm
    801. 

  801.  * @return boolean Success
    802. 

  802.  * @access public
    803. 

  803.  */
    804. 

  804. 	public static function luhn($check, $deep = false) {
    805. 

  805. 		if (is_array($check)) {
    806. 

  806. 			extract(self::_defaults($check));
    807. 

  807. 		}
    808. 

  808. 		if ($deep !== true) {
    809. 

  809. 			return true;
    810. 

  810. 		}
    811. 

  811. 		if ($check == 0) {
    812. 

  812. 			return false;
    813. 

  813. 		}
    814. 

  814. 		$sum = 0;
    815. 

  815. 		$length = strlen($check);
    816. 

  816. 

  817. 		for ($position = 1 - ($length % 2); $position < $length; $position += 2) {
    818. 

  818. 			$sum += $check[$position];
    819. 

  819. 		}
    820. 

  820. 

  821. 		for ($position = ($length % 2); $position < $length; $position += 2) {
    822. 

  822. 			$number = $check[$position] * 2;
    823. 

  823. 			$sum += ($number < 10) ? $number : $number - 9;
    824. 

  824. 		}
    825. 

  825. 

  826. 		return ($sum % 10 == 0);
    827. 

  827. 	}
    828. 

  828. 

  829. /**
    830. 

  830.  * Reset internal variables for another validation run.
    831. 

  831.  *
    832. 

  832.  * @return void
    833. 

  833.  * @access private
    834. 

  834.  */
    835. 

  835. 	private static function __reset() {
    836. 

  836. 		self::$errors = array();
    837. 

  837. 	}
    838. 

  838. }
    839. 

  839. ?>
    840.