5.0
Ενότητες

Class Phalcon\Validation

Source on 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;

Methods

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

Source on GitHub

Namespace Phalcon\Validation   Extends AbstractValidator

This is a base class for combined fields validators

Abstract Class Phalcon\Validation\AbstractValidator

Source on 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;

Methods

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

Source on 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;

Methods

public function getValidators(): array

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

Executes the validation

Class Phalcon\Validation\Exception

Source on GitHub

Namespace Phalcon\Validation   Extends \Phalcon\Exception

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

Interface Phalcon\Validation\ValidationInterface

Source on GitHub

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

Interface for the Phalcon\Validation component

Methods

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Alpha

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Between

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Callback

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Confirmation

Source on 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;

Methods

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

Κατασκευαστής

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Date

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Digit

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Email

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Exception

Source on GitHub

Namespace Phalcon\Validation\Validator   Extends \Phalcon\Exception

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

Class Phalcon\Validation\Validator\ExclusionIn

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\File

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

Methods

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

Κατασκευαστής

Abstract Class Phalcon\Validation\Validator\File\AbstractFile

Source on 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;

Methods

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

Source on 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;

Methods

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Identical

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\InclusionIn

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Ip

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

Constants

const VERSION_4 = FILTER_FLAG_IPV4;
const VERSION_6 = FILTER_FLAG_IPV6;

Properties

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

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Numericality

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\PresenceOf

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Regex

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\StringLength

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

Methods

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

Κατασκευαστής

Class Phalcon\Validation\Validator\StringLength\Max

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\StringLength\Min

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Class Phalcon\Validation\Validator\Uniqueness

Source on 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;

Methods

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

Κατασκευαστής

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

Source on 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;

Methods

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

Κατασκευαστής

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

Executes the validation

Interface Phalcon\Validation\ValidatorCompositeInterface

Source on GitHub

Namespace Phalcon\Validation   Uses Phalcon\Validation

This is a base class for combined fields validators

Methods

public function getValidators(): array;

Executes the validation

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

Executes the validation

Class Phalcon\Validation\ValidatorFactory

Source on 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.

Methods

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

Source on GitHub

Namespace Phalcon\Validation   Uses Phalcon\Validation

Interface for Phalcon\Validation\AbstractValidator

Methods

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

Γενικά
Εισαγωγή
Σημειώσεις έκδοσης
Αναβάθμιση
Σπόνσορες
Συνεισφορές
Επισκόπηση
Pull Requests
NFR
Δημιουργία Οπισθοεντοπισμού
Αναπαραγώγιμες Δοκιμές
Περιβάλλον δοκιμών
Πρότυπο Κωδικοποίησης
Ξεκινώντας
Εγκατάσταση
Εγκατάσταση του διακομιστή Web
Περιβάλλοντα
Devilbox
Nanobox
Εργαλεία ανάπτυξης
DevTools
Εντοπισμός σφαλμάτων
Μεταβάσεις
Τεστ Ενότητας
Οδηγοί εκμάθησης
Βασικό
Invo
REST
Vokuro
Περίπτωση Χρήσης
Απόδοση
Πυρήνας
Δείκτης API
Εφαρμογή
Micro
Cli
DI Container
MVC
Χώροι ονομάτων
Υπηρεσίες
Μνήμη cache
Ρυθμίσεις
Escaper
Φορτωτής
Logger
Βάση Δεδομένων
Στρώμα
PHQL
ODM
Μοντέλα
Συμπεριφορές
Μνήμη cache
Γεγονότα
Μεταδεδομένα
Σχέσεις
Συναλλαγές
Επικυρωτές
Σελιδοποίηση
Μεταβάσεις
Front End
Πόροι
Flash μηνύματα
Φόρμες
Εικόνες
Tag
Tag (legacy)
Προβολή
Volt
Επιχειρηματική λογική
Λίστες Ελέγχου Πρόσβασης
Σχολιασμοί
Ελεγκτές
Αποστολέας
Διαχείριση Γεγονότων
Φίλτρα
Δρομολόγηση
Συνεδρίες
Διεύθυνση URL
Επικύρωση
HTTP
Cookies
Αίτηση
Ανταπόκριση
Ασφάλεια
Κρυπτογραφία
Ασφάλεια
JWT
i18n
Διεθνοποίηση
Μετάφραση
Εργαλεία
Συλλογή
Τομέας
Βοηθός
Μητρώο
Έκδοση