Secciones

Class Phalcon\Filter\Exception

Código fuente en GitHub

Namespace Phalcon\Filter   Extends \Exception

Phalcon\Filter\Exception

Las excepciones lanzadas en Phalcon\Filter usarán esta clase

Class Phalcon\Filter\Filter

Código fuente en GitHub

Namespace Phalcon\Filter   Implements FilterInterface

Carga perezosamente, almacena y expone objetos saneadores

Constantes

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;

Propiedades

/**
 * @var array
 */
protected mapper;

/**
 * @var array
 */
protected services;

Métodos

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

Class Phalcon\Filter\FilterFactory

Código fuente en GitHub

Namespace Phalcon\Filter   Uses Phalcon\Filter\Filter

Class FilterFactory

@package Phalcon\Filter

Métodos

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

Interface Phalcon\Filter\FilterInterface

Código fuente en GitHub

Namespace Phalcon\Filter

Carga perezosamente, almacena y expone objetos saneadores

Métodos

public function sanitize( mixed $value, mixed $sanitizers, bool $noRecursive = bool ): mixed;

Sanea un valor con un único o conjunto de saneadores especificados

Class Phalcon\Filter\Sanitize\AbsInt

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\AbsInt

Sanea un valor a un entero absoluto

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Alnum

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Alnum

Sanea un valor a un valor alfanumérico

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Alpha

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Alpha

Sanea un valor a un valor alfabético

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\BoolVal

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\BoolVal

Sanea un valor a booleano

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Email

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Email

Sanea una cadena email

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\FloatVal

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\FloatVal

Sane a un valor a real

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\IntVal

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\IntVal

Sanea un valor a entero

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Lower

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Lower

Sanea un valor a minúsculas

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\LowerFirst

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\LowerFirst

Sanea un valor a lcfirst

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Regex

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Regex

Sanea un valor realizando preg_replace

Métodos

public function __invoke( mixed $input, mixed $pattern, mixed $replace );

Class Phalcon\Filter\Sanitize\Remove

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Remove

Sanea un valor eliminando partes de una cadena

Métodos

public function __invoke( mixed $input, mixed $replace );

Class Phalcon\Filter\Sanitize\Replace

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Replace

Sanea un valor sustituyendo partes de una cadena

Métodos

public function __invoke( mixed $input, mixed $from, mixed $to );

Class Phalcon\Filter\Sanitize\Special

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Special

Sanea caracteres especiales de un valor

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\SpecialFull

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\SpecialFull

Sanee caracteres especiales de un valor (htmlspecialchars() y ENT_QUOTES)

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\StringVal

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Sanea un valor a cadena

Métodos

public function __invoke( string $input, int $flags = int ): string;

Class Phalcon\Filter\Sanitize\StringValLegacy

Código fuente en GitHub

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

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Striptags

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Striptags

Sanea un valor a striptags

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Trim

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Trim

Sanea un valor eliminando espacios iniciales y finales

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Upper

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Upper

Sanea un valor a mayúsculas

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\UpperFirst

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\UpperFirst

Sanea un valor a ucfirst

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\UpperWords

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\UpperWords

Sanea un valor a mayúsculas el primer carácter de cada palabra

Métodos

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Url

Código fuente en GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Url

Sanea un valor url

Métodos

public function __invoke( mixed $input );

Class Phalcon\Filter\Validation

Código fuente en GitHub

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

Propiedades

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

Métodos

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

Abstract Class Phalcon\Filter\Validation\AbstractCombinedFieldsValidator

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Extends AbstractValidator

Esta es una clase base para validadores de campos combinados

Abstract Class Phalcon\Filter\Validation\AbstractValidator

Código fuente en GitHub

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

Propiedades

/**
    * Message template
    *
    * @var string|null
    */
protected template;

/**
    * Message templates
    *
    * @var array
    */
protected templates;

/**
 * @var array
 */
protected options;

Métodos

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.

Abstract Class Phalcon\Filter\Validation\AbstractValidatorComposite

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Uses Phalcon\Filter\Validation   Extends AbstractValidator   Implements ValidatorCompositeInterface

Esta es una clase base para validadores de campos combinados

Propiedades

/**
 * @var array
 */
protected validators;

Métodos

public function getValidators(): array;
public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Exception

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Extends \Exception

Exceptions thrown in Phalcon\Filter\Validation* classes will use this class

Interface Phalcon\Filter\Validation\ValidationInterface

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Uses Phalcon\Di\Injectable, Phalcon\Messages\MessageInterface, Phalcon\Messages\Messages

Interface for the Phalcon\Filter\Validation component

Métodos

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

Class Phalcon\Filter\Validation\Validator\Alnum

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must contain only letters and numbers;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Alpha

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must contain only letters;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Between

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must be within the range of :min to :max;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Callback

Código fuente en GitHub

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."
                        ]
                    );
                }
            }
        ]
    )
);

Propiedades

//
protected template = Field :field must match the callback function;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Confirmation

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must be the same as :with;

Métodos

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

Class Phalcon\Filter\Validation\Validator\CreditCard

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field is not valid for a credit card number;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Date

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field is not a valid date;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Digit

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must be numeric;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Email

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must be an email address;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Exception

Código fuente en GitHub

Namespace Phalcon\Filter\Validation\Validator   Extends \Exception

Exceptions thrown in Phalcon\Filter\Validation\Validator* classes will use this class

Class Phalcon\Filter\Validation\Validator\ExclusionIn

Código fuente en GitHub

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],
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field must not be a part of list: :domain;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File

Código fuente en GitHub

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",
            ],
        ]
    )
);

Métodos

public function __construct( array $options = [] );

Constructor

Abstract Class Phalcon\Filter\Validation\Validator\File\AbstractFile

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

/**
 * 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;

Métodos

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

Class Phalcon\Filter\Validation\Validator\File\MimeType

Código fuente en GitHub

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",
            ]
        ]
    )
);

Propiedades

//
protected template = File :field must be of type: :types;

Métodos

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Resolution\Equal

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = The resolution of the field :field has to be equal :resolution;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Resolution\Max

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = File :field exceeds the maximum resolution of :resolution;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Resolution\Min

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = File :field can not have the minimum resolution of :resolution;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Size\Equal

Código fuente en GitHub

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)",
            ],
        ]
    )
);

Propiedades

//
protected template = File :field does not have the exact :size file size;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Size\Max

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = File :field exceeds the size of :size;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\File\Size\Min

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = File :field can not have the minimum size of :size;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Identical

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field does not have the expected value;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\InclusionIn

Código fuente en GitHub

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],
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field must be a part of list: :domain;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Ip

Código fuente en GitHub

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,
            ],
        ]
    )
);

Constantes

const VERSION_4 = FILTER_FLAG_IPV4;
const VERSION_6 = FILTER_FLAG_IPV6;

Propiedades

//
protected template = Field :field must be a valid IP address;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Numericality

Código fuente en GitHub

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",
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field does not have a valid numeric format;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\PresenceOf

Código fuente en GitHub

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",
            ],
        ]
    )
);

Propiedades

//
protected template = Field :field is required;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Regex

Código fuente en GitHub

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",
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field does not match the required format;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\StringLength

Código fuente en GitHub

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,
            ]
        ]
    )
);

Métodos

public function __construct( array $options = [] );

Constructor

Class Phalcon\Filter\Validation\Validator\StringLength\Max

Código fuente en GitHub

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,
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field must not exceed :max characters long;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\StringLength\Min

Código fuente en GitHub

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,
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field must be at least :min characters long;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\Validator\Uniqueness

Código fuente en GitHub

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;
            }
        ]
    )
);

Propiedades

//
protected template = Field :field must be unique;

/**
 * @var array|null
 */
private columnMap;

Métodos

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

Class Phalcon\Filter\Validation\Validator\Url

Código fuente en GitHub

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",
            ]
        ]
    )
);

Propiedades

//
protected template = Field :field must be a url;

Métodos

public function __construct( array $options = [] );

Constructor

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Interface Phalcon\Filter\Validation\ValidatorCompositeInterface

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Uses Phalcon\Filter\Validation

Esta es una clase base para validadores de campos combinados

Métodos

public function getValidators(): array;

Ejecuta la validación

public function validate( Validation $validation, mixed $field ): bool;

Ejecuta la validación

Class Phalcon\Filter\Validation\ValidatorFactory

Código fuente en GitHub

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.

Métodos

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

Interface Phalcon\Filter\Validation\ValidatorInterface

Código fuente en GitHub

Namespace Phalcon\Filter\Validation   Uses Phalcon\Filter\Validation

Interface for Phalcon\Filter\Validation\AbstractValidator

Métodos

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