/**
* @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();
}
