PHP Classes

File: package.formchecker.php

Recommend this page to a friend!
  Classes of Johan Barbier  >  Form Checker  >  package.formchecker.php  >  Download  
File: package.formchecker.php
Role: Class source
Content type: text/plain
Description: formChecker package
Class: Form Checker
Sanitize and validate user input data
Author: By
Last change: Added an option (allowed), and made optimizations (static methods instead of normal methods)
Date: 15 years ago
Size: 35,124 bytes
 

Contents

Class file image Download
<?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 (); } ?>