/**
* 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 sLocClass
* used to store a ReflectionClass object pointing on the messages localization class
*
* @var ReflectionClass
*/
protected $sLocClass = null;
/**
* protected 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
*/
protected function isEmpty ($mString, $bMandatory) {
if (empty ($mString)) {
if (true === $bMandatory) {
formChecker::$aMsg[$this -> sName] = str_replace ('{__INPUT__}', $this
-> sName, $this -> sLocClass -> getConstant ('INPUT_EMPTY'));
return false;
}
return -1;
}
return true;
}
/**
* protected 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
*/
protected function assign ($sName, $loc) {
$this -> sName = $sName;
$this -> sLocClass = formCheckerMessages::factory ($loc);
}
/**
* protected function validateMinLength
* checks if the input length matches the minimum required length
*
* @param string $mString : the input
* @param int $iMinLength : minimum length
* @return boolean true if the input length is greater or equal to the minimum length, false if not
*/
protected function validateMinLength($mString, $iMinLength) {
if (true === $this -> isInt ($iMinLength)) {
if (strlen ($mString) < $iMinLength) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}', '{__MIN_LENGTH__}'), array ($this -> sName, $iMinLength), $this -> sLocClass
-> getConstant ('INPUT_NOT_IN_MIN_LENGTH'));
return false;
}
return true;
}
return false;
}
/**
* protected function validateMaxLength
* checks if the input length matches the maximum required length
*
* @param string $mString : the input
* @param int $iMaxLength : maximum length
* @return boolean true if the input length is lesser or equal to the maximum length, false if not
*/
protected function validateMaxLength($mString, $iMaxLength) {
if (true === $this -> isInt ($iMaxLength)) {
if (strlen ($mString) > $iMaxLength) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}', '{__MAX_LENGTH__}'), array ($this -> sName, $iMaxLength), $this -> sLocClass
-> getConstant ('INPUT_NOT_IN_MAX_LENGTH'));
return false;
}
return true;
}
return false;
}
/**
* protected function validateStrictLength
* checks if the input has the mandatory strict length
*
* @param string $mString : the input
* @param int $iStrictLength : strict length
* @return boolean true if the input length is equal to the mandaotry strict length, false if not
*/
protected function validateStrictLength($mString, $iStrictLength) {
if (true === $this -> isInt ($iStrictLength)) {
if (strlen ($mString) !== $iStrictLength) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}', '{__STRICT_LENGTH__}'), array ($this -> sName, $iStrictLength), $this -> sLocClass -> getConstant ('INPUT_NOT_IN_STRICT_LENGTH'));
return false;
}
return true;
}
return false;
}
/**
* protected function validateStartsWith
* checks if the input starts with each values in a given array
*
* @param string $mString : the input
* @param array $aStarts : array of values
* @return boolean true if the input starts with at least one of the values, false if not.
*/
protected function validateStartsWith ($mString, $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) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}', '{__START__}'), array ($this -> sName, implode (',', $aStarts)), $this -> sLocClass -> getConstant ('INPUT_STARTS_WITH'));
}
return $bRes;
}
/**
* protected function validateStartsWith
* checks if the input does not start with each values in a given array
*
* @param string $mString : the input
* @param array $aStarts : array of values
* @return boolean false if the input starts with at least one of the values, true if not.
*/
protected function validateStartsWithout ($mString, $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) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}', '{__START__}'), array ($this -> sName, implode (',', $aStarts)), $this -> sLocClass -> getConstant ('INPUT_DONOT_START_WITH'));
}
return $bRes;
}
/**
* protected 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 function hasForbidden ($mString, $mForbidden) {
if (is_array ($mForbidden)) {
if (in_array ($mString, $mForbidden)) {
formChecker::$aMsg[$this -> sName] = str_replace ('{__FORBIDDEN__}', $mForbidden[array_search($mString, $mForbidden)], $this -> sLocClass -> getConstant ('INPUT_FORBIDDEN'));
return false;
}
} else {
if ($mForbidden === $mString) {
formChecker::$aMsg[$this -> sName] = str_replace ('{__FORBIDDEN__}',$mForbidden, $this -> sLocClass -> getConstant ('INPUT_FORBIDDEN'));
return false;
}
}
return true;
}
/**
* protected 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 function isInt ($iNum) {
if (!is_int ($iNum)) {
throw new formCheckerException
(formCheckerException::FILTER_MUST_BE_INT);
}
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 === $this -> hasForbidden ($mString, $aOptions['forbidden']))
{
return false;
}
}
if (isset ($aOptions['min_length']) && is_int ($aOptions['min_length']))
{
if (false === $this -> validateMinLength ($mString,
$aOptions['min_length'])) {
return false;
}
}
if (isset ($aOptions['max_length']) && is_int ($aOptions['max_length']))
{
if (false === $this -> validateMaxLength ($mString,
$aOptions['max_length'])) {
return false;
}
}
if (isset ($aOptions['strict_length']) && is_int
($aOptions['strict_length'])) {
if (false === $this -> validateStrictLength ($mString,
$aOptions['strict_length'])) {
return false;
}
}
if (isset ($aOptions['starting_with'])) {
if (false === $this -> validateStartsWith ($mString,
$aOptions['starting_with'])) {
return false;
}
}
if (isset ($aOptions['not_starting_with'])) {
if (false === $this -> validateStartsWithout ($mString,
$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)) {
formChecker::$aMsg[$this -> sName] = $this -> sLocClass -> getConstant
('EMAIL_INVALID');
return false;
}
}
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)) {
formChecker::$aMsg[$this -> sName] = $this -> sLocClass -> getConstant
('URL_INVALID');
return false;
}
}
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) {
formChecker::$aMsg[$this -> sName] = str_replace ('{__INPUT__}', $this
-> sName, $this -> sLocClass -> getConstant ('REGEXP_FOUND_NOT_MATCH'));
return false;
}
}
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) {
formChecker::$aMsg[$this -> sName] = str_replace (array ('{__INPUT__}',
'{__FUNC__}'), array ($this -> sName, $aOptions['user_func']), $this ->
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)) {
formChecker::$aMsg[$this -> sName] = str_replace ('{__NUMERIC__}', $this
-> sName, $this -> sLocClass -> getConstant ('NUMERIC_NOT_NUMERIC'));
return false;
}
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 === $this -> isInt ($iMinRange)) {
if ($mString < $iMinRange) {
formChecker::$aMsg[$this -> sName] = str_replace (array
('{__NUMERIC__}', '{__MIN_RANGE__}'), array ($this -> sName, $iMinRange),
$this -> sLocClass -> getConstant ('NUMERIC_NOT_IN_MIN_RANGE'));
return false;
}
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 === $this -> isInt ($iMaxRange)) {
if ($mString > $iMaxRange) {
formChecker::$aMsg[$this -> sName] = str_replace (array
('{__NUMERIC__}', '{__MAX_RANGE__}'), array ($this -> sName, $iMaxRange),
$this -> sLocClass -> getConstant ('NUMERIC_NOT_IN_MAX_RANGE'));
return false;
}
return true;
}
return false;
}
}
/**
* class formChecker
* only class to be called
* uses ReflectionClass to call the correct validateZZZ class
*
*/
class formChecker {
/**
* 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 ();
if (false === ($bRes = $o -> validate ($mString, $sName, $this -> loc,
$aOptions, $bMandatory))) {
$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
*
* @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 = url_encode ($mString);
}
if (in_array ('trim', $aOptions)) {
$mString = trim ($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
* @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 = '[email protected]';
$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
*/
$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 '[email protected]'
*/
if (false === $oChecker -> validate ($sEmail, 'email',
formChecker::VALIDATE_EMAIL, array ('forbidden' => '[email protected]'))) {
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, 'url',
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
('[email protected]'). It is not, obviously.
*/
if (false === $oChecker -> validate ($sEmail, 'url',
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>';
}
} catch (Exception $e) {
echo $e -> getMessage ();
}
/**
* English test (same explanations as for the French one)
*/
try {
$oChecker = new formChecker ('ENG');
