5.0
Secciones

Class Phalcon\Validation

Código fuente en GitHub

Namespace Phalcon   Uses Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Filter\FilterInterface, Phalcon\Messages\MessageInterface, Phalcon\Messages\Messages, Phalcon\Validation\ValidationInterface, Phalcon\Validation\Exception, Phalcon\Validation\ValidatorInterface, Phalcon\Validation\AbstractCombinedFieldsValidator   Extends Injectable   Implements ValidationInterface

Permite validar datos usando validadores personalizados o integrados

Propiedades

//
protected combinedFieldsValidators;

//
protected data;

//
protected entity;

//
protected filters;

//
protected labels;

//
protected messages;

//
protected validators;

//
protected values;

Métodos

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

Constructor Phalcon\Validation

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()

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 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( $validators )

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\Validation\AbstractCombinedFieldsValidator

Código fuente en GitHub

Namespace Phalcon\Validation   Extends AbstractValidator

Esta es una clase base para validadores de campos combinados

Abstract Class Phalcon\Validation\AbstractValidator

Código fuente en GitHub

Namespace Phalcon\Validation   Uses Phalcon\Helper\Arr, Phalcon\Messages\Message, Phalcon\Validation   Implements ValidatorInterface

Esta es una clase base para validadores

Propiedades

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

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

//
protected options;

Métodos

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

Constructor Phalcon\Validation\Validator

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 prepareCode( string $field ): int | null;

Prepara un código de validación.

protected function prepareLabel( Validation $validation, string $field ): mixed;

Prepara una etiqueta para el campo.

Abstract Class Phalcon\Validation\AbstractValidatorComposite

Código fuente en GitHub

Namespace Phalcon\Validation   Uses Phalcon\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\Validation\Exception

Código fuente en GitHub

Namespace Phalcon\Validation   Extends \Phalcon\Exception

Las excepciones lanzadas en las clases Phalcon\Validation* usarán esta clase

Interface Phalcon\Validation\ValidationInterface

Código fuente en GitHub

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

Interfaz para el componente Phalcon\Validation

Métodos

public function add( string $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( string $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\Validation\Validator\Alnum

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprobar caracter(es) alfanumérico(s)

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Alpha

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Verifica uno o varios caracteres alfabéticos

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Between

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\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\Validation;
use Phalcon\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\Validation\Validator\Callback

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\ValidatorInterface, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Llama a la función del usuario para la validación

use Phalcon\Validation;
use Phalcon\Validation\Validator\Callback as CallbackValidator;
use Phalcon\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\Validation\Validator\Confirmation

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Exception, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprueba si dos valores tienen el mismo valor

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\CreditCard

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprueba si un valor tiene un número de tarjeta de crédito válido

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Date

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses DateTime, Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Verifica si un valor es una fecha válida

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Digit

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprueba caracter(es) numérico(s)

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Email

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Verifica si un valor tiene un formato de correo electrónico correcto

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Exception

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Extends \Phalcon\Exception

Las excepciones lanzadas en las clases Phalcon\Validation\Validator* usarán esta clase

Class Phalcon\Validation\Validator\ExclusionIn

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator, Phalcon\Validation\Exception   Extends AbstractValidator

Comprueba si un valor no está incluido en una lista de valores

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Helper\Arr, Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidatorComposite, Phalcon\Validation\Validator\File\MimeType, Phalcon\Validation\Validator\File\Resolution\Equal, Phalcon\Validation\Validator\File\Resolution\Max, Phalcon\Validation\Validator\File\Resolution\Min, Phalcon\Validation\Validator\File\Size\Equal, Phalcon\Validation\Validator\File\Size\Max, Phalcon\Validation\Validator\File\Size\Min   Extends AbstractValidatorComposite

Verifica si un valor tiene un archivo correcto

use Phalcon\Validation;
use Phalcon\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",
        ]
    )
);

$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\Validation\Validator\File\AbstractFile

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Verifica si un valor tiene un archivo correcto

use Phalcon\Validation;
use Phalcon\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
    */
protected messageFileEmpty = Field :field must not be empty;

/**
    * File exceeds the file size set in PHP configuration
    */
protected messageIniSize = File :field exceeds the maximum file size;

/**
    * File is not valid
    */
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()

public function getMessageIniSize()

public function getMessageValid()

public function isAllowEmpty( Validation $validation, string $field ): bool;

Comprueba si se permite vacío

public function setMessageFileEmpty( $messageFileEmpty )

public function setMessageIniSize( $messageIniSize )

public function setMessageValid( $messageValid )

Class Phalcon\Validation\Validator\File\MimeType

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Exception   Extends AbstractFile

Comprueba si un valor tiene un tipo de medio de fichero correcto

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Resolution\Equal

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Resolution   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Comprueba si un fichero tiene una resolución correcta

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Resolution\Max

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Resolution   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Comprueba si un fichero tiene una resolución correcta

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Resolution\Min

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Resolution   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Comprueba si un fichero tiene una resolución correcta

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Size\Equal

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Size   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Verifica si un valor tiene un archivo correcto

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Size\Max

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Size   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Verifica si un valor tiene un archivo correcto

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\File\Size\Min

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\File\Size   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\Validator\File\AbstractFile   Extends AbstractFile

Verifica si un valor tiene un archivo correcto

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Identical

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Verifica si un valor es idéntico a otro

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\InclusionIn

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator, Phalcon\Validation\Exception   Extends AbstractValidator

Comprueba si un valor está incluido en una lista de valores

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Ip

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Validation, Phalcon\Validation\AbstractValidator, Phalcon\Messages\Message   Extends AbstractValidator

Comprueba direcciones IP

use Phalcon\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\Validation\Validator\Numericality

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprueba que haya un valor numérico válido

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\PresenceOf

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Valida que un valor no sea nulo ni cadena vacía

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\Regex

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Permite validar si el valor de un campo coincide con una expresión regular

use Phalcon\Validation;
use Phalcon\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\Validation\Validator\StringLength

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation\AbstractValidator, Phalcon\Validation\AbstractValidatorComposite, Phalcon\Validation\Validator\StringLength\Max, Phalcon\Validation\Validator\StringLength\Min, Phalcon\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\Validation;
use Phalcon\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\Validation\Validator\StringLength\Max

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\StringLength   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator, Phalcon\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\Validation;
use Phalcon\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\Validation\Validator\StringLength\Min

Código fuente en GitHub

Namespace Phalcon\Validation\Validator\StringLength   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator, Phalcon\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\Validation;
use Phalcon\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\Validation\Validator\Uniqueness

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Mvc\Model, Phalcon\Mvc\ModelInterface, Phalcon\Validation, Phalcon\Validation\AbstractCombinedFieldsValidator, Phalcon\Validation\Exception   Extends AbstractCombinedFieldsValidator

Comprueba que un campo sea único en la tabla relacionada

use Phalcon\Validation;
use Phalcon\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;

//
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\Validation\Validator\Url

Código fuente en GitHub

Namespace Phalcon\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Validation, Phalcon\Validation\AbstractValidator   Extends AbstractValidator

Comprueba si un valor tiene un formato de url

use Phalcon\Validation;
use Phalcon\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\Validation\ValidatorCompositeInterface

Código fuente en GitHub

Namespace Phalcon\Validation   Uses Phalcon\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\Validation\ValidatorFactory

Código fuente en GitHub

Namespace Phalcon\Validation   Uses Phalcon\Factory\AbstractFactory, Phalcon\Helper\Arr   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 getAdapters(): array;

Interface Phalcon\Validation\ValidatorInterface

Código fuente en GitHub

Namespace Phalcon\Validation   Uses Phalcon\Validation

Interfaz para Phalcon\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

General
Introducción
Notas de la Versión
Actualizar
Patrocinadores
Contribuciones
Resumen
Pull Requests
NFR (Solicitud de Nuevas Características)
Generación de Backtrace
Pruebas Reproducibles
Entorno de prueba
Estándar de codificación
Cómo Empezar
Instalación
Configuración de Servidor Web
Entornos
Devilbox
Nanobox
Herramientas de Desarrollo
DevTools
Depuración
Migraciones
Pruebas Unitarias
Tutoriales
Básico
Invo
REST
Vokuro
Casos de uso
Rendimiento
Núcleo
Índice del API
Application
Micro
CLI
Contenedor DI
MVC
Espacios de nombres
Servicios
Cache
Configuración
Escaper
Loader
Logger
Base de Datos
Capa
PHQL
ODM
Modelos
Comportamientos
Cache
Eventos
Metadatos
Relaciones
Transacciones
Validadores
Paginación
Migraciones
Front End
Recursos Activos
Mensajes Flash
Formularios
Imagen
Tag
Tag (legacy)
Vistas
Volt
Lógica de Negocio
Listas de Control de Acceso
Anotaciones
Controladores
Dispatcher
Gestor de Eventos
Filtros
Ruteo
Sesiones
Url
Validación
HTTP
Cookies
Consulta
Respuesta
Seguridad
Crypto
Seguridad
JWT
i18n
Internacionalización
Traducciones
Utilidad
Coleccion
Domain
Ayudantes
Registro
Versión