[ PHPXref.com ] [ Generated: Sun Jul 20 19:19:39 2008 ] [ PEAR 1.4.5 ]
[ Index ]     [ Variables ]     [ Functions ]     [ Classes ]     [ Constants ]     [ Statistics ]

title

Body

[close]

/ -> Validate.php (source)

   1  <?php
   2  /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3  // +----------------------------------------------------------------------+
   4  // | PHP Version 4                                                        |
   5  // +----------------------------------------------------------------------+
   6  // | Copyright (c) 1997-2003 The PHP Group                                |
   7  // +----------------------------------------------------------------------+
   8  // | This source file is subject to version 2.02 of the PHP license,      |
   9  // | that is bundled with this package in the file LICENSE, and is        |
  10  // | available at through the world-wide-web at                           |
  11  // | http://www.php.net/license/2_02.txt.                                 |
  12  // | If you did not receive a copy of the PHP license and are unable to   |
  13  // | obtain it through the world-wide-web, please send a note to          |
  14  // | license@php.net so we can mail you a copy immediately.               |
  15  // +----------------------------------------------------------------------+
  16  // | Authors: Tomas V.V.Cox <cox@idecnet.com>                             |
  17  // |          Pierre-Alain Joye <pajoye@phpindex.com>                     |
  18  // +----------------------------------------------------------------------+
  19  //
  20  // $Id: Validate.php,v 1.30 2003/05/15 10:40:55 pajoye Exp $
  21  //
  22  // Methods for common data validations
  23  //
  24  
  25  define('VALIDATE_NUM',          '0-9');
  26  define('VALIDATE_SPACE',        '\s');
  27  define('VALIDATE_ALPHA_LOWER',  'a-z');
  28  define('VALIDATE_ALPHA_UPPER',  'A-Z');
  29  define('VALIDATE_ALPHA',        VALIDATE_ALPHA_LOWER . VALIDATE_ALPHA_UPPER);
  30  define('VALIDATE_EALPHA_LOWER', VALIDATE_ALPHA_LOWER . '');
  31  define('VALIDATE_EALPHA_UPPER', VALIDATE_ALPHA_UPPER . '');
  32  define('VALIDATE_EALPHA',       VALIDATE_EALPHA_LOWER . VALIDATE_EALPHA_UPPER);
  33  define('VALIDATE_PUNCTUATION',  VALIDATE_SPACE . '\.,;\:&"\'\?\!\(\)');
  34  define('VALIDATE_NAME',         VALIDATE_EALPHA . VALIDATE_SPACE . "'");
  35  define('VALIDATE_STREET',       VALIDATE_NAME . "/\\");
  36  
  37  class Validate
  38  {
  39      /**
  40       * Validate a number
  41       *
  42       * @param string    $number     Number to validate
  43       * @param array     $options    array where:
  44       *                              'decimal'   is the decimal char or false when decimal not allowed
  45       *                                          i.e. ',.' to allow both ',' and '.'
  46       *                              'dec_prec'  Number of allowed decimals
  47       *                              'min'       minimun value
  48       *                              'max'       maximum value
  49       */
  50      function number($number, $options)
  51      {
  52          $decimal=$dec_prec=$min=$max= null;
  53          if(is_array($options)){
  54              extract($options);
  55          }
  56  
  57          $dec_prec   = $dec_prec ? "{1,$dec_prec}" : '+';
  58          $dec_regex  = $decimal  ? "[$decimal][0-9]$dec_prec" : '';
  59  
  60          if (!preg_match("|^[-+]?\s*[0-9]+($dec_regex)?\$|", $number)) {
  61              return false;
  62          }
  63          if ($decimal != '.') {
  64              $number = strtr($number, $decimal, '.');
  65          }
  66          $number = (float)str_replace(' ', '', $number);
  67          if ($min !== null && $min > $number) {
  68              return false;
  69          }
  70          if ($max !== null && $max < $number) {
  71              return false;
  72          }
  73          return true;
  74      }
  75  
  76      /**
  77       * Validate a email
  78       *
  79       * @param string    $email          URL to validate
  80       * @param boolean   $domain_check   Check or not if the domain exists
  81       */
  82      function email($email, $check_domain = false)
  83      {
  84          if($check_domain){
  85  
  86          }
  87  
  88          if (ereg('^[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+'.'@'.
  89                   '[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.'.
  90                   '[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$', $email))
  91          {
  92              if ($check_domain && function_exists('checkdnsrr')) {
  93                  list (, $domain)  = explode('@', $email);
  94                  if (checkdnsrr($domain, 'MX') || checkdnsrr($domain, 'A')) {
  95                      return true;
  96                  }
  97                  return false;
  98              }
  99              return true;
 100          }
 101          return false;
 102      }
 103  
 104      /**
 105       * Validate a string using the given format 'format'
 106       *
 107       * @param string    $string     String to validate
 108       * @param array     $options    Options array where:
 109       *                              'format' is the format of the string
 110       *                                  Ex: VALIDATE_NUM . VALIDATE_ALPHA (see constants)
 111       *                              'min_length' minimum length
 112       *                              'max_length' maximum length
 113       */
 114      function string($string, $options)
 115      {
 116          $format = null;
 117          $min_length = $max_length = 0;
 118          if (is_array($options)){
 119              extract($options);
 120          }
 121          if ($format && !preg_match("|^[$format]*\$|s", $string)) {
 122              return false;
 123          }
 124          if ($min_length && strlen($string) < $min_length) {
 125              return false;
 126          }
 127          if ($max_length && strlen($string) > $max_length) {
 128              return false;
 129          }
 130          return true;
 131      }
 132  
 133      /**
 134       * Validate a URL
 135       *
 136       * @param string    $url            URL to validate
 137       * @param boolean   $domain_check   Check or not if the domain exists
 138       */
 139      function url($url, $domain_check = false)
 140      {
 141          $purl = parse_url($url);
 142          if (preg_match('|^http$|i', @$purl['scheme']) && !empty($purl['host'])) {
 143              if ($domain_check && function_exists('checkdnsrr')) {
 144                  if (checkdnsrr($purl['host'], 'A')) {
 145                      return true;
 146                  } else {
 147                      return false;
 148                  }
 149              }
 150              return true;
 151          }
 152          return false;
 153      }
 154  
 155      /**
 156       * Validate a number according to Luhn check algorithm
 157       *
 158       * This function checks given number according Luhn check
 159       * algorithm. It is published on several places, also here:
 160       *
 161       *      http://www.webopedia.com/TERM/L/Luhn_formula.html
 162       *      http://www.merriampark.com/anatomycc.htm
 163       *      http://hysteria.sk/prielom/prielom-12.html#3 (Slovak language)
 164       *      http://www.speech.cs.cmu.edu/~sburke/pub/luhn_lib.html (Perl lib)
 165       *
 166       * @param  string  $number number (only numeric chars will be considered)
 167       * @return bool    true if number is valid, otherwise false
 168       * @author Ondrej Jombik <nepto@pobox.sk>
 169       */
 170      function creditCard($creditCard)
 171      {
 172          $creditCard = preg_replace('/[^0-9]/','',$creditCard);
 173  
 174          if (empty($creditCard) || ($len_number = strlen($creditCard)) <= 0) {
 175              return false;
 176          }
 177          $sum = 0;
 178          for ($k = $len_number % 2; $k < $len_number; $k += 2) {
 179              if ((intval($creditCard{$k}) * 2) > 9) {
 180                  $sum += (intval($creditCard{$k}) * 2) - 9;
 181              } else {
 182                  $sum += intval($creditCard{$k}) * 2;
 183              }
 184          }
 185          for ($k = ($len_number % 2) ^ 1; $k < $len_number; $k += 2) {
 186              $sum += intval($creditCard{$k});
 187          }
 188          return $sum % 10 ? false : true;
 189      }
 190  
 191      /**
 192       * Validate date and times. Note that this method need the Date_Calc class
 193       *
 194       * @param string    $date   Date to validate
 195       * @param array     $options array options where :
 196       *                          'format' The format of the date (%d-%m-%Y)
 197       *                          'min' The date has to be greater
 198       *                                than this array($day, $month, $year)
 199       *                          'max' The date has to be smaller than
 200       *                                this array($day, $month, $year)
 201       *
 202       * @return bool
 203       */
 204      function date($date, $options)
 205      {
 206          $max = $min = false;
 207          $format = '';
 208          if (is_array($options)){
 209              extract($options);
 210          }
 211          $date_len   = strlen($format);
 212          for ($i = 0; $i < strlen($format); $i++) {
 213              $c = $format{$i};
 214              if ($c == '%') {
 215                  $next = $format{$i + 1};
 216                  switch ($next) {
 217                      case 'j':
 218                      case 'd':
 219                          if ($next == 'j') {
 220                              $day = (int)Validate::_substr($date, 1, 2);
 221                          } else {
 222                              $day = (int)Validate::_substr($date, 2);
 223                          }
 224                          if ($day < 1 || $day > 31) {
 225                              return false;
 226                          }
 227                          break;
 228                      case 'm':
 229                      case 'n':
 230                          if ($next == 'm') {
 231                              $month = (int)Validate::_substr($date, 2);
 232                          } else {
 233                              $month = (int)Validate::_substr($date, 1, 2);
 234                          }
 235                          if ($month < 1 || $month > 12) {
 236                              return false;
 237                          }
 238                          break;
 239                      case 'Y':
 240                      case 'y':
 241                          if ($next == 'Y') {
 242                              $year = Validate::_substr($date, 4);
 243                              $year = (int)$year?$year:'';
 244                          } else {
 245                              $year = (int)(substr(date('Y'), 0, 2) .
 246                                            Validate::_substr($date, 2));
 247                          }
 248                          if (strlen($year) != 4 || $year < 0 || $year > 9999) {
 249                              return false;
 250                          }
 251                          break;
 252                      case 'g':
 253                      case 'h':
 254                          if ($next == 'g') {
 255                              $hour = Validate::_substr($date, 1, 2);
 256                          } else {
 257                              $hour = Validate::_substr($date, 2);
 258                          }
 259                          if ($hour < 0 || $hour > 12) {
 260                              return false;
 261                          }
 262                          break;
 263                      case 'G':
 264                      case 'H':
 265                          if ($next == 'G') {
 266                              $hour = Validate::_substr($date, 1, 2);
 267                          } else {
 268                              $hour = Validate::_substr($date, 2);
 269                          }
 270                          if ($hour < 0 || $hour > 24) {
 271                              return false;
 272                          }
 273                          break;
 274                      case 's':
 275                      case 'i':
 276                          $t = Validate::_substr($date, 2);
 277                          if ($t < 0 || $t > 59) {
 278                              return false;
 279                          }
 280                          break;
 281                      default:
 282                          trigger_error("Not supported char `$next' after % in offset " . ($i+2), E_USER_WARNING);
 283                  }
 284                  $i++;
 285              } else {
 286                  //literal
 287                  if (Validate::_substr($date, 1) != $c) {
 288                      return false;
 289                  }
 290              }
 291          }
 292          // there is remaing data, we don't want it
 293          if (strlen($date)) {
 294              return false;
 295          }
 296          if (isset($day) && isset($month) && isset($year)) {
 297              if (!checkdate($month, $day, $year)) {
 298                  return false;
 299              }
 300              if ($min || $max) {
 301                  include_once  'Date/Calc.php';
 302                  if ($min &&
 303                      (Date_Calc::compareDates($day, $month, $year,
 304                                               $min[0], $min[1], $min[2]) < 0))
 305                  {
 306                      return false;
 307                  }
 308                  if ($max &&
 309                      (Date_Calc::compareDates($day, $month, $year,
 310                                               $max[0], $max[1], $max[2]) > 0))
 311                  {
 312                      return false;
 313                  }
 314              }
 315          }
 316          return true;
 317      }
 318  
 319      /**
 320       * Validate a ISBN number
 321       *
 322       * This function checks given number according
 323       *
 324       * @param  string  $isbn number (only numeric chars will be considered)
 325       * @return bool    true if number is valid, otherwise false
 326       * @author Damien Seguy <dams@nexen.net>
 327       */
 328      function isbn($isbn)
 329      {
 330          if (preg_match("/[^0-9 IXSBN-]/", $isbn)) {
 331              return false;
 332          }
 333  
 334          if (!ereg("^ISBN", $isbn)){
 335              return false;
 336          }
 337  
 338          $isbn = ereg_replace("-", "", $isbn);
 339          $isbn = ereg_replace(" ", "", $isbn);
 340          $isbn = eregi_replace("ISBN", "", $isbn);
 341          if (strlen($isbn) != 10) {
 342              return false;
 343          }
 344          if (preg_match("/[^0-9]{9}[^0-9X]/", $isbn)){
 345              return false;
 346          }
 347  
 348          $t = 0;
 349          for($i=0; $i< strlen($isbn)-1; $i++){
 350              $t += $isbn[$i]*(10-$i);
 351          }
 352          $f = $isbn[9];
 353          if ($f == "X") {
 354              $t += 10;
 355          } else {
 356              $t += $f;
 357          }
 358          if ($t % 11) {
 359              return false;
 360          } else {
 361              return true;
 362          }
 363      }
 364  
 365      function _substr(&$date, $num, $opt = false)
 366      {
 367          if ($opt && strlen($date) >= $opt && preg_match('/^[0-9]{'.$opt.'}/', $date, $m)) {
 368              $ret = $m[0];
 369          } else {
 370              $ret = substr($date, 0, $num);
 371          }
 372          $date = substr($date, strlen($ret));
 373          return $ret;
 374      }
 375  
 376      function _modf($val, $div) {
 377          if( function_exists('bcmod') ){
 378              return bcmod($val,$div);
 379          } else if (function_exists('fmod')) {
 380              return fmod($val,$div);
 381          }
 382          $r = $a / $b;
 383          $i = intval($r);
 384          return intval(($r - $i) * $b);
 385      }
 386  
 387      /**
 388      * Bulk data validation for data introduced in the form of an
 389      * assoc array in the form $var_name => $value.
 390      *
 391      * @param  array   $data     Ex: array('name'=>'toto','email'='toto@thing.info');
 392      * @param  array   $val_type Contains the validation type and all parameters used in.
 393      *                           'val_type' is not optional
 394      *                           others validations properties must have the same name as the function
 395      *                           parameters.
 396      *                           Ex: array('toto'=>array('type'=>'string','format'='toto@thing.info','min_length'=>5));
 397      * @param  boolean $remove if set, the elements not listed in data will be removed
 398      *
 399      * @return array   value name => true|false    the value name comes from the data key
 400      */
 401      function multiple(&$data, &$val_type, $remove = false)
 402      {
 403          $keys = array_keys($data);
 404          foreach ($keys as $var_name) {
 405              if (!isset($val_type[$var_name])) {
 406                  if ($remove) {
 407                      unset($data[$var_name]);
 408                  }
 409                  continue;
 410              }
 411              $opt = $val_type[$var_name];
 412              $methods = get_class_methods('Validate');
 413              $val2check = $data[$var_name];
 414              // core validation method
 415              if (in_array(strtolower($opt['type']), $methods)) {
 416                  //$opt[$opt['type']] = $data[$var_name];
 417                  $method = $opt['type'];
 418                  $opt = array_slice($opt,1);
 419  
 420                  if (sizeof($opt) == 1){
 421                      $opt = array_pop($opt);
 422                  }
 423                  $valid[$var_name] = call_user_func(array('Validate', $method), $val2check,$opt);
 424  
 425              /**
 426               * external validation method in the form:
 427               * "<class name><underscore><method name>"
 428               * Ex: us_ssn will include class Validate/US.php and call method ssn()
 429               */
 430              } elseif (strpos($opt['type'],'_') !== false) {
 431                  list($class, $method) = explode('_', $opt['type'], 2);
 432                  $class = strtoupper($class);
 433                  @include_once("Validate/$class.php");
 434                  if (!class_exists("Validate_$class") ||
 435                      !in_array($method, get_class_methods("Validate_$class"))) {
 436                      trigger_error("Invalid validation type Validate_$class::$method", E_USER_WARNING);
 437                      continue;
 438                  }
 439                  $valid[$var_name] = call_user_func(array("Validate_$class", $method), $data[$var_name]);
 440              } else {
 441                  trigger_error("Invalid validation type {$opt['type']}", E_USER_WARNING);
 442              }
 443          }
 444          return $valid;
 445      }
 446  }
 447  ?>


[ Powered by PHPXref - Served by Debian GNU/Linux ]