Namespace | Phalcon\Filter | Extends | \Exception |
Phalcon\Filter\Exception
Las excepciones lanzadas en Phalcon\Filter usarán esta clase
Namespace | Phalcon\Filter | Implements | FilterInterface |
Carga perezosamente, almacena y expone objetos saneadores
const FILTER_ABSINT = absint;
const FILTER_ALNUM = alnum;
const FILTER_ALPHA = alpha;
const FILTER_BOOL = bool;
const FILTER_EMAIL = email;
const FILTER_FLOAT = float;
const FILTER_INT = int;
const FILTER_LOWER = lower;
const FILTER_LOWERFIRST = lowerfirst;
const FILTER_REGEX = regex;
const FILTER_REMOVE = remove;
const FILTER_REPLACE = replace;
const FILTER_SPECIAL = special;
const FILTER_SPECIALFULL = specialfull;
const FILTER_STRING = string;
const FILTER_STRING_LEGACY = stringlegacy;
const FILTER_STRIPTAGS = striptags;
const FILTER_TRIM = trim;
const FILTER_UPPER = upper;
const FILTER_UPPERFIRST = upperfirst;
const FILTER_UPPERWORDS = upperwords;
const FILTER_URL = url;
/**
* @var array
*/
protected mapper;
/**
* @var array
*/
protected services;
public function __call( string $name, array $args );
Magic call to make the helper objects available as methods.
public function __construct( array $mapper = [] );
Filter constructor.
public function get( string $name ): mixed;
Obtiene un servicio. Si no está en el vector mapeador, crea un nuevo objeto, lo establece y luego lo devuelve.
public function has( string $name ): bool;
Comprueba si un servicio existe en el vector mapa
public function sanitize( mixed $value, mixed $sanitizers, bool $noRecursive = bool ): mixed;
Sanea un valor con un único o conjunto de saneadores especificados
public function set( string $name, mixed $service ): void;
Establece un nuevo servicio en el vector mapeador
protected function init( array $mapper ): void;
Carga los objetos en el vector mapeador interno
Namespace | Phalcon\Filter | Uses | Phalcon\Filter\Filter |
Class FilterFactory
@package Phalcon\Filter
public function newInstance(): FilterInterface;
Devuelve un objeto Localizador con todos los ayudantes definidos en funciones anónimas
protected function getServices(): array;
Devuelve los adaptadores disponibles
Namespace | Phalcon\Filter |
Carga perezosamente, almacena y expone objetos saneadores
public function sanitize( mixed $value, mixed $sanitizers, bool $noRecursive = bool ): mixed;
Sanea un valor con un único o conjunto de saneadores especificados
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\AbsInt
Sanea un valor a un entero absoluto
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Alnum
Sanea un valor a un valor alfanumérico
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Alpha
Sanea un valor a un valor alfabético
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\BoolVal
Sanea un valor a booleano
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Email
Sanea una cadena email
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\FloatVal
Sane a un valor a real
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\IntVal
Sanea un valor a entero
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Lower
Sanea un valor a minúsculas
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\LowerFirst
Sanea un valor a lcfirst
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Regex
Sanea un valor realizando preg_replace
public function __invoke( mixed $input, mixed $pattern, mixed $replace );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Remove
Sanea un valor eliminando partes de una cadena
public function __invoke( mixed $input, mixed $replace );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Replace
Sanea un valor sustituyendo partes de una cadena
public function __invoke( mixed $input, mixed $from, mixed $to );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Special
Sanea caracteres especiales de un valor
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\SpecialFull
Sanee caracteres especiales de un valor (htmlspecialchars() y ENT_QUOTES)
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Sanea un valor a cadena
public function __invoke( string $input, int $flags = int ): string;
Namespace | Phalcon\Filter\Sanitize |
Sanitizes a value to string using filter_var()
. The filter provides backwards compatibility with versions prior to v5. For PHP higher or equal to 8.1, the filter will remain the string unchanged. If anything other than a string is passed, the method will return false
public function __invoke( mixed $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Striptags
Sanea un valor a striptags
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Trim
Sanea un valor eliminando espacios iniciales y finales
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Upper
Sanea un valor a mayúsculas
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\UpperFirst
Sanea un valor a ucfirst
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\UpperWords
Sanea un valor a mayúsculas el primer carácter de cada palabra
public function __invoke( string $input );
Namespace | Phalcon\Filter\Sanitize |
Phalcon\Filter\Sanitize\Url
Sanea un valor url
public function __invoke( mixed $input );
Namespace | Phalcon\Filter | Uses | Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Filter\FilterInterface, Phalcon\Messages\MessageInterface, Phalcon\Messages\Messages, Phalcon\Filter\Validation\ValidationInterface, Phalcon\Filter\Validation\Exception, Phalcon\Filter\Validation\ValidatorInterface, Phalcon\Filter\Validation\AbstractCombinedFieldsValidator | Extends | Injectable | Implements | ValidationInterface |
Permite validar datos usando validadores personalizados o integrados
/**
* @var array
*/
protected combinedFieldsValidators;
/**
* @var mixed
*/
protected data;
/**
* @var object|null
*/
protected entity;
/**
* @var array
*/
protected filters;
/**
* @var array
*/
protected labels;
/**
* @var Messages|null
*/
protected messages;
/**
* List of validators
*
* @var array
*/
protected validators;
/**
* Calculated values
*
* @var array
*/
protected values;
public function __construct( array $validators = [] );
Phalcon\Filter\Validation constructor
public function add( mixed $field, ValidatorInterface $validator ): ValidationInterface;
Añade un validador a un campo
public function appendMessage( MessageInterface $message ): ValidationInterface;
Añade un mensaje a la lista de mensajes
public function bind( mixed $entity, mixed $data ): ValidationInterface;
Asigna los datos a una entidad Se usa la entidad para obtener los valores de validación
public function getData(): mixed;
public function getEntity(): mixed;
Devuelve la entidad enlazada
public function getFilters( string $field = null ): mixed | null;
Devuelve todos los filtros o uno específico
public function getLabel( mixed $field ): string;
Obtiene la etiqueta de un campo
public function getMessages(): Messages;
Devuelve los validadores registrados
public function getValidators(): array;
Devuelve los validadores añadidos a la validación
public function getValue( string $field ): mixed | null;
Obtiene un valor a validar en la fuente de datos vector/objeto
public function getValueByData( mixed $data, string $field ): mixed | null;
Obtiene un valor a validar en la fuente de datos vector/objeto
public function getValueByEntity( mixed $entity, string $field ): mixed | null;
Gets the a value to validate in the object entity source
public function rule( mixed $field, ValidatorInterface $validator ): ValidationInterface;
Alias del método add
public function rules( mixed $field, array $validators ): ValidationInterface;
Añade los validadores a un campo
public function setEntity( mixed $entity ): void;
Establece la entidad enlazada
public function setFilters( mixed $field, mixed $filters ): ValidationInterface;
Añade filtros al campo
public function setLabels( array $labels ): void;
Añade etiquetas a los campos
public function setValidators( array $validators ): Validation;
public function validate( mixed $data = null, mixed $entity = null ): Messages;
Valida un conjunto de datos según un conjunto de reglas
protected function preChecking( mixed $field, ValidatorInterface $validator ): bool;
Validaciones internas, que si devuelven verdadero, entonces omiten el validador actual
Namespace | Phalcon\Filter\Validation | Extends | AbstractValidator |
Esta es una clase base para validadores de campos combinados
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Support\Helper\Arr\Whitelist, Phalcon\Messages\Message, Phalcon\Filter\Validation | Implements | ValidatorInterface |
Esta es una clase base para validadores
/**
* Message template
*
* @var string|null
*/
protected template;
/**
* Message templates
*
* @var array
*/
protected templates;
/**
* @var array
*/
protected options;
public function __construct( array $options = [] );
Phalcon\Filter\Validation\Validator constructor
public function getOption( string $key, mixed $defaultValue = null ): mixed;
Devuelve una opción en las opciones del validador. Devuelve null si la opción no ha sido configurada
public function getTemplate( string $field = null ): string;
Obtiene el mensaje plantilla
public function getTemplates(): array;
Obtiene el objeto colección de plantillas
public function hasOption( string $key ): bool;
Comprueba si una opción está definida
public function messageFactory( Validation $validation, mixed $field, array $replacements = [] ): Message;
Crear un mensaje predeterminado por factoría
public function setOption( string $key, mixed $value ): void;
Configura una opción en el validador
public function setTemplate( string $template ): ValidatorInterface;
Establece un nuevo mensaje de plantilla
public function setTemplates( array $templates ): ValidatorInterface;
Limpia las plantillas actuales y establece nuevas desde un vector,
abstract public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
protected function allowEmpty( mixed $field, mixed $value ): bool;
Checks if field can be empty.
protected function prepareCode( string $field ): int;
Prepara un código de validación.
protected function prepareLabel( Validation $validation, string $field ): mixed;
Prepara una etiqueta para el campo.
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Filter\Validation | Extends | AbstractValidator | Implements | ValidatorCompositeInterface |
Esta es una clase base para validadores de campos combinados
/**
* @var array
*/
protected validators;
public function getValidators(): array;
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation | Extends | \Exception |
Exceptions thrown in Phalcon\Filter\Validation* classes will use this class
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Di\Injectable, Phalcon\Messages\MessageInterface, Phalcon\Messages\Messages |
Interface for the Phalcon\Filter\Validation component
public function add( mixed $field, ValidatorInterface $validator ): ValidationInterface;
Añade un validador a un campo
public function appendMessage( MessageInterface $message ): ValidationInterface;
Añade un mensaje a la lista de mensajes
public function bind( mixed $entity, mixed $data ): ValidationInterface;
Asigna los datos a una entidad Se usa la entidad para obtener los valores de validación
public function getEntity(): mixed;
Devuelve la entidad enlazada
public function getFilters( string $field = null ): mixed | null;
Devuelve todos los filtros o uno específico
public function getLabel( string $field ): string;
Obtiene la etiqueta de un campo
public function getMessages(): Messages;
Devuelve los validadores registrados
public function getValidators(): array;
Devuelve los validadores añadidos a la validación
public function getValue( string $field ): mixed | null;
Obtiene un valor a validar en la fuente de datos vector/objeto
public function rule( mixed $field, ValidatorInterface $validator ): ValidationInterface;
Alias del método add
public function rules( string $field, array $validators ): ValidationInterface;
Añade los validadores a un campo
public function setFilters( string $field, mixed $filters ): ValidationInterface;
Añade filtros al campo
public function setLabels( array $labels ): void;
Añade etiquetas a los campos
public function validate( mixed $data = null, mixed $entity = null ): Messages;
Valida un conjunto de datos según un conjunto de reglas
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprobar caracter(es) alfanumérico(s)
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alnum as AlnumValidator;
$validator = new Validation();
$validator->add(
"username",
new AlnumValidator(
[
"message" => ":field must contain only alphanumeric characters",
]
)
);
$validator->add(
[
"username",
"name",
],
new AlnumValidator(
[
"message" => [
"username" => "username must contain only alphanumeric characters",
"name" => "name must contain only alphanumeric characters",
],
]
)
);
//
protected template = Field :field must contain only letters and numbers;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Verifica uno o varios caracteres alfabéticos
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alpha as AlphaValidator;
$validator = new Validation();
$validator->add(
"username",
new AlphaValidator(
[
"message" => ":field must contain only letters",
]
)
);
$validator->add(
[
"username",
"name",
],
new AlphaValidator(
[
"message" => [
"username" => "username must contain only letters",
"name" => "name must contain only letters",
],
]
)
);
//
protected template = Field :field must contain only letters;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Valida que un valor está entre un rango inclusivo de dos valores. For a value x, the test is passed if minimum<=x<=maximum.
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Between;
$validator = new Validation();
$validator->add(
"price",
new Between(
[
"minimum" => 0,
"maximum" => 100,
"message" => "The price must be between 0 and 100",
]
)
);
$validator->add(
[
"price",
"amount",
],
new Between(
[
"minimum" => [
"price" => 0,
"amount" => 0,
],
"maximum" => [
"price" => 100,
"amount" => 50,
],
"message" => [
"price" => "The price must be between 0 and 100",
"amount" => "The amount must be between 0 and 50",
],
]
)
);
//
protected template = Field :field must be within the range of :min to :max;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\ValidatorInterface, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Llama a la función del usuario para la validación
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Callback as CallbackValidator;
use Phalcon\Filter\Validation\Validator\Numericality as NumericalityValidator;
$validator = new Validation();
$validator->add(
["user", "admin"],
new CallbackValidator(
[
"message" => "There must be only an user or admin set",
"callback" => function($data) {
if (!empty($data->getUser()) && !empty($data->getAdmin())) {
return false;
}
return true;
}
]
)
);
$validator->add(
"amount",
new CallbackValidator(
[
"callback" => function($data) {
if (!empty($data->getProduct())) {
return new NumericalityValidator(
[
"message" => "Amount must be a number."
]
);
}
}
]
)
);
//
protected template = Field :field must match the callback function;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Exception, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprueba si dos valores tienen el mismo valor
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Confirmation;
$validator = new Validation();
$validator->add(
"password",
new Confirmation(
[
"message" => "Password doesn't match confirmation",
"with" => "confirmPassword",
]
)
);
$validator->add(
[
"password",
"email",
],
new Confirmation(
[
"message" => [
"password" => "Password doesn't match confirmation",
"email" => "Email doesn't match confirmation",
],
"with" => [
"password" => "confirmPassword",
"email" => "confirmEmail",
],
]
)
);
//
protected template = Field :field must be the same as :with;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
final protected function compare( string $a, string $b ): bool;
Comparar cadenas
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprueba si un valor tiene un número de tarjeta de crédito válido
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\CreditCard as CreditCardValidator;
$validator = new Validation();
$validator->add(
"creditCard",
new CreditCardValidator(
[
"message" => "The credit card number is not valid",
]
)
);
$validator->add(
[
"creditCard",
"secondCreditCard",
],
new CreditCardValidator(
[
"message" => [
"creditCard" => "The credit card number is not valid",
"secondCreditCard" => "The second credit card number is not valid",
],
]
)
);
//
protected template = Field :field is not valid for a credit card number;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | DateTime, Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Verifica si un valor es una fecha válida
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Date as DateValidator;
$validator = new Validation();
$validator->add(
"date",
new DateValidator(
[
"format" => "d-m-Y",
"message" => "The date is invalid",
]
)
);
$validator->add(
[
"date",
"anotherDate",
],
new DateValidator(
[
"format" => [
"date" => "d-m-Y",
"anotherDate" => "Y-m-d",
],
"message" => [
"date" => "The date is invalid",
"anotherDate" => "The another date is invalid",
],
]
)
);
//
protected template = Field :field is not a valid date;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprueba caracter(es) numérico(s)
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Digit as DigitValidator;
$validator = new Validation();
$validator->add(
"height",
new DigitValidator(
[
"message" => ":field must be numeric",
]
)
);
$validator->add(
[
"height",
"width",
],
new DigitValidator(
[
"message" => [
"height" => "height must be numeric",
"width" => "width must be numeric",
],
]
)
);
//
protected template = Field :field must be numeric;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Verifica si un valor tiene un formato de correo electrónico correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Email as EmailValidator;
$validator = new Validation();
$validator->add(
"email",
new EmailValidator(
[
"message" => "The e-mail is not valid",
]
)
);
$validator->add(
[
"email",
"anotherEmail",
],
new EmailValidator(
[
"message" => [
"email" => "The e-mail is not valid",
"anotherEmail" => "The another e-mail is not valid",
],
]
)
);
//
protected template = Field :field must be an email address;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Extends | \Exception |
Exceptions thrown in Phalcon\Filter\Validation\Validator* classes will use this class
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\Exception | Extends | AbstractValidator |
Comprueba si un valor no está incluido en una lista de valores
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;
$validator = new Validation();
$validator->add(
"status",
new ExclusionIn(
[
"message" => "The status must not be A or B",
"domain" => [
"A",
"B",
],
]
)
);
$validator->add(
[
"status",
"type",
],
new ExclusionIn(
[
"message" => [
"status" => "The status must not be A or B",
"type" => "The type must not be 1 or "
],
"domain" => [
"status" => [
"A",
"B",
],
"type" => [1, 2],
],
]
)
);
//
protected template = Field :field must not be a part of list: :domain;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Support\Helper\Arr\Get, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidatorComposite, Phalcon\Filter\Validation\Validator\File\MimeType, Phalcon\Filter\Validation\Validator\File\Resolution\Equal, Phalcon\Filter\Validation\Validator\File\Resolution\Max, Phalcon\Filter\Validation\Validator\File\Resolution\Min, Phalcon\Filter\Validation\Validator\File\Size\Equal, Phalcon\Filter\Validation\Validator\File\Size\Max, Phalcon\Filter\Validation\Validator\File\Size\Min | Extends | AbstractValidatorComposite |
Verifica si un valor tiene un archivo correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File as FileValidator;
$validator = new Validation();
$validator->add(
"file",
new FileValidator(
[
"maxSize" => "2M",
"messageSize" => ":field exceeds the max file size (:size)",
"allowedTypes" => [
"image/jpeg",
"image/png",
],
"messageType" => "Allowed file types are :types",
"maxResolution" => "800x600",
"messageMaxResolution" => "Max resolution of :field is :resolution",
"messageFileEmpty" => "File is empty",
"messageIniSize" => "Ini size is not valid",
"messageValid" => "File is not valid",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new FileValidator(
[
"maxSize" => [
"file" => "2M",
"anotherFile" => "4M",
],
"messageSize" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
"allowedTypes" => [
"file" => [
"image/jpeg",
"image/png",
],
"anotherFile" => [
"image/gif",
"image/bmp",
],
],
"messageType" => [
"file" => "Allowed file types are image/jpeg and image/png",
"anotherFile" => "Allowed file types are image/gif and image/bmp",
],
"maxResolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"messageMaxResolution" => [
"file" => "Max resolution of file is 800x600",
"anotherFile" => "Max resolution of file is 1024x768",
],
]
)
);
public function __construct( array $options = [] );
Constructor
Namespace | Phalcon\Filter\Validation\Validator\File | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Verifica si un valor tiene un archivo correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Size(
[
"maxSize" => "2M",
"messageSize" => ":field exceeds the max file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new FileValidator(
[
"maxSize" => [
"file" => "2M",
"anotherFile" => "4M",
],
"messageSize" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
],
]
)
);
/**
* Empty is empty
*
* @var string
*/
protected messageFileEmpty = Field :field must not be empty;
/**
* File exceeds the file size set in PHP configuration
*
* @var string
*/
protected messageIniSize = File :field exceeds the maximum file size;
/**
* File is not valid
*
* @var string
*/
protected messageValid = Field :field is not valid;
public function checkUpload( Validation $validation, mixed $field ): bool;
Comprueba subida
public function checkUploadIsEmpty( Validation $validation, mixed $field ): bool;
Comprobar si la subida está vacía
public function checkUploadIsValid( Validation $validation, mixed $field ): bool;
Comprobar si la subida es válida
public function checkUploadMaxSize( Validation $validation, mixed $field ): bool;
Comprueba si el archivo subido es mayor que el tamaño permitido por PHP
public function getFileSizeInBytes( string $size ): double;
Convierte una cadena como “2.5MB” en bytes
public function getMessageFileEmpty(): string;
Empty is empty
public function getMessageIniSize(): string;
File exceeds the file size set in PHP configuration
public function getMessageValid(): string;
File is not valid
public function isAllowEmpty( Validation $validation, string $field ): bool;
Comprueba si se permite vacío
public function setMessageFileEmpty( string $message ): void;
Empty is empty
public function setMessageIniSize( string $message ): void;
File exceeds the file size set in PHP configuration
public function setMessageValid( string $message ): void;
File is not valid
protected function checkIsUploadedFile( string $name ): bool;
Checks if a file has been uploaded; Internal check that can be overriden in a subclass if you do not want to check uploaded files
Namespace | Phalcon\Filter\Validation\Validator\File | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Exception | Extends | AbstractFile |
Comprueba si un valor tiene un tipo de medio de fichero correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\MimeType;
$validator = new Validation();
$validator->add(
"file",
new MimeType(
[
"types" => [
"image/jpeg",
"image/png",
],
"message" => "Allowed file types are :types"
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new MimeType(
[
"types" => [
"file" => [
"image/jpeg",
"image/png",
],
"anotherFile" => [
"image/gif",
"image/bmp",
],
],
"message" => [
"file" => "Allowed file types are image/jpeg and image/png",
"anotherFile" => "Allowed file types are image/gif and image/bmp",
]
]
)
);
//
protected template = File :field must be of type: :types;
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Resolution | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Comprueba si un fichero tiene una resolución correcta
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Equal;
$validator = new Validation();
$validator->add(
"file",
new Equal(
[
"resolution" => "800x600",
"message" => "The resolution of the field :field has to be equal :resolution",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Equal(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"message" => [
"file" => "Equal resolution of file has to be 800x600",
"anotherFile" => "Equal resolution of file has to be 1024x768",
],
]
)
);
//
protected template = The resolution of the field :field has to be equal :resolution;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Resolution | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Comprueba si un fichero tiene una resolución correcta
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Max;
$validator = new Validation();
$validator->add(
"file",
new Max(
[
"resolution" => "800x600",
"message" => "Max resolution of :field is :resolution",
"included" => true,
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Max(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "Max resolution of file is 800x600",
"anotherFile" => "Max resolution of file is 1024x768",
],
]
)
);
//
protected template = File :field exceeds the maximum resolution of :resolution;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Resolution | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Comprueba si un fichero tiene una resolución correcta
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Min;
$validator = new Validation();
$validator->add(
"file",
new Min(
[
"resolution" => "800x600",
"message" => "Min resolution of :field is :resolution",
"included" => true,
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Min(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "Min resolution of file is 800x600",
"anotherFile" => "Min resolution of file is 1024x768",
],
]
)
);
//
protected template = File :field can not have the minimum resolution of :resolution;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Size | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Verifica si un valor tiene un archivo correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Equal(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the equal file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Equal(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file does not have the right file size",
"anotherFile" => "anotherFile wrong file size (4MB)",
],
]
)
);
//
protected template = File :field does not have the exact :size file size;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Size | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Verifica si un valor tiene un archivo correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Max(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the max file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Max(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
],
]
)
);
//
protected template = File :field exceeds the size of :size;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\File\Size | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\Validator\File\AbstractFile | Extends | AbstractFile |
Verifica si un valor tiene un archivo correcto
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Min(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the min file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Min(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file exceeds the min file size 2M",
"anotherFile" => "anotherFile exceeds the min file size 4M",
],
]
)
);
//
protected template = File :field can not have the minimum size of :size;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Verifica si un valor es idéntico a otro
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Identical;
$validator = new Validation();
$validator->add(
"terms",
new Identical(
[
"accepted" => "yes",
"message" => "Terms and conditions must be accepted",
]
)
);
$validator->add(
[
"terms",
"anotherTerms",
],
new Identical(
[
"accepted" => [
"terms" => "yes",
"anotherTerms" => "yes",
],
"message" => [
"terms" => "Terms and conditions must be accepted",
"anotherTerms" => "Another terms must be accepted",
],
]
)
);
//
protected template = Field :field does not have the expected value;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\Exception | Extends | AbstractValidator |
Comprueba si un valor está incluido en una lista de valores
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\InclusionIn;
$validator = new Validation();
$validator->add(
"status",
new InclusionIn(
[
"message" => "The status must be A or B",
"domain" => ["A", "B"],
]
)
);
$validator->add(
[
"status",
"type",
],
new InclusionIn(
[
"message" => [
"status" => "The status must be A or B",
"type" => "The status must be 1 or 2",
],
"domain" => [
"status" => ["A", "B"],
"type" => [1, 2],
]
]
)
);
//
protected template = Field :field must be a part of list: :domain;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Messages\Message | Extends | AbstractValidator |
Comprueba direcciones IP
use Phalcon\Filter\Validation\Validator\Ip as IpValidator;
$validator->add(
"ip_address",
new IpValidator(
[
"message" => ":field must contain only ip addresses",
"version" => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
"allowReserved" => false, // False if not specified. Ignored for v6
"allowPrivate" => false, // False if not specified
"allowEmpty" => false,
]
)
);
$validator->add(
[
"source_address",
"destination_address",
],
new IpValidator(
[
"message" => [
"source_address" => "source_address must be a valid IP address",
"destination_address" => "destination_address must be a valid IP address",
],
"version" => [
"source_address" => Ip::VERSION_4 | IP::VERSION_6,
"destination_address" => Ip::VERSION_4,
],
"allowReserved" => [
"source_address" => false,
"destination_address" => true,
],
"allowPrivate" => [
"source_address" => false,
"destination_address" => true,
],
"allowEmpty" => [
"source_address" => false,
"destination_address" => true,
],
]
)
);
const VERSION_4 = FILTER_FLAG_IPV4;
const VERSION_6 = FILTER_FLAG_IPV6;
//
protected template = Field :field must be a valid IP address;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprueba que haya un valor numérico válido
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Numericality;
$validator = new Validation();
$validator->add(
"price",
new Numericality(
[
"message" => ":field is not numeric",
]
)
);
$validator->add(
[
"price",
"amount",
],
new Numericality(
[
"message" => [
"price" => "price is not numeric",
"amount" => "amount is not numeric",
]
]
)
);
//
protected template = Field :field does not have a valid numeric format;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Valida que un valor no sea nulo ni cadena vacía
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\PresenceOf;
$validator = new Validation();
$validator->add(
"name",
new PresenceOf(
[
"message" => "The name is required",
]
)
);
$validator->add(
[
"name",
"email",
],
new PresenceOf(
[
"message" => [
"name" => "The name is required",
"email" => "The email is required",
],
]
)
);
//
protected template = Field :field is required;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Permite validar si el valor de un campo coincide con una expresión regular
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Regex as RegexValidator;
$validator = new Validation();
$validator->add(
"created_at",
new RegexValidator(
[
"pattern" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
"message" => "The creation date is invalid",
]
)
);
$validator->add(
[
"created_at",
"name",
],
new RegexValidator(
[
"pattern" => [
"created_at" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
"name" => "/^[a-z]$/",
],
"message" => [
"created_at" => "The creation date is invalid",
"name" => "The name is invalid",
]
]
)
);
//
protected template = Field :field does not match the required format;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\AbstractValidatorComposite, Phalcon\Filter\Validation\Validator\StringLength\Max, Phalcon\Filter\Validation\Validator\StringLength\Min, Phalcon\Filter\Validation\Exception | Extends | AbstractValidatorComposite |
Validates that a string has the specified maximum and minimum constraints The test is passed if for a string’s length L, min<=L<=max, i.e. L must be at least min, and at most max. Desde Phalcon v4.0 este validador funciona como un contenedor
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength as StringLength;
$validator = new Validation();
$validation->add(
"name_last",
new StringLength(
[
"max" => 50,
"min" => 2,
"messageMaximum" => "We don't like really long names",
"messageMinimum" => "We want more than just their initials",
"includedMaximum" => true,
"includedMinimum" => false,
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new StringLength(
[
"max" => [
"name_last" => 50,
"name_first" => 40,
],
"min" => [
"name_last" => 2,
"name_first" => 4,
],
"messageMaximum" => [
"name_last" => "We don't like really long last names",
"name_first" => "We don't like really long first names",
],
"messageMinimum" => [
"name_last" => "We don't like too short last names",
"name_first" => "We don't like too short first names",
],
"includedMaximum" => [
"name_last" => false,
"name_first" => true,
],
"includedMinimum" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
public function __construct( array $options = [] );
Constructor
Namespace | Phalcon\Filter\Validation\Validator\StringLength | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\Exception | Extends | AbstractValidator |
Validates that a string has the specified maximum constraints The test is passed if for a string’s length L, L<=max, i.e. L must be at most max.
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Max;
$validator = new Validation();
$validation->add(
"name_last",
new Max(
[
"max" => 50,
"message" => "We don't like really long names",
"included" => true
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new Max(
[
"max" => [
"name_last" => 50,
"name_first" => 40,
],
"message" => [
"name_last" => "We don't like really long last names",
"name_first" => "We don't like really long first names",
],
"included" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
//
protected template = Field :field must not exceed :max characters long;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator\StringLength | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\Exception | Extends | AbstractValidator |
Validates that a string has the specified minimum constraints The test is passed if for a string’s length L, min<=L, i.e. L must be at least min.
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Min;
$validator = new Validation();
$validation->add(
"name_last",
new Min(
[
"min" => 2,
"message" => "We want more than just their initials",
"included" => true
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new Min(
[
"min" => [
"name_last" => 2,
"name_first" => 4,
],
"message" => [
"name_last" => "We don't like too short last names",
"name_first" => "We don't like too short first names",
],
"included" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
//
protected template = Field :field must be at least :min characters long;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Mvc\Model, Phalcon\Mvc\ModelInterface, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractCombinedFieldsValidator, Phalcon\Filter\Validation\Exception | Extends | AbstractCombinedFieldsValidator |
Comprueba que un campo sea único en la tabla relacionada
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Uniqueness as UniquenessValidator;
$validator = new Validation();
$validator->add(
"username",
new UniquenessValidator(
[
"model" => new Users(),
"message" => ":field must be unique",
]
)
);
Atributo diferente del campo:
$validator->add(
"username",
new UniquenessValidator(
[
"model" => new Users(),
"attribute" => "nick",
]
)
);
En el modelo:
$validator->add(
"username",
new UniquenessValidator()
);
Combinación de campos en el modelo:
$validator->add(
[
"firstName",
"lastName",
],
new UniquenessValidator()
);
Es posible convertir valores antes de la validación. Esto es útil en situaciones donde los valores necesitan convertirse para hacer la búsqueda en la base de datos:
$validator->add(
"username",
new UniquenessValidator(
[
"convert" => function (array $values) {
$values["username"] = strtolower($values["username"]);
return $values;
}
]
)
);
//
protected template = Field :field must be unique;
/**
* @var array|null
*/
private columnMap;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
protected function getColumnNameReal( mixed $record, string $field ): string;
En este caso se usa el mapa de columnas para obtener el nombre de columna real
protected function isUniqueness( Validation $validation, mixed $field ): bool;
protected function isUniquenessModel( mixed $record, array $field, array $values );
Método de unicidad utilizado para el modelo
Namespace | Phalcon\Filter\Validation\Validator | Uses | Phalcon\Messages\Message, Phalcon\Filter\Validation, Phalcon\Filter\Validation\AbstractValidator | Extends | AbstractValidator |
Comprueba si un valor tiene un formato de url
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Url as UrlValidator;
$validator = new Validation();
$validator->add(
"url",
new UrlValidator(
[
"message" => ":field must be a url",
]
)
);
$validator->add(
[
"url",
"homepage",
],
new UrlValidator(
[
"message" => [
"url" => "url must be a url",
"homepage" => "homepage must be a url",
]
]
)
);
//
protected template = Field :field must be a url;
public function __construct( array $options = [] );
Constructor
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Filter\Validation |
Esta es una clase base para validadores de campos combinados
public function getValidators(): array;
Ejecuta la validación
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Factory\AbstractFactory | Extends | AbstractFactory |
Este fichero es parte del Framework Phalcon.
(c) Phalcon Team [email protected]
Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.
public function __construct( array $services = [] );
Constructor TagFactory.
public function newInstance( string $name ): ValidatorInterface;
Crea una nueva instancia
protected function getExceptionClass(): string;
protected function getServices(): array;
Devuelve los adaptadores disponibles
Namespace | Phalcon\Filter\Validation | Uses | Phalcon\Filter\Validation |
Interface for Phalcon\Filter\Validation\AbstractValidator
public function getOption( string $key, mixed $defaultValue = null ): mixed;
Devuelve una opción en las opciones del validador. Devuelve null si la opción no ha sido configurada
public function getTemplate( string $field ): string;
Obtiene el mensaje plantilla
public function getTemplates(): array;
Obtiene las plantillas de mensaje
public function hasOption( string $key ): bool;
Comprueba si una opción está definida
public function setTemplate( string $template ): ValidatorInterface;
Establece un nuevo mensaje de plantilla
public function setTemplates( array $templates ): ValidatorInterface;
Limpia la plantilla actual y establece una nueva desde un vector,
public function validate( Validation $validation, mixed $field ): bool;
Ejecuta la validación