5.0
Sections

Class Phalcon\Validation

Исходный код на 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

Allows to validate data using custom or built-in validators

Properties

//
protected combinedFieldsValidators;

//
protected data;

//
protected entity;

//
protected filters;

//
protected labels;

//
protected messages;

//
protected validators;

//
protected values;

Методы

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

Phalcon\Validation constructor

public function add( mixed $field, ValidatorInterface $validator ): ValidationInterface;

Adds a validator to a field

public function appendMessage( MessageInterface $message ): ValidationInterface;

Appends a message to the messages list

public function bind( mixed $entity, mixed $data ): ValidationInterface;

Assigns the data to an entity The entity is used to obtain the validation values

public function getData()

public function getEntity(): mixed;

Returns the bound entity

public function getFilters( string $field = null ): mixed | null;

Returns all the filters or a specific one

public function getLabel( mixed $field ): string;

Get label for field

public function getMessages(): Messages;

Returns the registered validators

public function getValidators(): array;

Returns the validators added to the validation

public function getValue( string $field ): mixed | null;

Gets the a value to validate in the array/object data source

public function rule( mixed $field, ValidatorInterface $validator ): ValidationInterface;

Alias of add method

public function rules( mixed $field, array $validators ): ValidationInterface;

Adds the validators to a field

public function setEntity( mixed $entity ): void;

Sets the bound entity

public function setFilters( mixed $field, mixed $filters ): ValidationInterface;

Adds filters to the field

public function setLabels( array $labels ): void;

Adds labels for fields

public function setValidators( $validators )

public function validate( mixed $data = null, mixed $entity = null ): Messages;

Validate a set of data according to a set of rules

protected function preChecking( mixed $field, ValidatorInterface $validator ): bool;

Internal validations, if it returns true, then skip the current validator

Abstract Class Phalcon\Validation\AbstractCombinedFieldsValidator

Исходный код на GitHub

Namespace Phalcon\Validation   Extends AbstractValidator

This is a base class for combined fields validators

Abstract Class Phalcon\Validation\AbstractValidator

Исходный код на GitHub

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

This is a base class for validators

Properties

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

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

//
protected options;

Методы

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

Phalcon\Validation\Validator constructor

public function getOption( string $key, mixed $defaultValue = null ): mixed;

Returns an option in the validator’s options Returns null if the option hasn’t set

public function getTemplate( string $field = null ): string;

Get the template message

public function getTemplates(): array;

Get templates collection object

public function hasOption( string $key ): bool;

Checks if an option is defined

public function messageFactory( Validation $validation, mixed $field, array $replacements = [] ): Message;

Create a default message by factory

public function setOption( string $key, mixed $value ): void;

Sets an option in the validator

public function setTemplate( string $template ): ValidatorInterface;

Set a new template message

public function setTemplates( array $templates ): ValidatorInterface;

Clear current templates and set new from an array,

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

Executes the validation

protected function prepareCode( string $field ): int | null;

Prepares a validation code.

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

Prepares a label for the field.

Abstract Class Phalcon\Validation\AbstractValidatorComposite

Исходный код на GitHub

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

This is a base class for combined fields validators

Properties

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

Методы

public function getValidators(): array

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

Executes the validation

Class Phalcon\Validation\Exception

Исходный код на GitHub

Namespace Phalcon\Validation   Extends \Phalcon\Exception

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

Interface Phalcon\Validation\ValidationInterface

Исходный код на GitHub

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

Interface for the Phalcon\Validation component

Методы

public function add( string $field, ValidatorInterface $validator ): ValidationInterface;

Adds a validator to a field

public function appendMessage( MessageInterface $message ): ValidationInterface;

Appends a message to the messages list

public function bind( mixed $entity, mixed $data ): ValidationInterface;

Assigns the data to an entity The entity is used to obtain the validation values

public function getEntity(): mixed;

Returns the bound entity

public function getFilters( string $field = null ): mixed | null;

Returns all the filters or a specific one

public function getLabel( string $field ): string;

Get label for field

public function getMessages(): Messages;

Returns the registered validators

public function getValidators(): array;

Returns the validators added to the validation

public function getValue( string $field ): mixed | null;

Gets the a value to validate in the array/object data source

public function rule( string $field, ValidatorInterface $validator ): ValidationInterface;

Alias of add method

public function rules( string $field, array $validators ): ValidationInterface;

Adds the validators to a field

public function setFilters( string $field, mixed $filters ): ValidationInterface;

Adds filters to the field

public function setLabels( array $labels ): void;

Adds labels for fields

public function validate( mixed $data = null, mixed $entity = null ): Messages;

Validate a set of data according to a set of rules

Class Phalcon\Validation\Validator\Alnum

Исходный код на GitHub

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

Check for alphanumeric character(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",
            ],
        ]
    )
);

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Alpha

Исходный код на GitHub

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

Check for alphabetic character(s)

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Between

Исходный код на GitHub

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

Validates that a value is between an inclusive range of two values. 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",
            ],
        ]
    )
);

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Callback

Исходный код на GitHub

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

Calls user function for validation

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Confirmation

Исходный код на GitHub

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

Checks that two values have the same value

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

Properties

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

Методы

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

Constructor

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

Executes the validation

final protected function compare( string $a, string $b ): bool;

Compare strings

Class Phalcon\Validation\Validator\CreditCard

Исходный код на GitHub

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

Checks if a value has a valid credit card number

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Date

Исходный код на GitHub

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

Checks if a value is a valid date

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Digit

Исходный код на GitHub

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

Check for numeric character(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",
            ],
        ]
    )
);

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Email

Исходный код на GitHub

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

Checks if a value has a correct e-mail format

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Exception

Исходный код на GitHub

Namespace Phalcon\Validation\Validator   Extends \Phalcon\Exception

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

Class Phalcon\Validation\Validator\ExclusionIn

Исходный код на GitHub

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

Check if a value is not included into a list of values

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\File

Исходный код на 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

Checks if a value has a correct file

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

Методы

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

Constructor

Abstract Class Phalcon\Validation\Validator\File\AbstractFile

Исходный код на GitHub

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

Checks if a value has a correct file

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

Properties

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

Методы

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

Check upload

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

Check if upload is empty

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

Check if upload is valid

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

Check if uploaded file is larger than PHP allowed size

public function getFileSizeInBytes( string $size ): double;

Convert a string like “2.5MB” in bytes

public function getMessageFileEmpty()

public function getMessageIniSize()

public function getMessageValid()

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

Check on empty

public function setMessageFileEmpty( $messageFileEmpty )

public function setMessageIniSize( $messageIniSize )

public function setMessageValid( $messageValid )

Class Phalcon\Validation\Validator\File\MimeType

Исходный код на GitHub

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

Checks if a value has a correct file mime type

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

Properties

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

Методы

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a file has the right resolution

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

Properties

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

Методы

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

Constructor

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a file has the right resolution

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

Properties

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

Методы

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

Constructor

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a file has the right resolution

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

Properties

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

Методы

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

Constructor

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a value has a correct file

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

Properties

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

Методы

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

Constructor

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a value has a correct file

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

Properties

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

Методы

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

Constructor

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

Executes the validation

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

Исходный код на GitHub

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

Checks if a value has a correct file

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Identical

Исходный код на GitHub

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

Checks if a value is identical to other

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\InclusionIn

Исходный код на GitHub

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

Check if a value is included into a list of values

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Ip

Исходный код на GitHub

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

Check for IP addresses

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

Константы

const VERSION_4 = FILTER_FLAG_IPV4;
const VERSION_6 = FILTER_FLAG_IPV6;

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Numericality

Исходный код на GitHub

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

Check for a valid numeric value

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\PresenceOf

Исходный код на GitHub

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

Validates that a value is not null or empty string

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

Properties

//
protected template = Field :field is required;

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Regex

Исходный код на GitHub

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

Allows validate if the value of a field matches a regular expression

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\StringLength

Исходный код на 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. Since Phalcon v4.0 this validator works like a container

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

Методы

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

Constructor

Class Phalcon\Validation\Validator\StringLength\Max

Исходный код на 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,
            ]
        ]
    )
);

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\StringLength\Min

Исходный код на 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,
            ]
        ]
    )
);

Properties

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

Методы

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

Constructor

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

Executes the validation

Class Phalcon\Validation\Validator\Uniqueness

Исходный код на 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

Check that a field is unique in the related table

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

Different attribute from the field:

$validator->add(
    "username",
    new UniquenessValidator(
        [
            "model"     => new Users(),
            "attribute" => "nick",
        ]
    )
);

In model:

$validator->add(
    "username",
    new UniquenessValidator()
);

Combination of fields in model:

$validator->add(
    [
        "firstName",
        "lastName",
    ],
    new UniquenessValidator()
);

It is possible to convert values before validation. This is useful in situations where values need to be converted to do the database lookup:

$validator->add(
    "username",
    new UniquenessValidator(
        [
            "convert" => function (array $values) {
                $values["username"] = strtolower($values["username"]);

                return $values;
            }
        ]
    )
);

Properties

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

//
private columnMap;

Методы

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

Constructor

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

Executes the validation

protected function getColumnNameReal( mixed $record, string $field ): string;

The column map is used in the case to get real column name

protected function isUniqueness( Validation $validation, mixed $field ): bool;

protected function isUniquenessModel( mixed $record, array $field, array $values );

Uniqueness method used for model

Class Phalcon\Validation\Validator\Url

Исходный код на GitHub

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

Checks if a value has a url format

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

Properties

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

Методы

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

Constructor

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

Executes the validation

Interface Phalcon\Validation\ValidatorCompositeInterface

Исходный код на GitHub

Namespace Phalcon\Validation   Uses Phalcon\Validation

This is a base class for combined fields validators

Методы

public function getValidators(): array;

Executes the validation

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

Executes the validation

Class Phalcon\Validation\ValidatorFactory

Исходный код на GitHub

Namespace Phalcon\Validation   Uses Phalcon\Factory\AbstractFactory, Phalcon\Helper\Arr   Extends AbstractFactory

This file is part of the Phalcon Framework.

(c) Phalcon Team [email protected]

For the full copyright and license information, please view the LICENSE.txt file that was distributed with this source code.

Методы

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

TagFactory constructor.

public function newInstance( string $name ): ValidatorInterface;

Creates a new instance

protected function getAdapters(): array;

Interface Phalcon\Validation\ValidatorInterface

Исходный код на GitHub

Namespace Phalcon\Validation   Uses Phalcon\Validation

Interface for Phalcon\Validation\AbstractValidator

Методы

public function getOption( string $key, mixed $defaultValue = null ): mixed;

Returns an option in the validator’s options Returns null if the option hasn’t set

public function getTemplate( string $field ): string;

Get the template message

public function getTemplates(): array;

Get message templates

public function hasOption( string $key ): bool;

Checks if an option is defined

public function setTemplate( string $template ): ValidatorInterface;

Set a new template message

public function setTemplates( array $templates ): ValidatorInterface;

Clear current template and set new from an array,

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

Executes the validation

Главная
Введение
Примечания к выпуску
Обновление
Спонсоры
Вклад
Введение
Пулл реквесты
NFR
Генерация трассировки выполнения
Воспроизводимые тесты
Тестовое окружение
Coding Standard
Приступая к работе
Установка
Настройка веб-сервера
Окружение
Devilbox
Nanobox
Инструменты разработчика
Инструменты разработчика
Отладка
Migrations
Unit Testing
Уроки
Основы
Invo
REST
Vokuro
Пример использования
Производительность
Ядро
API Index
Application
Micro
CLI
DI контейнер
MVC
Namespaces
Сервисы
Кэш
Конфигурация
Escaper
Loader
Журналирование
База данных
Слой
PHQL
ODM
Модели
Behaviors
Кэш
События
Metadata
Relationships
Транзакции
Валидаторы
Постраничная навигация
Migrations
Фронтенд
Медиа-ресурсы
Всплывающие сообщения
Формы
Изображения
Теги
Tag (legacy)
Представления
Volt
Бизнес-логика
Контроль доступа
Аннотации
Контроллеры
Dispatcher
Управление событиями
Фильтры
Маршрутизация
Сессии
URL
Валидация
HTTP
Cookies
Request
Response
Security
Crypto
Security
JWT
i18n
Internationalization
Helper
Utility
Collection
Domain
Helper
Registry
Version