/** * @test */ public function testNumbers() { foreach ($this->getValidNumbers() as $number) { $this->assertTrue($this->validator->isValid($number)); } foreach ($this->getInvalidNumbers() as $number) { $this->assertFalse($this->validator->isValid($number)); } }
/** * @param string $name * @param string $value * @param bool $stopOnError * * @return bool */ public function validate($name, $value, $stopOnError = false) { $this->errors = []; if (null === $this->validator) { $this->validator = ValidatorFactory::create($name, $this->type, $this->rules); } $isValid = $this->validator->validate($value, $stopOnError); if (false === $isValid) { $this->errors = $this->validator->getErrors(); } return $isValid; }
public function init() { if ($this->enableIDN && !function_exists('idn_to_ascii')) { $this->addError($this->intlErrorMessage); } parent::init(); }
/** * Do our own constructor so we can check for the php-clamav library * @param \Foundation\Form\Element $e the element we are validating * @param integer $sizeInBytes */ public function __construct(\Foundation\Form\Element $element) { if (!extension_loaded('clamav') or !function_exists('cl_scanfile')) { throw new \Foundation\Exception("Virusscan validator requires the php-clamav extension."); } parent::__construct($element); }
/** * Construct * Check the ruleSet * @param \Foundation\Form\Element $e * @param mixed $ruleSet */ public function __construct(\Foundation\Form\Element $e, $ruleSet) { if (!\is_array($ruleSet) or !isset($ruleSet[0]) or !isset($ruleSet[1])) { throw new \Foundation\Exception("The ruleset for NumberRange must be an array with two elements."); } parent::__construct($e, $ruleSet); }
/** * @param null $options - expects to find a ['token'] entry in * options, with the token in it */ public function __construct($options = null) { parent::__construct($options); $this->setMessage(self::MsgInvalidToken, 'Unable to authenticate form data. Please refresh and try again.'); $this->token = isset($options['token']) ? $options['token'] : 'missing token'; $this->logger = isset($options['logger']) ? $options['logger'] : null; }
/** * Constructor * * @param array|callable $options */ public function __construct($options = null) { if (is_callable($options)) { $options = ['callback' => $options]; } parent::__construct($options); }
public function init() { if ($this->message === null) { switch ($this->operator) { case '==': $this->message = '{compareAttribute} must be repeated exactly.'; break; case '===': $this->message = '{compareAttribute} must be repeated exactly.'; break; case '!=': $this->message = '{compareAttribute} must not be equal to "{compareValue}".'; break; case '!==': $this->message = '{compareAttribute} must not be equal to "{compareValue}".'; break; case '>': $this->message = '{compareAttribute} must be greater than "{compareValue}".'; break; case '>=': $this->message = '{compareAttribute} must be greater than or equal to "{compareValue}".'; break; case '<': $this->message = '{compareAttribute} must be less than "{compareValue}".'; break; case '<=': $this->message = '{compareAttribute} must be less than or equal to "{compareValue}".'; break; default: $this->addError('Unknown operator: {operator}', ['{operator}' => $this->operator]); } } parent::init(); }
/** * Construct * Check the ruleSet * @param \Foundation\Form\Element $e * @param mixed $ruleSet */ public function __construct(\Foundation\Form\Element $e, $ruleSet) { if (!\is_int($ruleSet)) { throw new \Foundation\Exception("The ruleset for MaximumLength must be an integer"); } parent::__construct($e, $ruleSet); }
/** * {@inheritdoc} */ public function sanitize() { if ($this->canSanitize()) { return new \DateTime($this->getInput()); } return parent::sanitize(); }
public function init() { if (!is_array($this->range)) { throw new \InvalidArgumentException($this->rangeErrorMessage); } parent::init(); }
/** * Construct * Check the ruleSet * * @param \Foundation\Form\Element $e * @param mixed $ruleSet */ public function __construct(\Foundation\Form\Element $e, $ruleSet) { if (!\strtotime($ruleSet)) { throw new \Foundation\Exception("The ruleset for DateBefore must be a valid PHP date string"); } parent::__construct($e, $ruleSet); }
/** * Construct * Check the ruleSet * * @param \Foundation\Form\Element $e * @param mixed $ruleSet */ public function __construct(\Foundation\Form\Element $e, $ruleSet) { if (\is_null($ruleSet)) { throw new \Foundation\Exception("The ruleset for SpeicifcString must be set."); } parent::__construct($e, $ruleSet); }
/** * Constructs a new validator, initializing the minimum valid value. * * @param \Zikula_ServiceManager $serviceManager The current service manager instance. * @param integer $value The minimum valid value for the field data. * @param string $errorMessage The error message to return if the field data is not valid. * * @throws \InvalidArgumentException If the minimum value specified is not an integer. */ public function __construct(\Zikula_ServiceManager $serviceManager, $value, $errorMessage = null) { parent::__construct($serviceManager, $errorMessage); if (!isset($value) || !is_int($value) || $value < 0) { throw new \InvalidArgumentException($this->__('An invalid integer value was received.')); } $this->value = $value; }
/** * Do our own constructor so we can set the maxfilesize and check the ruleSet * @param \Foundation\Form\Element $e the element we are validating * @param integer $sizeInBytes */ public function __construct(\Foundation\Form\Element $element, $sizeInBytes) { if (!($integer = \intval($sizeInBytes))) { throw new \Foundation\Exception("The ruleset for MaximumFileSize must be an integer. Value: '{$sizeInBytes}'"); } parent::__construct($element, $integer); $this->e->setMaxSize($this->ruleSet); }
/** * Constructs a new validator, initializing the maximum valid string length value. * * @param \Zikula_ServiceManager $serviceManager The current service manager instance. * @param integer $length The maximum valid length for the string value. * @param string $errorMessage The error message to return if the string data exceeds the maximum length. * * @throws \InvalidArgumentException Thrown if the maximum string length value is not an integer or is less than zero. */ public function __construct(\Zikula_ServiceManager $serviceManager, $length, $errorMessage = null) { parent::__construct($serviceManager, $errorMessage); if (!isset($length) || !is_int($length) || $length < 0) { throw new \InvalidArgumentException($this->__('An invalid string length was received.')); } $this->length = $length; }
/** * @param string $allowedTags */ public function __construct(...$allowedValues) { parent::__construct(); if (!$allowedValues) { throw new \InvalidArgumentException('__construct() expects at least 1 parameter'); } $this->allowedValues = $allowedValues; }
/** * Constructs the validator, initializing the regular expression. * * @param \Zikula_ServiceManager $serviceManager The current service manager instance. * @param string $regularExpression The PCRE regular expression against which to validate the data. * @param string $errorMessage The error message to return if the data does not match the expression. * * @throws \InvalidArgumentException Thrown if the regular expression is not valid. */ public function __construct(\Zikula_ServiceManager $serviceManager, $regularExpression, $errorMessage = null) { parent::__construct($serviceManager, $errorMessage); if (!isset($regularExpression) || !is_string($regularExpression) || empty($regularExpression)) { throw new \InvalidArgumentException($this->__('An invalid regular expression was received.')); } $this->regularExpression = $regularExpression; }
public function __construct($pattern) { if (is_string($pattern)) { $this->setPattern($pattern); parent::__construct(array()); return; } parent::__construct($pattern); }
public function validate() { parent::checkInput(); $value = $this->input->getValue(); if (empty($value)) { throw new ValidationException($this->input, "Input value is empty."); } return true; }
/** * Валидация значения элемента * * @return boolean true - если значение валидно, иначе выбрасывается * искючение типа @{ValidationException} * @throws ValidationException Исключение с информацией об ошибке */ public function validate() { parent::checkInput(); $value = $this->input->getValue(); $result = preg_match($this->pattern, $value, $matches); if ($result !== 1) { throw new ValidationException($this->input, "Input value doesn't match '" . $this->pattern . "' pattern."); } return true; }
/** * Constructor for barcodes * * @param array|string $options Options to use */ public function __construct($options = null) { if (!is_array($options) && !$options instanceof \Zend\Config\Config) { $options = array('adapter' => $options); } if (array_key_exists('options', $options)) { $options['options'] = array('options' => $options['options']); } parent::__construct($options); }
/** * {@inheritdoc} */ public function sanitize() { if ($this->isValid()) { return $this->getInput(); } elseif ($this->canSanitize()) { return $this->default; } else { return parent::sanitize(); } }
/** * @param int|float|string $min * @param int|float|string $max */ public function __construct($min, $max) { parent::__construct(); $this->min = $min; $this->max = $max; if (is_string($min) && !is_numeric($min) && is_string($max) && !is_numeric($max)) { $this->isStringComparison = true; } else { $this->min = (double) $this->min; $this->max = (double) $this->max; } }
/** * Construct * Check the ruleSet * * @param \Foundation\Form\Element $e * @param array $ruleSet */ public function __construct(\Foundation\Form\Element $e, $ruleSet) { if (!\is_array($ruleSet)) { throw new \Foundation\Exception("The ruleset for SpecialObject must be an array"); } if (!\array_key_exists('object', $ruleSet) or !\array_key_exists('method', $ruleSet) or !\array_key_exists('errorMessage', $ruleSet)) { throw new \Foundation\Exception("The ruleset for SpecialObject must be an array with keys 'object', 'method', and 'errorMessage'"); } if (!\method_exists($ruleSet['object'], $ruleSet['method'])) { throw new \Foundation\Exception("The " . get_class($ruleSet['object']) . " object has no method {$ruleSet['method']} as specified in SpecialObject ruleset"); } parent::__construct($e, $ruleSet); }
/** * Creates a new validator, initializing the set of valid string values. * * @param \Zikula_ServiceManager $serviceManager The current service manager instance. * @param array $validStrings An array containing valid string values. * @param string $errorMessage The error message to return if the data is not valid. * * @throws \InvalidArgumentException Thrown if the list of valid string values is not valid, or if it contains an invalid value. */ public function __construct(\Zikula_ServiceManager $serviceManager, array $validStrings, $errorMessage = null) { parent::__construct($serviceManager, $errorMessage); if (empty($validStrings)) { throw new \InvalidArgumentException($this->__('An invalid list of valid strings was received.')); } foreach ($validStrings as $validString) { if (isset($validString) && is_string($validString)) { $this->validStrings[$validString] = $validString; } else { throw new \InvalidArgumentException($this->__('An invalid value was received in the list of valid strings.')); } } }
/** * @param int $min * @param int $max */ public function __construct($min, $max = null) { parent::__construct(); $this->min = (int) $min; if ($this->min < 0) { throw new \InvalidArgumentException('$min must be a positive integer'); } if ($max !== null) { $this->max = (int) $max; if ($this->max < 0) { throw new \InvalidArgumentException('$max must be a positive integer'); } } }
/** * Sets validator options * * @param integer|array|\Zend\Config\Config $options * @return void */ public function __construct($options = array()) { if (!is_array($options)) { $options = func_get_args(); $temp['min'] = array_shift($options); if (!empty($options)) { $temp['max'] = array_shift($options); } if (!empty($options)) { $temp['encoding'] = array_shift($options); } $options = $temp; } parent::__construct($options); }
/** * This function routes all requests to the validation methods. * * If validation method does not exist false will be returned. * * Optional elements will be checked before executing the validation callback. * The following values are considered as empty: false, null and an empty string or array. * * The arguments array has to be in the following order: * The First argument should be the optional state, the second state the value followed by the * arguments for the calles function. * * @see empty() * @param string Function name * @param array Arguments for the function */ public static function __callStatic($name, $arguments) { self::$errors = array(); if ($name[0] == '_') { $name = substr($name, 1); } // Use Late static binding because __CLASS__ would contain AbstractValidator if (method_exists(get_called_class(), $name) == true) { // Optional check if ($arguments[1] == true && ($arguments[0] === false || $arguments[0] === null || $arguments[0] === '' || $arguments[0] === array())) { return true; } return call_user_func_array("static::{$name}", $arguments); } else { return false; } }
public function init() { if ($this->edsn) { $this->parseEDSN(); } if (!$this->table || !$this->column) { throw new \UnexpectedValueException('Table and column must be specified'); } if (!is_string($this->table) || !is_string($this->column)) { throw new \UnexpectedValueException('Table and column must be set as string'); } mysqli_report(MYSQLI_REPORT_STRICT); $mysqli = new \mysqli($this->host, $this->user, $this->pass, $this->dbname); if ($mysqli->connect_errno) { throw new \mysqli_sql_exception(printf("Connection error: %s\n", $mysqli->connect_error)); } $this->conn = $mysqli; parent::init(); }