libraries/Form_validation.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 4.3.2 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.0
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * Form Validation Class
  20  *
  21  * @package             CodeIgniter
  22  * @subpackage  Libraries
  23  * @category    Validation
  24  * @author              ExpressionEngine Dev Team
  25  * @link                http://codeigniter.com/user_guide/libraries/form_validation.html
  26  */
  27 class CI_Form_validation {
  28
  29         var $CI;
  30         var $_field_data                        = array();
  31         var $_config_rules                      = array();
  32         var $_error_array                       = array();
  33         var $_error_messages            = array();
  34         var $_error_prefix                      = '<p>';
  35         var $_error_suffix                      = '</p>';
  36         var $error_string                       = '';
  37         var $_safe_form_data            = FALSE;
  38
  39
  40         /**
  41          * Constructor
  42          *
  43          */
  44         function CI_Form_validation($rules = array())
  45         {
  46                 $this->CI =& get_instance();
  47
  48                 // Validation rules can be stored in a config file.
  49                 $this->_config_rules = $rules;
  50
  51                 // Automatically load the form helper
  52                 $this->CI->load->helper('form');
  53
  54                 // Set the character encoding in MB.
  55                 if (function_exists('mb_internal_encoding'))
  56                 {
  57                         mb_internal_encoding($this->CI->config->item('charset'));
  58                 }
  59
  60                 log_message('debug', "Validation Class Initialized");
  61         }
  62
  63         // --------------------------------------------------------------------
  64
  65         /**
  66          * Set Rules
  67          *
  68          * This function takes an array of field names and validation
  69          * rules as input, validates the info, and stores it
  70          *
  71          * @access      public
  72          * @param       mixed
  73          * @param       string
  74          * @return      void
  75          */
  76         function set_rules($field, $label = '', $rules = '')
  77         {
  78                 // No reason to set rules if we have no POST data
  79                 if (count($_POST) == 0)
  80                 {
  81                         return;
  82                 }
  83
  84                 // If an array was passed via the first parameter instead of indidual string
  85                 // values we cycle through it and recursively call this function.
  86                 if (is_array($field))
  87                 {
  88                         foreach ($field as $row)
  89                         {
  90                                 // Houston, we have a problem...
  91                                 if ( ! isset($row['field']) OR ! isset($row['rules']))
  92                                 {
  93                                         continue;
  94                                 }
  95
  96                                 // If the field label wasn't passed we use the field name
  97                                 $label = ( ! isset($row['label'])) ? $row['field'] : $row['label'];
  98
  99                                 // Here we go!
 100                                 $this->set_rules($row['field'], $label, $row['rules']);
 101                         }
 102                         return;
 103                 }
 104
 105                 // No fields? Nothing to do...
 106                 if ( ! is_string($field) OR  ! is_string($rules) OR $field == '')
 107                 {
 108                         return;
 109                 }
 110
 111                 // If the field label wasn't passed we use the field name
 112                 $label = ($label == '') ? $field : $label;
 113
 114                 // Is the field name an array?  We test for the existence of a bracket "[" in
 115                 // the field name to determine this.  If it is an array, we break it apart
 116                 // into its components so that we can fetch the corresponding POST data later
 117                 if (strpos($field, '[') !== FALSE AND preg_match_all('/\[(.*?)\]/', $field, $matches))
 118                 {
 119                         // Note: Due to a bug in current() that affects some versions
 120                         // of PHP we can not pass function call directly into it
 121                         $x = explode('[', $field);
 122                         $indexes[] = current($x);
 123
 124                         for ($i = 0; $i < count($matches['0']); $i++)
 125                         {
 126                                 if ($matches['1'][$i] != '')
 127                                 {
 128                                         $indexes[] = $matches['1'][$i];
 129                                 }
 130                         }
 131
 132                         $is_array = TRUE;
 133                 }
 134                 else
 135                 {
 136                         $indexes        = array();
 137                         $is_array       = FALSE;
 138                 }
 139
 140                 // Build our master array
 141                 $this->_field_data[$field] = array(
 142                                                                                         'field'                         => $field,
 143                                                                                         'label'                         => $label,
 144                                                                                         'rules'                         => $rules,
 145                                                                                         'is_array'                      => $is_array,
 146                                                                                         'keys'                          => $indexes,
 147                                                                                         'postdata'                      => NULL,
 148                                                                                         'error'                         => ''
 149                                                                                         );
 150         }
 151
 152         // --------------------------------------------------------------------
 153
 154         /**
 155          * Set Error Message
 156          *
 157          * Lets users set their own error messages on the fly.  Note:  The key
 158          * name has to match the  function name that it corresponds to.
 159          *
 160          * @access      public
 161          * @param       string
 162          * @param       string
 163          * @return      string
 164          */
 165         function set_message($lang, $val = '')
 166         {
 167                 if ( ! is_array($lang))
 168                 {
 169                         $lang = array($lang => $val);
 170                 }
 171
 172                 $this->_error_messages = array_merge($this->_error_messages, $lang);
 173         }
 174
 175         // --------------------------------------------------------------------
 176
 177         /**
 178          * Set The Error Delimiter
 179          *
 180          * Permits a prefix/suffix to be added to each error message
 181          *
 182          * @access      public
 183          * @param       string
 184          * @param       string
 185          * @return      void
 186          */
 187         function set_error_delimiters($prefix = '<p>', $suffix = '</p>')
 188         {
 189                 $this->_error_prefix = $prefix;
 190                 $this->_error_suffix = $suffix;
 191         }
 192
 193         // --------------------------------------------------------------------
 194
 195         /**
 196          * Get Error Message
 197          *
 198          * Gets the error message associated with a particular field
 199          *
 200          * @access      public
 201          * @param       string  the field name
 202          * @return      void
 203          */
 204         function error($field = '', $prefix = '', $suffix = '')
 205         {
 206                 if ( ! isset($this->_field_data[$field]['error']) OR $this->_field_data[$field]['error'] == '')
 207                 {
 208                         return '';
 209                 }
 210
 211                 if ($prefix == '')
 212                 {
 213                         $prefix = $this->_error_prefix;
 214                 }
 215
 216                 if ($suffix == '')
 217                 {
 218                         $suffix = $this->_error_suffix;
 219                 }
 220
 221                 return $prefix.$this->_field_data[$field]['error'].$suffix;
 222         }
 223
 224         // --------------------------------------------------------------------
 225
 226         /**
 227          * Error String
 228          *
 229          * Returns the error messages as a string, wrapped in the error delimiters
 230          *
 231          * @access      public
 232          * @param       string
 233          * @param       string
 234          * @return      str
 235          */
 236         function error_string($prefix = '', $suffix = '')
 237         {
 238                 // No errrors, validation passes!
 239                 if (count($this->_error_array) === 0)
 240                 {
 241                         return '';
 242                 }
 243
 244                 if ($prefix == '')
 245                 {
 246                         $prefix = $this->_error_prefix;
 247                 }
 248
 249                 if ($suffix == '')
 250                 {
 251                         $suffix = $this->_error_suffix;
 252                 }
 253
 254                 // Generate the error string
 255                 $str = '';
 256                 foreach ($this->_error_array as $val)
 257                 {
 258                         if ($val != '')
 259                         {
 260                                 $str .= $prefix.$val.$suffix."\n";
 261                         }
 262                 }
 263
 264                 return $str;
 265         }
 266
 267         // --------------------------------------------------------------------
 268
 269         /**
 270          * Run the Validator
 271          *
 272          * This function does all the work.
 273          *
 274          * @access      public
 275          * @return      bool
 276          */
 277         function run($group = '')
 278         {
 279                 // Do we even have any data to process?  Mm?
 280                 if (count($_POST) == 0)
 281                 {
 282                         return FALSE;
 283                 }
 284
 285                 // Does the _field_data array containing the validation rules exist?
 286                 // If not, we look to see if they were assigned via a config file
 287                 if (count($this->_field_data) == 0)
 288                 {
 289                         // No validation rules?  We're done...
 290                         if (count($this->_config_rules) == 0)
 291                         {
 292                                 return FALSE;
 293                         }
 294
 295                         // Is there a validation rule for the particular URI being accessed?
 296                         $uri = ($group == '') ? trim($this->CI->uri->ruri_string(), '/') : $group;
 297
 298                         if ($uri != '' AND isset($this->_config_rules[$uri]))
 299                         {
 300                                 $this->set_rules($this->_config_rules[$uri]);
 301                         }
 302                         else
 303                         {
 304                                 $this->set_rules($this->_config_rules);
 305                         }
 306
 307                         // We're we able to set the rules correctly?
 308                         if (count($this->_field_data) == 0)
 309                         {
 310                                 log_message('debug', "Unable to find validation rules");
 311                                 return FALSE;
 312                         }
 313                 }
 314
 315                 // Load the language file containing error messages
 316                 $this->CI->lang->load('form_validation');
 317
 318                 // Cycle through the rules for each field, match the
 319                 // corresponding $_POST item and test for errors
 320                 foreach ($this->_field_data as $field => $row)
 321                 {
 322                         // Fetch the data from the corresponding $_POST array and cache it in the _field_data array.
 323                         // Depending on whether the field name is an array or a string will determine where we get it from.
 324
 325                         if ($row['is_array'] == TRUE)
 326                         {
 327                                 $this->_field_data[$field]['postdata'] = $this->_reduce_array($_POST, $row['keys']);
 328                         }
 329                         else
 330                         {
 331                                 if (isset($_POST[$field]) AND $_POST[$field] != "")
 332                                 {
 333                                         $this->_field_data[$field]['postdata'] = $_POST[$field];
 334                                 }
 335                         }
 336
 337                         $this->_execute($row, explode('|', $row['rules']), $this->_field_data[$field]['postdata']);
 338                 }
 339
 340                 // Did we end up with any errors?
 341                 $total_errors = count($this->_error_array);
 342
 343                 if ($total_errors > 0)
 344                 {
 345                         $this->_safe_form_data = TRUE;
 346                 }
 347
 348                 // Now we need to re-set the POST data with the new, processed data
 349                 $this->_reset_post_array();
 350
 351                 // No errors, validation passes!
 352                 if ($total_errors == 0)
 353                 {
 354                         return TRUE;
 355                 }
 356
 357                 // Validation fails
 358                 return FALSE;
 359         }
 360
 361         // --------------------------------------------------------------------
 362
 363         /**
 364          * Traverse a multidimensional $_POST array index until the data is found
 365          *
 366          * @access      private
 367          * @param       array
 368          * @param       array
 369          * @param       integer
 370          * @return      mixed
 371          */
 372         function _reduce_array($array, $keys, $i = 0)
 373         {
 374                 if (is_array($array))
 375                 {
 376                         if (isset($keys[$i]))
 377                         {
 378                                 if (isset($array[$keys[$i]]))
 379                                 {
 380                                         $array = $this->_reduce_array($array[$keys[$i]], $keys, ($i+1));
 381                                 }
 382                                 else
 383                                 {
 384                                         return NULL;
 385                                 }
 386                         }
 387                         else
 388                         {
 389                                 return $array;
 390                         }
 391                 }
 392
 393                 return $array;
 394         }
 395
 396         // --------------------------------------------------------------------
 397
 398         /**
 399          * Re-populate the _POST array with our finalized and processed data
 400          *
 401          * @access      private
 402          * @return      null
 403          */
 404         function _reset_post_array()
 405         {
 406                 foreach ($this->_field_data as $field => $row)
 407                 {
 408                         if ( ! is_null($row['postdata']))
 409                         {
 410                                 if ($row['is_array'] == FALSE)
 411                                 {
 412                                         if (isset($_POST[$row['field']]))
 413                                         {
 414                                                 $_POST[$row['field']] = $this->prep_for_form($row['postdata']);
 415                                         }
 416                                 }
 417                                 else
 418                                 {
 419                                         $post = '$_POST["';
 420
 421                                         if (count($row['keys']) == 1)
 422                                         {
 423                                                 $post .= current($row['keys']);
 424                                                 $post .= '"]';
 425                                         }
 426                                         else
 427                                         {
 428                                                 $i = 0;
 429                                                 foreach ($row['keys'] as $val)
 430                                                 {
 431                                                         if ($i == 0)
 432                                                         {
 433                                                                 $post .= $val.'"]';
 434                                                                 $i++;
 435                                                                 continue;
 436                                                         }
 437
 438                                                         $post .= '["'.$val.'"]';
 439                                                 }
 440                                         }
 441
 442                                         if (is_array($row['postdata']))
 443                                         {
 444                                                 $array = array();
 445                                                 foreach ($row['postdata'] as $k => $v)
 446                                                 {
 447                                                         $array[$k] = $this->prep_for_form($v);
 448                                                 }
 449
 450                                                 $post .= ' = $array;';
 451                                         }
 452                                         else
 453                                         {
 454                                                 $post .= ' = "'.$this->prep_for_form($row['postdata']).'";';
 455                                         }
 456
 457                                         eval($post);
 458                                 }
 459                         }
 460                 }
 461         }
 462
 463         // --------------------------------------------------------------------
 464
 465         /**
 466          * Executes the Validation routines
 467          *
 468          * @access      private
 469          * @param       array
 470          * @param       array
 471          * @param       mixed
 472          * @param       integer
 473          * @return      mixed
 474          */
 475         function _execute($row, $rules, $postdata = NULL, $cycles = 0)
 476         {
 477                 // If the $_POST data is an array we will run a recursive call
 478                 if (is_array($postdata))
 479                 {
 480                         foreach ($postdata as $key => $val)
 481                         {
 482                                 $this->_execute($row, $rules, $val, $cycles);
 483                                 $cycles++;
 484                         }
 485
 486                         return;
 487                 }
 488
 489                 // --------------------------------------------------------------------
 490
 491                 // If the field is blank, but NOT required, no further tests are necessary
 492                 $callback = FALSE;
 493                 if ( ! in_array('required', $rules) AND is_null($postdata))
 494                 {
 495                         // Before we bail out, does the rule contain a callback?
 496                         if (preg_match("/(callback_\w+)/", implode(' ', $rules), $match))
 497                         {
 498                                 $callback = TRUE;
 499                                 $rules = (array('1' => $match[1]));
 500                         }
 501                         else
 502                         {
 503                                 return;
 504                         }
 505                 }
 506
 507                 // --------------------------------------------------------------------
 508
 509                 // Isset Test. Typically this rule will only apply to checkboxes.
 510                 if (is_null($postdata) AND $callback == FALSE)
 511                 {
 512                         if (in_array('isset', $rules, TRUE) OR in_array('required', $rules))
 513                         {
 514                                 // Set the message type
 515                                 $type = (in_array('required', $rules)) ? 'required' : 'isset';
 516
 517                                 if ( ! isset($this->_error_messages[$type]))
 518                                 {
 519                                         if (FALSE === ($line = $this->CI->lang->line($type)))
 520                                         {
 521                                                 $line = 'The field was not set';
 522                                         }
 523                                 }
 524                                 else
 525                                 {
 526                                         $line = $this->_error_messages[$type];
 527                                 }
 528
 529                                 // Build the error message
 530                                 $message = sprintf($line, $this->_translate_fieldname($row['label']));
 531
 532                                 // Save the error message
 533                                 $this->_field_data[$row['field']]['error'] = $message;
 534
 535                                 if ( ! isset($this->_error_array[$row['field']]))
 536                                 {
 537                                         $this->_error_array[$row['field']] = $message;
 538                                 }
 539                         }
 540
 541                         return;
 542                 }
 543
 544                 // --------------------------------------------------------------------
 545
 546                 // Cycle through each rule and run it
 547                 foreach ($rules As $rule)
 548                 {
 549                         $_in_array = FALSE;
 550
 551                         // We set the $postdata variable with the current data in our master array so that
 552                         // each cycle of the loop is dealing with the processed data from the last cycle
 553                         if ($row['is_array'] == TRUE AND is_array($this->_field_data[$row['field']]['postdata']))
 554                         {
 555                                 // We shouldn't need this safety, but just in case there isn't an array index
 556                                 // associated with this cycle we'll bail out
 557                                 if ( ! isset($this->_field_data[$row['field']]['postdata'][$cycles]))
 558                                 {
 559                                         continue;
 560                                 }
 561
 562                                 $postdata = $this->_field_data[$row['field']]['postdata'][$cycles];
 563                                 $_in_array = TRUE;
 564                         }
 565                         else
 566                         {
 567                                 $postdata = $this->_field_data[$row['field']]['postdata'];
 568                         }
 569
 570                         // --------------------------------------------------------------------
 571
 572                         // Is the rule a callback?
 573                         $callback = FALSE;
 574                         if (substr($rule, 0, 9) == 'callback_')
 575                         {
 576                                 $rule = substr($rule, 9);
 577                                 $callback = TRUE;
 578                         }
 579
 580                         // Strip the parameter (if exists) from the rule
 581                         // Rules can contain a parameter: max_length[5]
 582                         $param = FALSE;
 583                         if (preg_match("/(.*?)\[(.*?)\]/", $rule, $match))
 584                         {
 585                                 $rule   = $match[1];
 586                                 $param  = $match[2];
 587                         }
 588
 589                         // Call the function that corresponds to the rule
 590                         if ($callback === TRUE)
 591                         {
 592                                 if ( ! method_exists($this->CI, $rule))
 593                                 {
 594                                         continue;
 595                                 }
 596
 597                                 // Run the function and grab the result
 598                                 $result = $this->CI->$rule($postdata, $param);
 599
 600                                 // Re-assign the result to the master data array
 601                                 if ($_in_array == TRUE)
 602                                 {
 603                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 604                                 }
 605                                 else
 606                                 {
 607                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 608                                 }
 609
 610                                 // If the field isn't required and we just processed a callback we'll move on...
 611                                 if ( ! in_array('required', $rules, TRUE) AND $result !== FALSE)
 612                                 {
 613                                         return;
 614                                 }
 615                         }
 616                         else
 617                         {
 618                                 if ( ! method_exists($this, $rule))
 619                                 {
 620                                         // If our own wrapper function doesn't exist we see if a native PHP function does.
 621                                         // Users can use any native PHP function call that has one param.
 622                                         if (function_exists($rule))
 623                                         {
 624                                                 $result = $rule($postdata);
 625
 626                                                 if ($_in_array == TRUE)
 627                                                 {
 628                                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 629                                                 }
 630                                                 else
 631                                                 {
 632                                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 633                                                 }
 634                                         }
 635
 636                                         continue;
 637                                 }
 638
 639                                 $result = $this->$rule($postdata, $param);
 640
 641                                 if ($_in_array == TRUE)
 642                                 {
 643                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 644                                 }
 645                                 else
 646                                 {
 647                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 648                                 }
 649                         }
 650
 651                         // Did the rule test negatively?  If so, grab the error.
 652                         if ($result === FALSE)
 653                         {
 654                                 if ( ! isset($this->_error_messages[$rule]))
 655                                 {
 656                                         if (FALSE === ($line = $this->CI->lang->line($rule)))
 657                                         {
 658                                                 $line = 'Unable to access an error message corresponding to your field name.';
 659                                         }
 660                                 }
 661                                 else
 662                                 {
 663                                         $line = $this->_error_messages[$rule];
 664                                 }
 665
 666                                 // Build the error message
 667                                 $message = sprintf($line, $this->_translate_fieldname($row['label']), $param);
 668
 669                                 // Save the error message
 670                                 $this->_field_data[$row['field']]['error'] = $message;
 671
 672                                 if ( ! isset($this->_error_array[$row['field']]))
 673                                 {
 674                                         $this->_error_array[$row['field']] = $message;
 675                                 }
 676
 677                                 return;
 678                         }
 679                 }
 680         }
 681
 682         // --------------------------------------------------------------------
 683
 684         /**
 685          * Translate a field name
 686          *
 687          * @access      private
 688          * @param       string  the field name
 689          * @return      string
 690          */
 691         function _translate_fieldname($fieldname)
 692         {
 693                 // Do we need to translate the field name?
 694                 // We look for the prefix lang: to determine this
 695                 if (substr($fieldname, 0, 5) == 'lang:')
 696                 {
 697                         // Grab the variable
 698                         $line = substr($fieldname, 5);
 699
 700                         // Were we able to translate the field name?  If not we use $line
 701                         if (FALSE === ($fieldname = $this->CI->lang->line($line)))
 702                         {
 703                                 return $line;
 704                         }
 705                 }
 706
 707                 return $fieldname;
 708         }
 709
 710         // --------------------------------------------------------------------
 711
 712         /**
 713          * Get the value from a form
 714          *
 715          * Permits you to repopulate a form field with the value it was submitted
 716          * with, or, if that value doesn't exist, with the default
 717          *
 718          * @access      public
 719          * @param       string  the field name
 720          * @param       string
 721          * @return      void
 722          */
 723         function set_value($field = '', $default = '')
 724         {
 725                 if ( ! isset($this->_field_data[$field]))
 726                 {
 727                         return $default;
 728                 }
 729
 730                 return $this->_field_data[$field]['postdata'];
 731         }
 732
 733         // --------------------------------------------------------------------
 734
 735         /**
 736          * Set Select
 737          *
 738          * Enables pull-down lists to be set to the value the user
 739          * selected in the event of an error
 740          *
 741          * @access      public
 742          * @param       string
 743          * @param       string
 744          * @return      string
 745          */
 746         function set_select($field = '', $value = '', $default = FALSE)
 747         {
 748                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 749                 {
 750                         if ($default === TRUE AND count($this->_field_data) === 0)
 751                         {
 752                                 return ' selected="selected"';
 753                         }
 754                         return '';
 755                 }
 756
 757                 $field = $this->_field_data[$field]['postdata'];
 758
 759                 if (is_array($field))
 760                 {
 761                         if ( ! in_array($value, $field))
 762                         {
 763                                 return '';
 764                         }
 765                 }
 766                 else
 767                 {
 768                         if (($field == '' OR $value == '') OR ($field != $value))
 769                         {
 770                                 return '';
 771                         }
 772                 }
 773
 774                 return ' selected="selected"';
 775         }
 776
 777         // --------------------------------------------------------------------
 778
 779         /**
 780          * Set Radio
 781          *
 782          * Enables radio buttons to be set to the value the user
 783          * selected in the event of an error
 784          *
 785          * @access      public
 786          * @param       string
 787          * @param       string
 788          * @return      string
 789          */
 790         function set_radio($field = '', $value = '', $default = FALSE)
 791         {
 792                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 793                 {
 794                         if ($default === TRUE AND count($this->_field_data) === 0)
 795                         {
 796                                 return ' checked="checked"';
 797                         }
 798                         return '';
 799                 }
 800
 801                 $field = $this->_field_data[$field]['postdata'];
 802
 803                 if (is_array($field))
 804                 {
 805                         if ( ! in_array($value, $field))
 806                         {
 807                                 return '';
 808                         }
 809                 }
 810                 else
 811                 {
 812                         if (($field == '' OR $value == '') OR ($field != $value))
 813                         {
 814                                 return '';
 815                         }
 816                 }
 817
 818                 return ' checked="checked"';
 819         }
 820
 821         // --------------------------------------------------------------------
 822
 823         /**
 824          * Set Checkbox
 825          *
 826          * Enables checkboxes to be set to the value the user
 827          * selected in the event of an error
 828          *
 829          * @access      public
 830          * @param       string
 831          * @param       string
 832          * @return      string
 833          */
 834         function set_checkbox($field = '', $value = '', $default = FALSE)
 835         {
 836                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 837                 {
 838                         if ($default === TRUE AND count($this->_field_data) === 0)
 839                         {
 840                                 return ' checked="checked"';
 841                         }
 842                         return '';
 843                 }
 844
 845                 $field = $this->_field_data[$field]['postdata'];
 846
 847                 if (is_array($field))
 848                 {
 849                         if ( ! in_array($value, $field))
 850                         {
 851                                 return '';
 852                         }
 853                 }
 854                 else
 855                 {
 856                         if (($field == '' OR $value == '') OR ($field != $value))
 857                         {
 858                                 return '';
 859                         }
 860                 }
 861
 862                 return ' checked="checked"';
 863         }
 864
 865         // --------------------------------------------------------------------
 866
 867         /**
 868          * Required
 869          *
 870          * @access      public
 871          * @param       string
 872          * @return      bool
 873          */
 874         function required($str)
 875         {
 876                 if ( ! is_array($str))
 877                 {
 878                         return (trim($str) == '') ? FALSE : TRUE;
 879                 }
 880                 else
 881                 {
 882                         return ( ! empty($str));
 883                 }
 884         }
 885
 886         // --------------------------------------------------------------------
 887
 888         /**
 889          * Match one field to another
 890          *
 891          * @access      public
 892          * @param       string
 893          * @param       field
 894          * @return      bool
 895          */
 896         function matches($str, $field)
 897         {
 898                 if ( ! isset($_POST[$field]))
 899                 {
 900                         return FALSE;
 901                 }
 902
 903                 $field = $_POST[$field];
 904
 905                 return ($str !== $field) ? FALSE : TRUE;
 906         }
 907
 908         // --------------------------------------------------------------------
 909
 910         /**
 911          * Minimum Length
 912          *
 913          * @access      public
 914          * @param       string
 915          * @param       value
 916          * @return      bool
 917          */
 918         function min_length($str, $val)
 919         {
 920                 if (preg_match("/[^0-9]/", $val))
 921                 {
 922                         return FALSE;
 923                 }
 924
 925                 if (function_exists('mb_strlen'))
 926                 {
 927                         return (mb_strlen($str) < $val) ? FALSE : TRUE;
 928                 }
 929
 930                 return (strlen($str) < $val) ? FALSE : TRUE;
 931         }
 932
 933         // --------------------------------------------------------------------
 934
 935         /**
 936          * Max Length
 937          *
 938          * @access      public
 939          * @param       string
 940          * @param       value
 941          * @return      bool
 942          */
 943         function max_length($str, $val)
 944         {
 945                 if (preg_match("/[^0-9]/", $val))
 946                 {
 947                         return FALSE;
 948                 }
 949
 950                 if (function_exists('mb_strlen'))
 951                 {
 952                         return (mb_strlen($str) > $val) ? FALSE : TRUE;
 953                 }
 954
 955                 return (strlen($str) > $val) ? FALSE : TRUE;
 956         }
 957
 958         // --------------------------------------------------------------------
 959
 960         /**
 961          * Exact Length
 962          *
 963          * @access      public
 964          * @param       string
 965          * @param       value
 966          * @return      bool
 967          */
 968         function exact_length($str, $val)
 969         {
 970                 if (preg_match("/[^0-9]/", $val))
 971                 {
 972                         return FALSE;
 973                 }
 974
 975                 if (function_exists('mb_strlen'))
 976                 {
 977                         return (mb_strlen($str) != $val) ? FALSE : TRUE;
 978                 }
 979
 980                 return (strlen($str) != $val) ? FALSE : TRUE;
 981         }
 982
 983         // --------------------------------------------------------------------
 984
 985         /**
 986          * Valid Email
 987          *
 988          * @access      public
 989          * @param       string
 990          * @return      bool
 991          */
 992         function valid_email($str)
 993         {
 994                 return ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $str)) ? FALSE : TRUE;
 995         }
 996
 997         // --------------------------------------------------------------------
 998
 999         /**
1000          * Valid Emails
1001          *
1002          * @access      public
1003          * @param       string
1004          * @return      bool
1005          */
1006         function valid_emails($str)
1007         {
1008                 if (strpos($str, ',') === FALSE)
1009                 {
1010                         return $this->valid_email(trim($str));
1011                 }
1012
1013                 foreach(explode(',', $str) as $email)
1014                 {
1015                         if (trim($email) != '' && $this->valid_email(trim($email)) === FALSE)
1016                         {
1017                                 return FALSE;
1018                         }
1019                 }
1020
1021                 return TRUE;
1022         }
1023
1024         // --------------------------------------------------------------------
1025
1026         /**
1027          * Validate IP Address
1028          *
1029          * @access      public
1030          * @param       string
1031          * @return      string
1032          */
1033         function valid_ip($ip)
1034         {
1035                 return $this->CI->input->valid_ip($ip);
1036         }
1037
1038         // --------------------------------------------------------------------
1039
1040         /**
1041          * Alpha
1042          *
1043          * @access      public
1044          * @param       string
1045          * @return      bool
1046          */
1047         function alpha($str)
1048         {
1049                 return ( ! preg_match("/^([a-z])+$/i", $str)) ? FALSE : TRUE;
1050         }
1051
1052         // --------------------------------------------------------------------
1053
1054         /**
1055          * Alpha-numeric
1056          *
1057          * @access      public
1058          * @param       string
1059          * @return      bool
1060          */
1061         function alpha_numeric($str)
1062         {
1063                 return ( ! preg_match("/^([a-z0-9])+$/i", $str)) ? FALSE : TRUE;
1064         }
1065
1066         // --------------------------------------------------------------------
1067
1068         /**
1069          * Alpha-numeric with underscores and dashes
1070          *
1071          * @access      public
1072          * @param       string
1073          * @return      bool
1074          */
1075         function alpha_dash($str)
1076         {
1077                 return ( ! preg_match("/^([-a-z0-9_-])+$/i", $str)) ? FALSE : TRUE;
1078         }
1079
1080         // --------------------------------------------------------------------
1081
1082         /**
1083          * Numeric
1084          *
1085          * @access      public
1086          * @param       string
1087          * @return      bool
1088          */
1089         function numeric($str)
1090         {
1091                 return (bool)preg_match( '/^[\-+]?[0-9]*\.?[0-9]+$/', $str);
1092
1093         }
1094
1095         // --------------------------------------------------------------------
1096
1097     /**
1098      * Is Numeric
1099      *
1100      * @access    public
1101      * @param    string
1102      * @return    bool
1103      */
1104     function is_numeric($str)
1105     {
1106         return ( ! is_numeric($str)) ? FALSE : TRUE;
1107     }
1108
1109         // --------------------------------------------------------------------
1110
1111         /**
1112          * Integer
1113          *
1114          * @access      public
1115          * @param       string
1116          * @return      bool
1117          */
1118         function integer($str)
1119         {
1120                 return (bool)preg_match( '/^[\-+]?[0-9]+$/', $str);
1121         }
1122
1123         // --------------------------------------------------------------------
1124
1125     /**
1126      * Is a Natural number  (0,1,2,3, etc.)
1127      *
1128      * @access  public
1129      * @param   string
1130      * @return  bool
1131      */
1132     function is_natural($str)
1133     {
1134                 return (bool)preg_match( '/^[0-9]+$/', $str);
1135     }
1136
1137         // --------------------------------------------------------------------
1138
1139     /**
1140      * Is a Natural number, but not a zero  (1,2,3, etc.)
1141      *
1142      * @access  public
1143      * @param   string
1144      * @return  bool
1145      */
1146         function is_natural_no_zero($str)
1147     {
1148         if ( ! preg_match( '/^[0-9]+$/', $str))
1149         {
1150                 return FALSE;
1151         }
1152
1153         if ($str == 0)
1154         {
1155                 return FALSE;
1156         }
1157
1158                 return TRUE;
1159     }
1160
1161         // --------------------------------------------------------------------
1162
1163         /**
1164          * Valid Base64
1165          *
1166          * Tests a string for characters outside of the Base64 alphabet
1167          * as defined by RFC 2045 http://www.faqs.org/rfcs/rfc2045
1168          *
1169          * @access      public
1170          * @param       string
1171          * @return      bool
1172          */
1173         function valid_base64($str)
1174         {
1175                 return (bool) ! preg_match('/[^a-zA-Z0-9\/\+=]/', $str);
1176         }
1177
1178         // --------------------------------------------------------------------
1179
1180         /**
1181          * Prep data for form
1182          *
1183          * This function allows HTML to be safely shown in a form.
1184          * Special characters are converted.
1185          *
1186          * @access      public
1187          * @param       string
1188          * @return      string
1189          */
1190         function prep_for_form($data = '')
1191         {
1192                 if (is_array($data))
1193                 {
1194                         foreach ($data as $key => $val)
1195                         {
1196                                 $data[$key] = $this->prep_for_form($val);
1197                         }
1198
1199                         return $data;
1200                 }
1201
1202                 if ($this->_safe_form_data == FALSE OR $data === '')
1203                 {
1204                         return $data;
1205                 }
1206
1207                 return str_replace(array("'", '"', '<', '>'), array("&#39;", "&quot;", '&lt;', '&gt;'), stripslashes($data));
1208         }
1209
1210         // --------------------------------------------------------------------
1211
1212         /**
1213          * Prep URL
1214          *
1215          * @access      public
1216          * @param       string
1217          * @return      string
1218          */
1219         function prep_url($str = '')
1220         {
1221                 if ($str == 'http://' OR $str == '')
1222                 {
1223                         return '';
1224                 }
1225
1226                 if (substr($str, 0, 7) != 'http://' && substr($str, 0, 8) != 'https://')
1227                 {
1228                         $str = 'http://'.$str;
1229                 }
1230
1231                 return $str;
1232         }
1233
1234         // --------------------------------------------------------------------
1235
1236         /**
1237          * Strip Image Tags
1238          *
1239          * @access      public
1240          * @param       string
1241          * @return      string
1242          */
1243         function strip_image_tags($str)
1244         {
1245                 return $this->CI->input->strip_image_tags($str);
1246         }
1247
1248         // --------------------------------------------------------------------
1249
1250         /**
1251          * XSS Clean
1252          *
1253          * @access      public
1254          * @param       string
1255          * @return      string
1256          */
1257         function xss_clean($str)
1258         {
1259                 return $this->CI->input->xss_clean($str);
1260         }
1261
1262         // --------------------------------------------------------------------
1263
1264         /**
1265          * Convert PHP tags to entities
1266          *
1267          * @access      public
1268          * @param       string
1269          * @return      string
1270          */
1271         function encode_php_tags($str)
1272         {
1273                 return str_replace(array('<?php', '<?PHP', '<?', '?>'),  array('&lt;?php', '&lt;?PHP', '&lt;?', '?&gt;'), $str);
1274         }
1275
1276 }
1277 // END Form Validation Class
1278
1279 /* End of file Form_validation.php */
1280 /* Location: ./system/libraries/Form_validation.php */