CI_Validation Class Reference

List of all members.


Public Member Functions
	CI_Validation ()
	Constructor.
	set_fields ($data= '', $field= '')
	Set Fields.
	set_rules ($data, $rules= '')
	Set Rules.
	set_message ($lang, $val= '')
	Set Error Message.
	set_error_delimiters ($prefix= '< p >', $suffix= '</p >')
	Set The Error Delimiter.
	run ()
	Run the Validator.
	required ($str)
	Required.
	matches ($str, $field)
	Match one field to another.
	min_length ($str, $val)
	Minimum Length.
	max_length ($str, $val)
	Max Length.
	exact_length ($str, $val)
	Exact Length.
	valid_email ($str)
	Valid Email.
	valid_emails ($str)
	Valid Emails.
	valid_ip ($ip)
	Validate IP Address.
	alpha ($str)
	Alpha.
	alpha_numeric ($str)
	Alpha-numeric.
	alpha_dash ($str)
	Alpha-numeric with underscores and dashes.
	numeric ($str)
	Numeric.
	is_numeric ($str)
	Is Numeric.
	integer ($str)
	Integer.
	is_natural ($str)
	Is a Natural number (0,1,2,3, etc.
	is_natural_no_zero ($str)
	Is a Natural number, but not a zero (1,2,3, etc.
	valid_base64 ($str)
	Valid Base64.
	set_select ($field= '', $value= '')
	Set Select.
	set_radio ($field= '', $value= '')
	Set Radio.
	set_checkbox ($field= '', $value= '')
	Set Checkbox.
	prep_for_form ($data= '')
	Prep data for form.
	prep_url ($str= '')
	Prep URL.
	strip_image_tags ($str)
	Strip Image Tags.
	xss_clean ($str)
	XSS Clean.
	encode_php_tags ($str)
	Convert PHP tags to entities.
Public Attributes
	$CI
	$error_string = ''
	$_error_array = array()
	$_rules = array()
	$_fields = array()
	$_error_messages = array()
	$_current_field = ''
	$_safe_form_data = FALSE
	$_error_prefix = '<p>'
	$_error_suffix = '</p>'

Detailed Description

Definition at line 27 of file Validation.php.

Member Function Documentation

CI_Validation::alpha ( $ str )

Alpha.

public

Parameters:

string

Returns:: bool

Definition at line 563 of file Validation.php.

00564         {
00565                 return ( ! preg_match("/^([a-z])+$/i", $str)) ? FALSE : TRUE;
00566         }

CI_Validation::alpha_dash ( $ str )

Alpha-numeric with underscores and dashes.

public

Parameters:

string

Returns:: bool

Definition at line 591 of file Validation.php.

00592         {
00593                 return ( ! preg_match("/^([-a-z0-9_-])+$/i", $str)) ? FALSE : TRUE;
00594         }

CI_Validation::alpha_numeric ( $ str )

Alpha-numeric.

public

Parameters:

string

Returns:: bool

Definition at line 577 of file Validation.php.

00578         {
00579                 return ( ! preg_match("/^([a-z0-9])+$/i", $str)) ? FALSE : TRUE;
00580         }

CI_Validation::CI_Validation ( )

Constructor.

Definition at line 46 of file Validation.php.

References get_instance(), and log_message().

00047         {       
00048                 $this->CI =& get_instance();
00049                 
00050                 if (function_exists('mb_internal_encoding'))
00051                 {
00052                         mb_internal_encoding($this->CI->config->item('charset'));
00053                 }
00054                 
00055                 log_message('debug', "Validation Class Initialized");
00056         }

Here is the call graph for this function:

CI_Validation::encode_php_tags ( $ str )

Convert PHP tags to entities.

public

Parameters:

string

Returns:: string

Definition at line 866 of file Validation.php.

00867         {
00868                 $_POST[$this->_current_field] = str_replace(array('<?php', '<?PHP', '<?', '?>'),  array('&lt;?php', '&lt;?PHP', '&lt;?', '?&gt;'), $str);
00869         }

CI_Validation::exact_length	(	$	str,
		$	val
	)

Exact Length.

public

Parameters:

	string
	value

Returns:: bool

Definition at line 484 of file Validation.php.

00485         {
00486                 if (preg_match("/[^0-9]/", $val))
00487                 {
00488                         return FALSE;
00489                 }
00490         
00491                 if (function_exists('mb_strlen'))
00492                 {
00493                         return (mb_strlen($str) != $val) ? FALSE : TRUE;                
00494                 }
00495 
00496                 return (strlen($str) != $val) ? FALSE : TRUE;
00497         }

CI_Validation::integer ( $ str )

Integer.

public

Parameters:

string

Returns:: bool

Definition at line 634 of file Validation.php.

00635         {
00636                 return (bool)preg_match( '/^[\-+]?[0-9]+$/', $str);
00637         }

CI_Validation::is_natural ( $ str )

Is a Natural number (0,1,2,3, etc.

)

public

Parameters:

string

Returns:: bool

Definition at line 648 of file Validation.php.

00649         {   
00650                 return (bool)preg_match( '/^[0-9]+$/', $str);
00651         }

CI_Validation::is_natural_no_zero ( $ str )

Is a Natural number, but not a zero (1,2,3, etc.

)

public

Parameters:

string

Returns:: bool

Definition at line 662 of file Validation.php.

00663         {   
00664                 if ( ! preg_match( '/^[0-9]+$/', $str))
00665                 {
00666                         return FALSE;
00667                 }
00668         
00669                 if ($str == 0)
00670                 {
00671                         return FALSE;
00672                 }
00673 
00674                 return TRUE;
00675         }

CI_Validation::is_numeric ( $ str )

Is Numeric.

public

Parameters:

string

Returns:: bool

Definition at line 620 of file Validation.php.

00621         {
00622                 return ( ! is_numeric($str)) ? FALSE : TRUE;
00623         }

CI_Validation::matches	(	$	str,
		$	field
	)

Match one field to another.

public

Parameters:

	string
	field

Returns:: bool

Definition at line 414 of file Validation.php.

00415         {
00416                 if ( ! isset($_POST[$field]))
00417                 {
00418                         return FALSE;
00419                 }
00420                 
00421                 return ($str !== $_POST[$field]) ? FALSE : TRUE;
00422         }

CI_Validation::max_length	(	$	str,
		$	val
	)

Max Length.

public

Parameters:

	string
	value

Returns:: bool

Definition at line 459 of file Validation.php.

00460         {
00461                 if (preg_match("/[^0-9]/", $val))
00462                 {
00463                         return FALSE;
00464                 }
00465                 
00466                 if (function_exists('mb_strlen'))
00467                 {
00468                         return (mb_strlen($str) > $val) ? FALSE : TRUE;         
00469                 }
00470 
00471                 return (strlen($str) > $val) ? FALSE : TRUE;
00472         }

CI_Validation::min_length	(	$	str,
		$	val
	)

Minimum Length.

public

Parameters:

	string
	value

Returns:: bool

Definition at line 434 of file Validation.php.

00435         {
00436                 if (preg_match("/[^0-9]/", $val))
00437                 {
00438                         return FALSE;
00439                 }
00440 
00441                 if (function_exists('mb_strlen'))
00442                 {
00443                         return (mb_strlen($str) < $val) ? FALSE : TRUE;         
00444                 }
00445 
00446                 return (strlen($str) < $val) ? FALSE : TRUE;
00447         }

CI_Validation::numeric ( $ str )

Numeric.

public

Parameters:

string

Returns:: bool

Definition at line 605 of file Validation.php.

00606         {
00607                 return (bool)preg_match( '/^[\-+]?[0-9]*\.?[0-9]+$/', $str);
00608 
00609         }

CI_Validation::prep_for_form ( $ data = '' )

Prep data for form.

This function allows HTML to be safely shown in a form. Special characters are converted.

public

Parameters:

string

Returns:: string

Definition at line 784 of file Validation.php.

Referenced by set_fields().

00785         {
00786                 if (is_array($data))
00787                 {
00788                         foreach ($data as $key => $val)
00789                         {
00790                                 $data[$key] = $this->prep_for_form($val);
00791                         }
00792                         
00793                         return $data;
00794                 }
00795                 
00796                 if ($this->_safe_form_data == FALSE OR $data == '')
00797                 {
00798                         return $data;
00799                 }
00800 
00801                 return str_replace(array("'", '"', '<', '>'), array("&#39;", "&quot;", '&lt;', '&gt;'), stripslashes($data));
00802         }

Here is the caller graph for this function:

CI_Validation::prep_url ( $ str = '' )

Prep URL.

public

Parameters:

string

Returns:: string

Definition at line 813 of file Validation.php.

00814         {
00815                 if ($str == 'http://' OR $str == '')
00816                 {
00817                         $_POST[$this->_current_field] = '';
00818                         return;
00819                 }
00820                 
00821                 if (substr($str, 0, 7) != 'http://' && substr($str, 0, 8) != 'https://')
00822                 {
00823                         $str = 'http://'.$str;
00824                 }
00825                 
00826                 $_POST[$this->_current_field] = $str;
00827         }

CI_Validation::required ( $ str )

Required.

public

Parameters:

string

Returns:: bool

Definition at line 392 of file Validation.php.

00393         {
00394                 if ( ! is_array($str))
00395                 {
00396                         return (trim($str) == '') ? FALSE : TRUE;
00397                 }
00398                 else
00399                 {
00400                         return ( ! empty($str));
00401                 }
00402         }

CI_Validation::run ( )

Run the Validator.

This function does all the work.

public

Returns:: bool

Definition at line 186 of file Validation.php.

References set_fields().

00187         {
00188                 // Do we even have any data to process?  Mm?
00189                 if (count($_POST) == 0 OR count($this->_rules) == 0)
00190                 {
00191                         return FALSE;
00192                 }
00193         
00194                 // Load the language file containing error messages
00195                 $this->CI->lang->load('validation');
00196                                                         
00197                 // Cycle through the rules and test for errors
00198                 foreach ($this->_rules as $field => $rules)
00199                 {
00200                         //Explode out the rules!
00201                         $ex = explode('|', $rules);
00202 
00203                         // Is the field required?  If not, if the field is blank  we'll move on to the next test
00204                         if ( ! in_array('required', $ex, TRUE))
00205                         {
00206                                 if ( ! isset($_POST[$field]) OR $_POST[$field] == '')
00207                                 {
00208                                         continue;
00209                                 }
00210                         }
00211                         
00212                         /*
00213                          * Are we dealing with an "isset" rule?
00214                          *
00215                          * Before going further, we'll see if one of the rules
00216                          * is to check whether the item is set (typically this
00217                          * applies only to checkboxes).  If so, we'll
00218                          * test for it here since there's not reason to go
00219                          * further
00220                          */
00221                         if ( ! isset($_POST[$field]))
00222                         {                       
00223                                 if (in_array('isset', $ex, TRUE) OR in_array('required', $ex))
00224                                 {
00225                                         if ( ! isset($this->_error_messages['isset']))
00226                                         {
00227                                                 if (FALSE === ($line = $this->CI->lang->line('isset')))
00228                                                 {
00229                                                         $line = 'The field was not set';
00230                                                 }                                                       
00231                                         }
00232                                         else
00233                                         {
00234                                                 $line = $this->_error_messages['isset'];
00235                                         }
00236                                         
00237                                         // Build the error message
00238                                         $mfield = ( ! isset($this->_fields[$field])) ? $field : $this->_fields[$field];
00239                                         $message = sprintf($line, $mfield);
00240 
00241                                         // Set the error variable.  Example: $this->username_error
00242                                         $error = $field.'_error';
00243                                         $this->$error = $this->_error_prefix.$message.$this->_error_suffix;
00244                                         $this->_error_array[] = $message;
00245                                 }
00246                                                 
00247                                 continue;
00248                         }
00249         
00250                         /*
00251                          * Set the current field
00252                          *
00253                          * The various prepping functions need to know the
00254                          * current field name so they can do this:
00255                          *
00256                          * $_POST[$this->_current_field] == 'bla bla';
00257                          */
00258                         $this->_current_field = $field;
00259 
00260                         // Cycle through the rules!
00261                         foreach ($ex As $rule)
00262                         {
00263                                 // Is the rule a callback?                      
00264                                 $callback = FALSE;
00265                                 if (substr($rule, 0, 9) == 'callback_')
00266                                 {
00267                                         $rule = substr($rule, 9);
00268                                         $callback = TRUE;
00269                                 }
00270                                 
00271                                 // Strip the parameter (if exists) from the rule
00272                                 // Rules can contain a parameter: max_length[5]
00273                                 $param = FALSE;
00274                                 if (preg_match("/(.*?)\[(.*?)\]/", $rule, $match))
00275                                 {
00276                                         $rule   = $match[1];
00277                                         $param  = $match[2];
00278                                 }
00279                                 
00280                                 // Call the function that corresponds to the rule
00281                                 if ($callback === TRUE)
00282                                 {
00283                                         if ( ! method_exists($this->CI, $rule))
00284                                         {               
00285                                                 continue;
00286                                         }
00287                                         
00288                                         $result = $this->CI->$rule($_POST[$field], $param);     
00289                                         
00290                                         // If the field isn't required and we just processed a callback we'll move on...
00291                                         if ( ! in_array('required', $ex, TRUE) AND $result !== FALSE)
00292                                         {
00293                                                 continue 2;
00294                                         }
00295                                         
00296                                 }
00297                                 else
00298                                 {                               
00299                                         if ( ! method_exists($this, $rule))
00300                                         {
00301                                                 /*
00302                                                  * Run the native PHP function if called for
00303                                                  *
00304                                                  * If our own wrapper function doesn't exist we see
00305                                                  * if a native PHP function does. Users can use
00306                                                  * any native PHP function call that has one param.
00307                                                  */
00308                                                 if (function_exists($rule))
00309                                                 {
00310                                                         $_POST[$field] = $rule($_POST[$field]);
00311                                                         $this->$field = $_POST[$field];
00312                                                 }
00313                                                                                         
00314                                                 continue;
00315                                         }
00316                                         
00317                                         $result = $this->$rule($_POST[$field], $param);
00318                                 }
00319                                                                 
00320                                 // Did the rule test negatively?  If so, grab the error.
00321                                 if ($result === FALSE)
00322                                 {
00323                                         if ( ! isset($this->_error_messages[$rule]))
00324                                         {
00325                                                 if (FALSE === ($line = $this->CI->lang->line($rule)))
00326                                                 {
00327                                                         $line = 'Unable to access an error message corresponding to your field name.';
00328                                                 }                                               
00329                                         }
00330                                         else
00331                                         {
00332                                                 $line = $this->_error_messages[$rule];
00333                                         }                               
00334 
00335                                         // Build the error message
00336                                         $mfield = ( ! isset($this->_fields[$field])) ? $field : $this->_fields[$field];
00337                                         $mparam = ( ! isset($this->_fields[$param])) ? $param : $this->_fields[$param];
00338                                         $message = sprintf($line, $mfield, $mparam);
00339                                         
00340                                         // Set the error variable.  Example: $this->username_error
00341                                         $error = $field.'_error';
00342                                         $this->$error = $this->_error_prefix.$message.$this->_error_suffix;
00343 
00344                                         // Add the error to the error array
00345                                         $this->_error_array[] = $message;                               
00346                                         continue 2;
00347                                 }                               
00348                         }
00349                         
00350                 }
00351                 
00352                 $total_errors = count($this->_error_array);
00353 
00354                 /*
00355                  * Recompile the class variables
00356                  *
00357                  * If any prepping functions were called the $_POST data
00358                  * might now be different then the corresponding class
00359                  * variables so we'll set them anew.
00360                  */     
00361                 if ($total_errors > 0)
00362                 {
00363                         $this->_safe_form_data = TRUE;
00364                 }
00365                 
00366                 $this->set_fields();
00367 
00368                 // Did we end up with any errors?
00369                 if ($total_errors == 0)
00370                 {
00371                         return TRUE;
00372                 }
00373                 
00374                 // Generate the error string
00375                 foreach ($this->_error_array as $val)
00376                 {
00377                         $this->error_string .= $this->_error_prefix.$val.$this->_error_suffix."\n";
00378                 }
00379 
00380                 return FALSE;
00381         }

Here is the call graph for this function:

CI_Validation::set_checkbox	(	$	field = `''`,
		$	value = `''`
	)

Set Checkbox.

Enables checkboxes to be set to the value the user selected in the event of an error

public

Parameters:

	string
	string

Returns:: string

Definition at line 759 of file Validation.php.

00760         {
00761                 if ($field == '' OR $value == '' OR  ! isset($_POST[$field]))
00762                 {
00763                         return '';
00764                 }
00765                         
00766                 if ($_POST[$field] == $value)
00767                 {
00768                         return ' checked="checked"';
00769                 }
00770         }

CI_Validation::set_error_delimiters	(	$	prefix = `'<p>'`,
		$	suffix = `'</p>'`
	)

Set The Error Delimiter.

Permits a prefix/suffix to be added to each error message

public

Parameters:

	string
	string

Returns:: void

Definition at line 170 of file Validation.php.

00171         {
00172                 $this->_error_prefix = $prefix;
00173                 $this->_error_suffix = $suffix;
00174         }

CI_Validation::set_fields	(	$	data = `''`,
		$	field = `''`
	)

Set Fields.

This function takes an array of field names as input and generates class variables with the same name, which will either be blank or contain the $_POST value corresponding to it

public

Parameters:

	string
	string

Returns:: void

Definition at line 72 of file Validation.php.

References prep_for_form().

Referenced by run().

00073         {       
00074                 if ($data == '')
00075                 {
00076                         if (count($this->_fields) == 0)
00077                         {
00078                                 return FALSE;
00079                         }
00080                 }
00081                 else
00082                 {
00083                         if ( ! is_array($data))
00084                         {
00085                                 $data = array($data => $field);
00086                         }
00087                         
00088                         if (count($data) > 0)
00089                         {
00090                                 $this->_fields = $data;
00091                         }
00092                 }               
00093                         
00094                 foreach($this->_fields as $key => $val)
00095                 {
00096                         $this->$key = ( ! isset($_POST[$key])) ? '' : $this->prep_for_form($_POST[$key]);
00097                         
00098                         $error = $key.'_error';
00099                         if ( ! isset($this->$error))
00100                         {
00101                                 $this->$error = '';
00102                         }
00103                 }               
00104         }

Here is the call graph for this function:

Here is the caller graph for this function:

CI_Validation::set_message	(	$	lang,
		$	val = `''`
	)

Set Error Message.

Lets users set their own error messages on the fly. Note: The key name has to match the function name that it corresponds to.

public

Parameters:

	string
	string

Returns:: string

Definition at line 148 of file Validation.php.

References $lang.

00149         {
00150                 if ( ! is_array($lang))
00151                 {
00152                         $lang = array($lang => $val);
00153                 }
00154         
00155                 $this->_error_messages = array_merge($this->_error_messages, $lang);
00156         }

CI_Validation::set_radio	(	$	field = `''`,
		$	value = `''`
	)

Set Radio.

Enables radio buttons to be set to the value the user selected in the event of an error

public

Parameters:

	string
	string

Returns:: string

Definition at line 733 of file Validation.php.

00734         {
00735                 if ($field == '' OR $value == '' OR  ! isset($_POST[$field]))
00736                 {
00737                         return '';
00738                 }
00739                         
00740                 if ($_POST[$field] == $value)
00741                 {
00742                         return ' checked="checked"';
00743                 }
00744         }

CI_Validation::set_rules	(	$	data,
		$	rules = `''`
	)

Set Rules.

This function takes an array of field names and validation rules as input ad simply stores is for use later.

public

Parameters:

	mixed
	string

Returns:: void

Definition at line 119 of file Validation.php.

00120         {
00121                 if ( ! is_array($data))
00122                 {
00123                         if ($rules == '')
00124                                 return;
00125                                 
00126                         $data = array($data => $rules);
00127                 }
00128         
00129                 foreach ($data as $key => $val)
00130                 {
00131                         $this->_rules[$key] = $val;
00132                 }
00133         }

CI_Validation::set_select	(	$	field = `''`,
		$	value = `''`
	)

Set Select.

Enables pull-down lists to be set to the value the user selected in the event of an error

public

Parameters:

	string
	string

Returns:: string

Definition at line 707 of file Validation.php.

00708         {
00709                 if ($field == '' OR $value == '' OR  ! isset($_POST[$field]))
00710                 {
00711                         return '';
00712                 }
00713                         
00714                 if ($_POST[$field] == $value)
00715                 {
00716                         return ' selected="selected"';
00717                 }
00718         }

CI_Validation::strip_image_tags ( $ str )

Strip Image Tags.

public

Parameters:

string

Returns:: string

Definition at line 838 of file Validation.php.

00839         {
00840                 $_POST[$this->_current_field] = $this->CI->input->strip_image_tags($str);
00841         }

CI_Validation::valid_base64 ( $ str )

Valid Base64.

Tests a string for characters outside of the Base64 alphabet as defined by RFC 2045 http://www.faqs.org/rfcs/rfc2045

public

Parameters:

string

Returns:: bool

Definition at line 689 of file Validation.php.

00690         {
00691                 return (bool) ! preg_match('/[^a-zA-Z0-9\/\+=]/', $str);
00692         }

CI_Validation::valid_email ( $ str )

Valid Email.

public

Parameters:

string

Returns:: bool

Definition at line 508 of file Validation.php.

Referenced by valid_emails().

00509         {
00510                 return ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $str)) ? FALSE : TRUE;
00511         }

Here is the caller graph for this function:

CI_Validation::valid_emails ( $ str )

Valid Emails.

public

Parameters:

string

Returns:: bool

Definition at line 522 of file Validation.php.

References valid_email().

00523         {
00524                 if (strpos($str, ',') === FALSE)
00525                 {
00526                         return $this->valid_email(trim($str));
00527                 }
00528                 
00529                 foreach(explode(',', $str) as $email)
00530                 {
00531                         if (trim($email) != '' && $this->valid_email(trim($email)) === FALSE)
00532                         {
00533                                 return FALSE;
00534                         }
00535                 }
00536                 
00537                 return TRUE;
00538         }

Here is the call graph for this function:

CI_Validation::valid_ip ( $ ip )

Validate IP Address.

public

Parameters:

string

Returns:: string

Definition at line 549 of file Validation.php.

00550         {
00551                 return $this->CI->input->valid_ip($ip);
00552         }

CI_Validation::xss_clean ( $ str )

XSS Clean.

public

Parameters:

string

Returns:: string

Definition at line 852 of file Validation.php.

00853         {
00854                 $_POST[$this->_current_field] = $this->CI->input->xss_clean($str);
00855         }

Member Data Documentation

CI_Validation::$_current_field = ''

Definition at line 35 of file Validation.php.

CI_Validation::$_error_array = array()

Definition at line 31 of file Validation.php.

CI_Validation::$_error_messages = array()

Definition at line 34 of file Validation.php.

CI_Validation::$_error_prefix = '<p>'

Definition at line 37 of file Validation.php.

CI_Validation::$_error_suffix = '</p>'

Definition at line 38 of file Validation.php.

CI_Validation::$_fields = array()

Definition at line 33 of file Validation.php.

CI_Validation::$_rules = array()

Definition at line 32 of file Validation.php.

CI_Validation::$_safe_form_data = FALSE

Definition at line 36 of file Validation.php.

CI_Validation::$CI

Definition at line 29 of file Validation.php.

CI_Validation::$error_string = ''

Definition at line 30 of file Validation.php.

The documentation for this class was generated from the following file:

Validation.php

CI_Validation Class Reference

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation