<?php
/**
* FormChecker package
* @author Johan Barbier <johan.barbier@gmail.com>
* @version 20070104
*
*/
/**
* Messages classes
* must be named this way : formCheckerMessagesXXX
* where XXX is the alpha 3 country code
*/
/**
* class formCheckerMessagesENG
* English localization of the messages
*
*/
class formCheckerMessagesENG {
const EMAIL_INVALID = 'The email address is invalid';
const URL_INVALID = 'The URL is invalid';
const REGEXP_FOUND_NOT_MATCH = 'Input {__INPUT__} does not match given regexp pattern';
const USER_FUNC_RETURNED_FALSE = 'User function {__FUNC__} returned false for {__INPUT__}';
const INPUT_EMPTY = 'You must fill in your {__INPUT__}';
const INPUT_NOT_IN_MIN_LENGTH = 'Your {__INPUT__} must et least have {__MIN_LENGTH__} characters';
const INPUT_NOT_IN_MAX_LENGTH = 'Your {__INPUT__} must at most have {__MAX_LENGTH__} characters';
const INPUT_NOT_IN_STRICT_LENGTH = 'Your {__INPUT__} must have {__STRICT_LENGTH__} characters';
const INPUT_STARTS_WITH = 'Your {__INPUT__} must start with {__START__}';
const INPUT_DONOT_START_WITH = 'Your {__INPUT__} must not start with {__START__}';
const INPUT_FORBIDDEN = 'these input are forbidden : {__FORBIDDEN__}';
const NUMERIC_NOT_NUMERIC = 'Your {__NUMERIC__} must be numeric';
const NUMERIC_NOT_IN_MIN_RANGE = 'Your {__NUMERIC__} must be greater than {__MIN_RANGE__}';
const NUMERIC_NOT_IN_MAX_RANGE = 'Your {__NUMERIC__} must be lesser than {__MAX_RANGE__}';
}
/**
* class formCheckerMessagesFRA
* French localization of the messages
*
*/
class formCheckerMessagesFRA {
const EMAIL_INVALID = 'L\'adresse email saisie est invalide';
const URL_INVALID = 'L\'URL est invalide';
const REGEXP_FOUND_NOT_MATCH = 'Le motif d\'expression régulière n\'a pas été trouvé dans {__INPUT__}';
const USER_FUNC_RETURNED_FALSE = 'La fonction utilisateur {__FUNC__} a retourné false pour {__INPUT__}';
const INPUT_EMPTY = 'Vous devez saisir votre {__INPUT__}';
const INPUT_NOT_IN_MIN_LENGTH = 'Votre {__INPUT__} doit contenir au moins {__MIN_LENGTH__} caractères';
const INPUT_NOT_IN_MAX_LENGTH = 'Votre {__INPUT__} doit contenir au plus {__MAX_LENGTH__} caractères';
const INPUT_NOT_IN_STRICT_LENGTH = 'Votre {__INPUT__} doit être composé de {__STRICT_LENGTH__} caractères';
const INPUT_STARTS_WITH = 'Votre {__INPUT__} doit commencer par {__START__}';
const INPUT_DONOT_START_WITH = 'Votre {__INPUT__} ne doit pas commencer par {__START__}';
const INPUT_FORBIDDEN = 'Ces entrées sont interdites : {__FORBIDDEN__}';
const NUMERIC_NOT_NUMERIC = 'Votre {__NUMERIC__} doit être composé de chiffres';
const NUMERIC_NOT_IN_MIN_RANGE = 'Votre {__NUMERIC__} doit être supérieur à {__MIN_RANGE__}';
const NUMERIC_NOT_IN_MAX_RANGE = 'Votre {__NUMERIC__} doit être inférieur à {__MAX_RANGE__}';
}
/**
* class formCheckerException extends Exception
* Specialized exceptions class
*
*/
class formCheckerException extends Exception {
const CLASS_NOT_EXISTS = 'Invalid pattern';
const CLASS_LOC_NOT_EXISTS = 'Invalid localization class';
const FILTER_MUST_BE_INT = 'Filter must be an integer';
const FILTER_NOT_ARRAY = 'Filter must be an array';
const NO_REGEXP = 'Regexp filter needs a regexp option';
const BAD_REGEXP = 'Bad regexp pattern';
const NO_USER_FUNC = 'No user function filter given';
const USER_FUNC_PARAMS_NO_ARRAY = 'User function parameters filter must be an array';
const SANITIZE_NO_USER_FUNC = 'No user function given to the sanitizer';
const SANITIZE_USER_FUNC_NOT_EXISTS = 'User function given to the sanitizer has not been found';
const SANITIZE_USER_FUNC_PARAMS_NOT_ARRAY = 'User function parameters given to the sanitizer must be an array';
}
/**
* class formCheckerMessages
* The factory chosing correct messages localization class
*
*/
class formCheckerMessages {
/**
* public static function factory
* factory building the correct localized formCheckerMessages class through a ReflectionClass object
*
* @param string $loc : country alpha 3 code
* @return ReflectionClass object
*/
public static function factory ($loc) {
if (false === class_exists ('formCheckerMessages'.$loc)) {
throw new formCheckerException (formCheckerException::CLASS_LOC_NOT_EXISTS);
}
$sClass = 'formCheckerMessages'.$loc;
return new ReflectionClass ($sClass);
}
}
/**
* abstract class validateGen
* the parent of all validateZZZ classes
* defines common methods and properties
*
*/
abstract class validateGen {
/**
* protected sName
* user defined name given to the input (used for the messages)
*
* @var string
*/
protected $sName = null;
/**
* protected static sLocClass
* used to store a ReflectionClass object pointing on the messages localization class
*
* @var ReflectionClass
*/
protected static $sLocClass = null;
/**
* private static sLoc
* used to store current localization code and check if there is any change
*
* @var string
*/
private static $sLoc = null;
/**
* private function isEmpty
* test if a given input is empty or not
*
* @param string $mString : the input
* @param boolean $bMandatory : is the input mandatory or not (if not, it can be empty)
* @return boolean true if not empty, false if empty AND mandatory, -1 if empty AND NOT mandatory
*/
private function isEmpty ($mString, $bMandatory) {
if (empty ($mString)) {
if (true === $bMandatory) {
throw new formCheckerException (str_replace ('{__INPUT__}', $this -> sName, self::$sLocClass -> getConstant('INPUT_EMPTY')));
}
return -1;
}
return true;
}
/**
* protected static function isInt
* checks if the given parameter is an integer
*
* @param int $iNum
* @return boolean tue if $iNum is an integer (throw an exception if not)
*/
protected static function isInt ($iNum) {
if (!is_int ($iNum)) {
throw new formCheckerException (formCheckerException::FILTER_MUST_BE_INT);
}
return true;
}
/**
* private function assign
* just assigns properties and instanciate the ReflectionClass via the formCheckerMessages::factory () method
*
* @param string $sName : name given to the input
* @param string $loc : country alpha 3 code
*/
private function assign ($sName, $loc) {
$this -> sName = $sName;
if ($loc !== self::$sLoc) {
self::$sLoc = $loc;
self::$sLocClass = formCheckerMessages::factory ($loc);
}
}
/**
* protected static function validateMinLength
* checks if the input length matches the minimum required length
*
* @param string $mString : the input
* @param string $sName : user defined name for the data
* @param int $iMinLength : minimum length
* @return boolean true if the input length is greater or equal to the minimum length, false if not
*/
protected static function validateMinLength($mString, $sName, $iMinLength) {
if (true === self::isInt ($iMinLength)) {
if (strlen ($mString) < $iMinLength) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__MIN_LENGTH__}'), array ($sName, $iMinLength), self::$sLocClass -> getConstant ('INPUT_NOT_IN_MIN_LENGTH')));
}
return true;
}
return false;
}
/**
* protected static function validateMaxLength
* checks if the input length matches the maximum required length
*
* @param string $mString : the input
* @param string $sName : user defined name for the data
* @param int $iMaxLength : maximum length
* @return boolean true if the input length is lesser or equal to the maximum length, false if not
*/
protected static function validateMaxLength($mString, $sName, $iMaxLength) {
if (true === self::isInt ($iMaxLength)) {
if (strlen ($mString) > $iMaxLength) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__MAX_LENGTH__}'), array ($sName, $iMaxLength), self::$sLocClass -> getConstant ('INPUT_NOT_IN_MAX_LENGTH')));
}
return true;
}
return false;
}
/**
* protected static function validateStrictLength
* checks if the input has the mandatory strict length
*
* @param string $mString : the input
* @param string $sName : user defined name for the data
* @param int $iStrictLength : strict length
* @return boolean true if the input length is equal to the mandaotry strict length, false if not
*/
protected static function validateStrictLength($mString, $sName, $iStrictLength) {
if (true === self::isInt ($iStrictLength)) {
if (strlen ($mString) !== $iStrictLength) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__STRICT_LENGTH__}'), array ($sName, $iStrictLength), self::$sLocClass -> getConstant ('INPUT_NOT_IN_STRICT_LENGTH')));
}
return true;
}
return false;
}
/**
* protected static function validateStartsWith
* checks if the input starts with each values in a given array
*
* @param string $mString : the input
* @param string $sName : user defined name for the data
* @param array $aStarts : array of values
* @return boolean true if the input starts with at least one of the values, false if not.
*/
protected static function validateStartsWith ($mString, $sName, $aStarts) {
$bRes = false;
if (!is_array ($aStarts)) {
throw new formCheckerException (formCheckerException::FILTER_NOT_ARRAY);
}
foreach ($aStarts as $mVal) {
if (substr ($mString, 0, strlen ($mVal)) === $mVal) {
$bRes = true;
}
}
if (false === $bRes) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__START__}'), array ($sName, implode (',', $aStarts)), self::$sLocClass -> getConstant ('INPUT_STARTS_WITH')));
}
return $bRes;
}
/**
* protected static function validateStartsWith
* checks if the input does not start with each values in a given array
*
* @param string $mString : the input
* @param string $sName : user defined name for the data
* @param array $aStarts : array of values
* @return boolean false if the input starts with at least one of the values, true if not.
*/
protected static function validateStartsWithout ($mString, $sName, $aStarts) {
$bRes = true;
if (!is_array ($aStarts)) {
throw new formCheckerException (formCheckerException::FILTER_NOT_ARRAY);
}
foreach ($aStarts as $mVal) {
if (substr ($mString, 0, strlen ($mVal)) === $mVal) {
$bRes = false;
break;
}
}
if (false === $bRes) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__START__}'), array ($sName, implode (',', $aStarts)), self::$sLocClass -> getConstant ('INPUT_DONOT_START_WITH')));
}
return $bRes;
}
/**
* protected static function hasForbidden
* checks if the input is equal to one of the forbidden values
*
* @param string $mString : the input
* @param string or array $mForbidden : string or array of forbidden values
* @return boolean false if the input is equal to one of the forbidden values, true if not
*/
protected static function hasForbidden ($mString, $mForbidden) {
if (is_array ($mForbidden)) {
if (in_array ($mString, $mForbidden)) {
throw new formCheckerException (str_replace ('{__FORBIDDEN__}', $mForbidden[array_search($mString, $mForbidden)], self::$sLocClass -> getConstant ('INPUT_FORBIDDEN')));
}
} else {
if ($mForbidden === $mString) {
throw new formCheckerException (str_replace ('{__FORBIDDEN__}',$mForbidden, self::$sLocClass -> getConstant ('INPUT_FORBIDDEN')));
}
}
return true;
}
/**
* protected static function hasAllowed
* checks if the input is equal to one of the allowed (and mandatory) values
*
* @param string $mString : the input
* @param string or array $mForbidden : string or array of forbidden values
* @return boolean false if the input is equal to one of the forbidden values, true if not
*/
protected static function hasAllowed ($mString, $mAllowed) {
if (is_array ($mAllowed)) {
if (!in_array ($mString, $mAllowed)) {
throw new formCheckerException (self::$sLocClass -> getConstant ('INPUT_ALLOWED'));
}
} else {
if ($mAllowed !== $mString) {
throw new formCheckerException (self::$sLocClass -> getConstant ('INPUT_ALLOWED'));
}
}
return true;
}
/**
* protected function validate
* validation method, calls the required check methods
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not, -1 if input is empty
*/
protected function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
$this -> assign ($sName, $loc);
if (false === ($bRes = $this -> isEmpty ($mString, $bMandatory))) {
return false;
} elseif (true === $bRes) {
if (isset ($aOptions['forbidden'])) {
if (false === self::hasForbidden ($mString, $aOptions['forbidden'])) {
return false;
}
}
if (isset ($aOptions['allowed'])) {
if (false === self::hasAllowed ($mString, $aOptions['allowed'])) {
return false;
}
}
if (isset ($aOptions['min_length']) && is_int ($aOptions['min_length'])) {
if (false === self::validateMinLength ($mString, $this -> sName, $aOptions['min_length'])) {
return false;
}
}
if (isset ($aOptions['max_length']) && is_int ($aOptions['max_length'])) {
if (false === self::validateMaxLength ($mString, $this -> sName, $aOptions['max_length'])) {
return false;
}
}
if (isset ($aOptions['strict_length']) && is_int ($aOptions['strict_length'])) {
if (false === self::validateStrictLength ($mString, $this -> sName, $aOptions['strict_length'])) {
return false;
}
}
if (isset ($aOptions['starting_with'])) {
if (false === self::validateStartsWith ($mString, $this -> sName, $aOptions['starting_with'])) {
return false;
}
}
if (isset ($aOptions['not_starting_with'])) {
if (false === self::validateStartsWithout ($mString, $this -> sName, $aOptions['not_starting_with'])) {
return false;
}
}
} else {
return -1;
}
return true;
}
}
/**
* class validateText extends validateGen
* basic text checker class
*
*/
class validateText extends validateGen {
/**
* protected function validate
* validation method, calls the required check methods and prior to them, calls parent validate method
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory)) {
return false;
}
return true;
}
}
/**
* class validateEmail extends validateGen
* emails checker class
*
*/
class validateEmail extends validateGen {
/**
* protected function validate
* validation method, checks if the input is an email and prior to it, calls parent validate method
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === ($bRes = parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory))) {
return false;
} elseif (true === $bRes){
if (!preg_match ('`^[[:alnum:]]([-_.]?[[:alnum:]])*@[[:alnum:]]([-.]?[[:alnum:]])*\.([a-z]{2,4})$`', $mString)) {
throw new formCheckerException (self::$sLocClass -> getConstant ('EMAIL_INVALID'));
}
}
return true;
}
}
/**
* class validateUrl extends validateGen
* url checker class
*
*/
class validateUrl extends validateGen {
/**
* protected function validate
* validation method, checks if the input is an url and prior to it, calls parent validate method
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === ($bRes = parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory))) {
return false;
} elseif (true === $bRes){
if (!preg_match ('`((?:https?|ftp)://\S+[[:alnum:]]/?)`si', $mString) && !preg_match ('`((?<!//)(www\.\S+[[:alnum:]]/?))`si', $mString)) {
throw new formCheckerException (self::$sLocClass -> getConstant ('URL_INVALID'));
}
}
return true;
}
}
/**
* class validateRegExp extends validateGen
* user defined regexp checker class
*
*/
class validateRegExp extends validateGen {
/**
* protected function validate
* validation method, checks if the input matches the user defined regexp and prior to it, calls parent validate method
* needs a mandaotory option at least : $aOptions['regexp'] = user defined regexp pattern
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === ($bRes = parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory))) {
return false;
} elseif (true === $bRes){
if (!isset ($aOptions['regexp'])) {
throw new formCheckerException (formCheckerException::NO_REGEXP);
}
$bReg = @preg_match ($aOptions['regexp'], $mString);
if ((function_exists ('preg_last_error') && @preg_last_error() !== PREG_NO_ERROR) || false === $bReg) {
throw new formCheckerException (formCheckerException::BAD_REGEXP);
} elseif (0 === $bReg) {
throw new formCheckerException (str_replace ('{__INPUT__}', $this -> sName, self::$sLocClass -> getConstant ('REGEXP_FOUND_NOT_MATCH')));
}
}
return true;
}
}
/**
* class validateUserFunc extends validateGen
* user defined function checker class
*
*/
class validateUserFunc extends validateGen {
/**
* protected function validate
* validation method, checks if the input matches the user defined function and prior to it, calls parent validate method
* needs a mandatory option at least : $aOptions['user_func'] = name of the user function
* you can add parameters via the optional option $aOptions['user_func_params']. This must be an array with all the parameters.
* Please note the method will add at the end of the array of options the input $mString.
* So, your user function MUST implements at least 1 parameter (the input), and if there are others, the input parameter MUST be the last parameter
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === ($bRes = parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory))) {
return false;
} elseif (true === $bRes){
if (!isset ($aOptions['user_func'])) {
throw new formCheckerException (formCheckerException::NO_USER_FUNC);
}
if (isset ($aOptions['user_func_params']) && !is_array ($aOptions['user_func_params'])) {
throw new formCheckerException (formCheckerException::USER_FUNC_PARAMS_NO_ARRAY);
}
$aOptions['user_func_params'][] = $mString;
$bFunc = call_user_func_array ($aOptions['user_func'], $aOptions['user_func_params']);
if (false === $bFunc) {
throw new formCheckerException (str_replace (array ('{__INPUT__}', '{__FUNC__}'), array ($this -> sName, $aOptions['user_func']), self::$sLocClass -> getConstant ('USER_FUNC_RETURNED_FALSE')));
}
}
return true;
}
}
/**
* class validateInt extends validateGen
* integer checker class
*
*/
class validateInt extends validateGen {
/**
* protected function validate
* validation method, checks some specific numeric requirements and prior to them, calls parent validate method
*
* @param string $mString : the input
* @param string $sName : user defined name given to the input
* @param string $loc : country alpha 3 code
* @param array $aOptions : null if no option, array of options
* @param boolean $bMandatory : true if the input is mandaotry, false if not
* @return boolean true if the input successfully meets all the requirements, false if not
*/
public function validate ($mString, $sName, $loc, $aOptions, $bMandatory) {
if (false === ($bRes = parent::validate ($mString, $sName, $loc, $aOptions, $bMandatory))) {
return false;
} elseif (true === $bRes) {
if (false === ctype_digit ($mString)) {
throw new formCheckerException (str_replace ('{__NUMERIC__}', $this -> sName, self::$sLocClass -> getConstant ('NUMERIC_NOT_NUMERIC')));
}
if (isset ($aOptions['min_range'])) {
if (false === $this -> validateMinRange ($mString, $aOptions['min_range'])) {
return false;
}
}
if (isset ($aOptions['max_range'])) {
if (false === $this -> validateMaxRange ($mString, $aOptions['max_range'])) {
return false;
}
}
}
return true;
}
/**
* private function validateMinRange
* checks if the numeric input is greater or equal than the minimum range
*
* @param string $mString : the input
* @param int $iMinRange : minimum range
* @return boolean if the input is greater or equal than the minimum range, false if not
*/
private function validateMinRange ($mString, $iMinRange) {
if (true === parent::isInt ($iMinRange)) {
if ($mString < $iMinRange) {
throw new formCheckerException (str_replace (array ('{__NUMERIC__}', '{__MIN_RANGE__}'), array ($this -> sName, $iMinRange), self::$sLocClass -> getConstant ('NUMERIC_NOT_IN_MIN_RANGE')));
}
return true;
}
return false;
}
/**
* private function validateMaxRange
* checks if the numeric input is lesser or equal than the maximum range
*
* @param string $mString : the input
* @param int $iMaxRange : maximum range
* @return boolean if the input is lesser or equal than the maximum range, false if not
*/
private function validateMaxRange ($mString, $iMaxRange) {
if (true === parent::isInt ($iMaxRange)) {
if ($mString > $iMaxRange) {
throw new formCheckerException (str_replace (array ('{__NUMERIC__}', '{__MAX_RANGE__}'), array ($this -> sName, $iMaxRange), self::$sLocClass -> getConstant ('NUMERIC_NOT_IN_MAX_RANGE')));
}
return true;
}
return false;
}
}
/**
* class formChecker
* only class to be called
* uses ReflectionClass to call the correct validateZZZ class
*
*/
class formChecker {
/**
* constants defining the allowed validation classes
*
*/
const VALIDATE_EMAIL = 'validateEmail';
const VALIDATE_INT = 'validateInt';
const VALIDATE_TEXT = 'validateText';
const VALIDATE_URL = 'validateUrl';
const VALIDATE_REGEXP = 'validateRegExp';
const VALIDATE_USER_FUNC = 'validateUserFunc';
/**
* public static aMsg
* static property storing the messages returned by the validateZZZ classes (error messages)
* key is the user defined name for the input, value being the error message
*
* @var array
*/
public static $aMsg = null;
/**
* private bValid
* true if the form (all the input validated) is ok, false if there is at least one error among all the validation
*
* @var boolean
*/
private $bValid = true;
/**
* private loc
* localization property, country alpha 3 code
*
* @var string
*/
private $loc = null;
/**
* public function __construct
* constructor, sets some properties : localization, and reset aMsg array of error messages
*
* @param string $loc
*/
public function __construct ($loc = 'FRA') {
self::$aMsg = null;
$this -> loc = $loc;
}
/**
* public function validate
* call the validation type required, via ReflectionClass
* sets the formChecker::bValid property to false if any error is detected on an input
*
* @param string $mString : the input
* @param string $sName : user defined name for the input
* @param formChecker constant $cPattern : the validation type to be applied to this input
* @param array $aOptions : null if not options, array of options on the other hand. default to null
* @param boolean $bMandatory : true if the input must not be empty, false if not. default to true
* @return unknown
*/
public function validate ($mString, $sName, $cPattern, $aOptions = null, $bMandatory = true) {
if (false === class_exists ($cPattern)) {
throw new Exception (formCheckerException::CLASS_NOT_EXISTS);
}
$oReflect = new ReflectionClass($cPattern);
$o = $oReflect -> newInstance ();
try {
$bRes = $o -> validate ($mString, $sName, $this -> loc, $aOptions, $bMandatory);
} catch (Exception $e) {
self::$aMsg[$sName] = $e -> getMessage ();
$bRes = $this -> bValid = false;
}
return $bRes;
}
/**
* public function sanitizeStr
* sanitize a string, given an array of options :
* addslashes => adds slashes...(default)
* htmlentities => encode html entities (default)
* urlencode => encode as en url
* trim => apply a trim
* mssqlEscape => escape quotes for mssql
*
* @param string $mString : the input
* @param array $aOptions : array of options
* @return string
*/
public function sanitizeStr ($mString, $aOptions = array ('addslashes', 'htmlentities')) {
if (in_array ('addslashes', $aOptions)) {
$mString = addslashes ($mString);
}
if (in_array ('htmlentities', $aOptions)) {
$mString = htmlentities ($mString);
}
if (in_array ('urlencode', $aOptions)) {
$mString = urlencode ($mString);
}
if (in_array ('trim', $aOptions)) {
$mString = trim ($mString);
}
if (in_array ('mssqlEscape', $aOptions)) {
$mString = str_replace ("'", "''", $mString);
}
return $mString;
}
/**
* public function sanitizeInt
* sanitize a variable (input, so should be a string) as an integer, given an array of options :
* onlyInt => extract onnly the integer values in the variable
*
* @param string $mString : the input
* @param array $aOptions : array of options :
* onlyInt => retrieve only integer characters
* @return string
*/
public function sanitizeInt ($mString, $aOptions = array ('onlyInt')) {
if (in_array ('onlyInt', $aOptions)) {
preg_match_all ('@([\d]+)+@', $mString, $aRes);
if (!empty ($aRes[0])) {
$mString = implode ($aRes[0]);
} else {
$mString = '';
}
}
return $mString;
}
/**
* public function sanitizeUserFunc
* sanitize a variable (input, so should be a string) as an integer, given a user function.
* Same rule as the formChecker::VALIDATE_USER_FUNC pattern : the user defined function MUST have at least one parameters which is the input.
* If there are more parameters, the input MUST be the last parameter.
*
* @param string $mString : the input
* @param array $aOptions : array of options
* @return string
*/
public function sanitizeUserFunc ($mString, $aOptions = array ('user_func' => '', 'user_func_params' => array ())) {
if (!isset ($aOptions['user_func'])) {
throw new formCheckerException (formCheckerException::SANITIZE_NO_USER_FUNC);
}
if (!function_exists ($aOptions['user_func'])) {
throw new formCheckerException (formCheckerException::SANITIZE_USER_FUNC_NOT_EXISTS);
}
if (isset ($aOptions['user_func_params']) && !is_array ($aOptions['user_func_params'])) {
throw new formCheckerException (formCheckerException::SANITIZE_USER_FUNC_PARAMS_NOT_ARRAY);
}
$aOptions['user_func_params'][] = $mString;
$mString = call_user_func_array ($aOptions['user_func'], $aOptions['user_func_params']);
return $mString;
}
/**
* public function isValid
* returns formChecker::bValid property
* it will be set to true if every input successfully passed the validation, false if one of them failed
*
* @return unknown
*/
public function isValid () {
return $this -> bValid;
}
}
/**
* Example
*/
/**
* declarations.
* of course, should be user input values like POST or GET
*/
$sEmail = 'moi@moi.com';
$sCp = '00345';
$sNom ='';
$sPrenom = '';
$sTel = '04-23-45-67-89';
$sUrl = 'http://monsite.com';
$sToBeSanitized = 'must be uppercase';
/**
* some user defined function to be used for the formchecker::VALIDATE_USER_FUNC pattern
*/
function myFunc ($sNeedle, $sHaystack) {
if (false !== strpos ($sHaystack, $sNeedle)) {
return true;
}
return false;
}
/**
* some user defined function to be used for the formchecker::sanitizeUserFunc method
*/
function mySanitizer ($mString) {
return strtoupper ($mString);
}
/**
* French test
*/
try {
/**
* instanciation of the formChecker
*/
$iStart = microtime (true);
$oChecker = new formChecker;
/**
* just to show sanitization : we remove the '-' from the phone number
*/
$sSanitizedTel = $oChecker -> sanitizeInt ($sTel);
/**
* just to show sanitization via user defined function : we just return the uppercase version of the string
*/
$sToBeSanitized = $oChecker -> sanitizeUserFunc ($sToBeSanitized, array ('user_func' => 'mySanitizer'));
echo '<br />SANITIZED : ', $sToBeSanitized, '<br />';
/**
* some validations
*/
/**
* using the email validation, and we forbid the use of the 'moi@moi.com'
*/
if (false === $oChecker -> validate ($sEmail, 'email', formChecker::VALIDATE_EMAIL, array ('forbidden' => 'moi@moi.com'))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the integer validation : the French zip code should broadly be only integers, strictly 5 in length, and cannot start with 00
*/
if (false === $oChecker -> validate ($sCp, 'code postal', formChecker::VALIDATE_INT, array ('strict_length' => 5, 'not_starting_with' => array ('00')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the basic text validation, nothing special except that the input must not be empty (default valus is true for the mandatory parameter)
*/
if (false === $oChecker -> validate ($sNom, 'nom', formChecker::VALIDATE_TEXT)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using again the basic text validation, but the first name is not mandatory (see the last parameter : false); note that mandatory being the last parameter, and
* as we do not need any option, wu must pass a null value instead of the array of options
*/
if (false === $oChecker -> validate ($sPrenom, 'prénom', formChecker::VALIDATE_TEXT, null, false)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the integer validation for the sanitized phone number. Broadly, the French phone number should be 10 cahracters long, only integers (that's why we sanitied it),
* and should start with 01, 02, 03, 04, 05, 06 or 08
*/
if (false === $oChecker -> validate ($sSanitizedTel, 'telephone', formChecker::VALIDATE_INT, array ('strict_length' => 10, 'starting_with' => array ('01', '02', '03', '04', '05', '06', '08')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the URL validation
*/
if (false === $oChecker -> validate ($sUrl, 'url', formChecker::VALIDATE_URL)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the regexp validation (ok, my regexp is stupid...)
*/
if (false === $oChecker -> validate ($sUrl, 'url2', formChecker::VALIDATE_REGEXP, array ('regexp' => '@(doli)@'))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* using the user function validation (ok, my function is stupid...again!)
* here, my function will check if the string 'da' is in the email string ('moi@moi.com'). It is not, obviously.
*/
if (false === $oChecker -> validate ($sEmail, 'url3', formChecker::VALIDATE_USER_FUNC, array ('user_func' => 'myFunc', 'user_func_params' => array ('da')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
/**
* if there is any error, formchecker::isValid () returns false, else it returns true.
* If false, we check the error messages.
*/
if (false === $oChecker -> isValid ()) {
echo '<pre>',print_r (formChecker::$aMsg), '</pre>';
}
$iStop = microtime (true);
echo '<p>ELAPSED : ',$iStop - $iStart,'</p>';
} catch (Exception $e) {
echo $e -> getMessage ();
}
/**
* English test (same explanations as for the French one)
*/
try {
$oChecker = new formChecker ('ENG');
$sSanitizedTel = $oChecker -> sanitizeInt ($sTel);
if (false === $oChecker -> validate ($sEmail, 'email', formChecker::VALIDATE_EMAIL, array ('forbidden' => 'moi@moi.com'))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sCp, 'zip code', formChecker::VALIDATE_INT, array ('strict_length' => 5, 'not_starting_with' => array ('00')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sNom, 'last name', formChecker::VALIDATE_TEXT)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sPrenom, 'first name', formChecker::VALIDATE_TEXT, null, false)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sSanitizedTel, 'phone number', formChecker::VALIDATE_INT, array ('strict_length' => 10, 'starting_with' => array ('01', '02', '03', '04', '05', '06', '08')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sUrl, 'url', formChecker::VALIDATE_URL)) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sUrl, 'url2', formChecker::VALIDATE_REGEXP, array ('regexp' => '@(doli)@'))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> validate ($sEmail, 'url3', formChecker::VALIDATE_USER_FUNC, array ('user_func' => 'myFunc', 'user_func_params' => array ('da')))) {
echo 'FALSE<br />';
} else {
echo 'OK<br />';
}
if (false === $oChecker -> isValid ()) {
echo '<pre>',print_r (formChecker::$aMsg), '</pre>';
}
} catch (Exception $e) {
echo $e -> getMessage ();
}
?>
|
Download
