섹션

Class Phalcon\Filter\Exception

Source on GitHub

Namespace Phalcon\Filter   Extends \Exception

Phalcon\Filter\Exception

Exceptions thrown in Phalcon\Filter will use this class

Class Phalcon\Filter\Filter

Source on GitHub

Namespace Phalcon\Filter   Implements FilterInterface

Lazy loads, stores and exposes sanitizer objects

Constants

const FILTER_ABSINT = absint;
const FILTER_ALNUM = alnum;
const FILTER_ALPHA = alpha;
const FILTER_BOOL = bool;
const FILTER_EMAIL = email;
const FILTER_FLOAT = float;
const FILTER_INT = int;
const FILTER_LOWER = lower;
const FILTER_LOWERFIRST = lowerfirst;
const FILTER_REGEX = regex;
const FILTER_REMOVE = remove;
const FILTER_REPLACE = replace;
const FILTER_SPECIAL = special;
const FILTER_SPECIALFULL = specialfull;
const FILTER_STRING = string;
const FILTER_STRING_LEGACY = stringlegacy;
const FILTER_STRIPTAGS = striptags;
const FILTER_TRIM = trim;
const FILTER_UPPER = upper;
const FILTER_UPPERFIRST = upperfirst;
const FILTER_UPPERWORDS = upperwords;
const FILTER_URL = url;

Properties

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

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

Methods

public function __call( string $name, array $args );

Magic call to make the helper objects available as methods.

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

Filter constructor.

public function get( string $name ): mixed;

Get a service. If it is not in the mapper array, create a new object, set it and then return it.

public function has( string $name ): bool;

Checks if a service exists in the map array

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

Sanitizes a value with a specified single or set of sanitizers

public function set( string $name, mixed $service ): void;

Set a new service to the mapper array

protected function init( array $mapper ): void;

Loads the objects in the internal mapper array

Class Phalcon\Filter\FilterFactory

Source on GitHub

Namespace Phalcon\Filter   Uses Phalcon\Filter\Filter

Class FilterFactory

@package Phalcon\Filter

Methods

public function newInstance(): FilterInterface;

Returns a Locator object with all the helpers defined in anonymous functions

protected function getServices(): array;

Returns the available adapters

Interface Phalcon\Filter\FilterInterface

Source on GitHub

Namespace Phalcon\Filter

Lazy loads, stores and exposes sanitizer objects

Methods

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

Sanitizes a value with a specified single or set of sanitizers

Class Phalcon\Filter\Sanitize\AbsInt

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\AbsInt

Sanitizes a value to absolute integer

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Alnum

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Alnum

Sanitizes a value to an alphanumeric value

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Alpha

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Alpha

Sanitizes a value to an alpha value

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\BoolVal

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\BoolVal

Sanitizes a value to boolean

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Email

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Email

Sanitizes an email string

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\FloatVal

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\FloatVal

Sanitizes a value to float

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\IntVal

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\IntVal

Sanitizes a value to integer

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Lower

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Lower

Sanitizes a value to lowercase

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\LowerFirst

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\LowerFirst

Sanitizes a value to lcfirst

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Regex

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Regex

Sanitizes a value performing preg_replace

Methods

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

Class Phalcon\Filter\Sanitize\Remove

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Remove

Sanitizes a value removing parts of a string

Methods

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

Class Phalcon\Filter\Sanitize\Replace

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Replace

Sanitizes a value replacing parts of a string

Methods

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

Class Phalcon\Filter\Sanitize\Special

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Special

Sanitizes a value special characters

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\SpecialFull

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\SpecialFull

Sanitizes a value special characters (htmlspecialchars() and ENT_QUOTES)

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\StringVal

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Sanitizes a value to string

Methods

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

Class Phalcon\Filter\Sanitize\StringValLegacy

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Sanitizes a value to string using filter_var(). The filter provides backwards compatibility with versions prior to v5. For PHP higher or equal to 8.1, the filter will remain the string unchanged. If anything other than a string is passed, the method will return false

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Sanitize\Striptags

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Striptags

Sanitizes a value striptags

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Trim

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Trim

Sanitizes a value removing leading and trailing spaces

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Upper

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Upper

Sanitizes a value to uppercase

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\UpperFirst

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\UpperFirst

Sanitizes a value to ucfirst

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\UpperWords

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\UpperWords

Sanitizes a value to uppercase the first character of each word

Methods

public function __invoke( string $input );

Class Phalcon\Filter\Sanitize\Url

Source on GitHub

Namespace Phalcon\Filter\Sanitize

Phalcon\Filter\Sanitize\Url

Sanitizes a value url

Methods

public function __invoke( mixed $input );

Class Phalcon\Filter\Validation

Source on GitHub

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

Allows to validate data using custom or built-in validators

Properties

/**
 * @var array
 */
protected combinedFieldsValidators;

/**
 * @var mixed
 */
protected data;

/**
 * @var object|null
 */
protected entity;

/**
 * @var array
 */
protected filters;

/**
 * @var array
 */
protected labels;

/**
 * @var Messages|null
 */
protected messages;

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

/**
 * Calculated values
 *
 * @var array
 */
protected values;

Methods

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

Phalcon\Filter\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(): mixed;
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 getValueByData( mixed $data, string $field ): mixed | null;

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

public function getValueByEntity( mixed $entity, string $field ): mixed | null;

Gets the a value to validate in the object entity source

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

Alias 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( array $validators ): Validation;
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\Filter\Validation\AbstractCombinedFieldsValidator

Source on GitHub

Namespace Phalcon\Filter\Validation   Extends AbstractValidator

This is a base class for combined fields validators

Abstract Class Phalcon\Filter\Validation\AbstractValidator

Source on GitHub

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

This is a base class for validators

Properties

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

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

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

Methods

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

Phalcon\Filter\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 allowEmpty( mixed $field, mixed $value ): bool;

Checks if field can be empty.

protected function prepareCode( string $field ): int;

Prepares a validation code.

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

Prepares a label for the field.

Abstract Class Phalcon\Filter\Validation\AbstractValidatorComposite

Source on GitHub

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

Source on GitHub

Namespace Phalcon\Filter\Validation   Extends \Exception

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

Interface Phalcon\Filter\Validation\ValidationInterface

Source on GitHub

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

Interface for the Phalcon\Filter\Validation component

Methods

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 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( mixed $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\Filter\Validation\Validator\Alnum

Source on GitHub

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

Check for alphanumeric character(s)

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alnum as AlnumValidator;

$validator = new Validation();

$validator->add(
    "username",
    new AlnumValidator(
        [
            "message" => ":field must contain only alphanumeric characters",
        ]
    )
);

$validator->add(
    [
        "username",
        "name",
    ],
    new AlnumValidator(
        [
            "message" => [
                "username" => "username must contain only alphanumeric characters",
                "name"     => "name must contain only alphanumeric characters",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Alpha

Source on GitHub

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

Check for alphabetic character(s)

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alpha as AlphaValidator;

$validator = new Validation();

$validator->add(
    "username",
    new AlphaValidator(
        [
            "message" => ":field must contain only letters",
        ]
    )
);

$validator->add(
    [
        "username",
        "name",
    ],
    new AlphaValidator(
        [
            "message" => [
                "username" => "username must contain only letters",
                "name"     => "name must contain only letters",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Between

Source on GitHub

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

$validator = new Validation();

$validator->add(
    "price",
    new Between(
        [
            "minimum" => 0,
            "maximum" => 100,
            "message" => "The price must be between 0 and 100",
        ]
    )
);

$validator->add(
    [
        "price",
        "amount",
    ],
    new Between(
        [
            "minimum" => [
                "price"  => 0,
                "amount" => 0,
            ],
            "maximum" => [
                "price"  => 100,
                "amount" => 50,
            ],
            "message" => [
                "price"  => "The price must be between 0 and 100",
                "amount" => "The amount must be between 0 and 50",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Callback

Source on GitHub

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

Calls user function for validation

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Callback as CallbackValidator;
use Phalcon\Filter\Validation\Validator\Numericality as NumericalityValidator;

$validator = new Validation();

$validator->add(
    ["user", "admin"],
    new CallbackValidator(
        [
            "message" => "There must be only an user or admin set",
            "callback" => function($data) {
                if (!empty($data->getUser()) && !empty($data->getAdmin())) {
                    return false;
                }

                return true;
            }
        ]
    )
);

$validator->add(
    "amount",
    new CallbackValidator(
        [
            "callback" => function($data) {
                if (!empty($data->getProduct())) {
                    return new NumericalityValidator(
                        [
                            "message" => "Amount must be a number."
                        ]
                    );
                }
            }
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Confirmation

Source on GitHub

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

Checks that two values have the same value

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Confirmation;

$validator = new Validation();

$validator->add(
    "password",
    new Confirmation(
        [
            "message" => "Password doesn't match confirmation",
            "with"    => "confirmPassword",
        ]
    )
);

$validator->add(
    [
        "password",
        "email",
    ],
    new Confirmation(
        [
            "message" => [
                "password" => "Password doesn't match confirmation",
                "email"    => "Email doesn't match confirmation",
            ],
            "with" => [
                "password" => "confirmPassword",
                "email"    => "confirmEmail",
            ],
        ]
    )
);

Properties

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

Methods

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\Filter\Validation\Validator\CreditCard

Source on GitHub

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

Checks if a value has a valid credit card number

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\CreditCard as CreditCardValidator;

$validator = new Validation();

$validator->add(
    "creditCard",
    new CreditCardValidator(
        [
            "message" => "The credit card number is not valid",
        ]
    )
);

$validator->add(
    [
        "creditCard",
        "secondCreditCard",
    ],
    new CreditCardValidator(
        [
            "message" => [
                "creditCard"       => "The credit card number is not valid",
                "secondCreditCard" => "The second credit card number is not valid",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Date

Source on GitHub

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

Checks if a value is a valid date

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Date as DateValidator;

$validator = new Validation();

$validator->add(
    "date",
    new DateValidator(
        [
            "format"  => "d-m-Y",
            "message" => "The date is invalid",
        ]
    )
);

$validator->add(
    [
        "date",
        "anotherDate",
    ],
    new DateValidator(
        [
            "format" => [
                "date"        => "d-m-Y",
                "anotherDate" => "Y-m-d",
            ],
            "message" => [
                "date"        => "The date is invalid",
                "anotherDate" => "The another date is invalid",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Digit

Source on GitHub

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

Check for numeric character(s)

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Digit as DigitValidator;

$validator = new Validation();

$validator->add(
    "height",
    new DigitValidator(
        [
            "message" => ":field must be numeric",
        ]
    )
);

$validator->add(
    [
        "height",
        "width",
    ],
    new DigitValidator(
        [
            "message" => [
                "height" => "height must be numeric",
                "width"  => "width must be numeric",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Email

Source on GitHub

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

Checks if a value has a correct e-mail format

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Email as EmailValidator;

$validator = new Validation();

$validator->add(
    "email",
    new EmailValidator(
        [
            "message" => "The e-mail is not valid",
        ]
    )
);

$validator->add(
    [
        "email",
        "anotherEmail",
    ],
    new EmailValidator(
        [
            "message" => [
                "email"        => "The e-mail is not valid",
                "anotherEmail" => "The another e-mail is not valid",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Exception

Source on GitHub

Namespace Phalcon\Filter\Validation\Validator   Extends \Exception

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

Class Phalcon\Filter\Validation\Validator\ExclusionIn

Source on GitHub

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

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

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;

$validator = new Validation();

$validator->add(
    "status",
    new ExclusionIn(
        [
            "message" => "The status must not be A or B",
            "domain"  => [
                "A",
                "B",
            ],
        ]
    )
);

$validator->add(
    [
        "status",
        "type",
    ],
    new ExclusionIn(
        [
            "message" => [
                "status" => "The status must not be A or B",
                "type"   => "The type must not be 1 or "
            ],
            "domain" => [
                "status" => [
                    "A",
                    "B",
                ],
                "type"   => [1, 2],
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\File

Source on GitHub

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

Checks if a value has a correct file

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File as FileValidator;

$validator = new Validation();

$validator->add(
    "file",
    new FileValidator(
        [
            "maxSize"              => "2M",
            "messageSize"          => ":field exceeds the max file size (:size)",
            "allowedTypes"         => [
                "image/jpeg",
                "image/png",
            ],
            "messageType"          => "Allowed file types are :types",
            "maxResolution"        => "800x600",
            "messageMaxResolution" => "Max resolution of :field is :resolution",
            "messageFileEmpty"     => "File is empty",
            "messageIniSize"       => "Ini size is not valid",
            "messageValid"         => "File is not valid",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new FileValidator(
        [
            "maxSize" => [
                "file"        => "2M",
                "anotherFile" => "4M",
            ],
            "messageSize" => [
                "file"        => "file exceeds the max file size 2M",
                "anotherFile" => "anotherFile exceeds the max file size 4M",
            "allowedTypes" => [
                "file"        => [
                    "image/jpeg",
                    "image/png",
                ],
                "anotherFile" => [
                    "image/gif",
                    "image/bmp",
                ],
            ],
            "messageType" => [
                "file"        => "Allowed file types are image/jpeg and image/png",
                "anotherFile" => "Allowed file types are image/gif and image/bmp",
            ],
            "maxResolution" => [
                "file"        => "800x600",
                "anotherFile" => "1024x768",
            ],
            "messageMaxResolution" => [
                "file"        => "Max resolution of file is 800x600",
                "anotherFile" => "Max resolution of file is 1024x768",
            ],
        ]
    )
);

Methods

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

Constructor

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

Source on GitHub

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

Checks if a value has a correct file

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;

$validator = new Validation();

$validator->add(
    "file",
    new Size(
        [
            "maxSize"              => "2M",
            "messageSize"          => ":field exceeds the max file size (:size)",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new FileValidator(
        [
            "maxSize" => [
                "file"        => "2M",
                "anotherFile" => "4M",
            ],
            "messageSize" => [
                "file"        => "file exceeds the max file size 2M",
                "anotherFile" => "anotherFile exceeds the max file size 4M",
            ],
        ]
    )
);

Properties

/**
 * Empty is empty
 *
 * @var string
 */
protected messageFileEmpty = Field :field must not be empty;

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

/**
 * File is not valid
 *
 * @var string
 */
protected messageValid = Field :field is not valid;

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(): string;

Empty is empty

public function getMessageIniSize(): string;

File exceeds the file size set in PHP configuration

public function getMessageValid(): string;

File is not valid

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

Check on empty

public function setMessageFileEmpty( string $message ): void;

Empty is empty

public function setMessageIniSize( string $message ): void;

File exceeds the file size set in PHP configuration

public function setMessageValid( string $message ): void;

File is not valid

protected function checkIsUploadedFile( string $name ): bool;

Checks if a file has been uploaded; Internal check that can be overriden in a subclass if you do not want to check uploaded files

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

Source on GitHub

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

Checks if a value has a correct file mime type

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\MimeType;

$validator = new Validation();

$validator->add(
    "file",
    new MimeType(
        [
            "types" => [
                "image/jpeg",
                "image/png",
            ],
            "message" => "Allowed file types are :types"
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new MimeType(
        [
            "types" => [
                "file"        => [
                    "image/jpeg",
                    "image/png",
                ],
                "anotherFile" => [
                    "image/gif",
                    "image/bmp",
                ],
            ],
            "message" => [
                "file"        => "Allowed file types are image/jpeg and image/png",
                "anotherFile" => "Allowed file types are image/gif and image/bmp",
            ]
        ]
    )
);

Properties

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

Methods

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

Executes the validation

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

Source on GitHub

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

Checks if a file has the right resolution

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Equal;

$validator = new Validation();

$validator->add(
    "file",
    new Equal(
        [
            "resolution" => "800x600",
            "message"    => "The resolution of the field :field has to be equal :resolution",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Equal(
        [
            "resolution" => [
                "file"        => "800x600",
                "anotherFile" => "1024x768",
            ],
            "message" => [
                "file"        => "Equal resolution of file has to be 800x600",
                "anotherFile" => "Equal resolution of file has to be 1024x768",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Checks if a file has the right resolution

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Max;

$validator = new Validation();

$validator->add(
    "file",
    new Max(
        [
            "resolution"      => "800x600",
            "message"  => "Max resolution of :field is :resolution",
            "included" => true,
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Max(
        [
            "resolution" => [
                "file"        => "800x600",
                "anotherFile" => "1024x768",
            ],
            "included" => [
                "file"        => false,
                "anotherFile" => true,
            ],
            "message" => [
                "file"        => "Max resolution of file is 800x600",
                "anotherFile" => "Max resolution of file is 1024x768",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Checks if a file has the right resolution

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Min;

$validator = new Validation();

$validator->add(
    "file",
    new Min(
        [
            "resolution" => "800x600",
            "message"    => "Min resolution of :field is :resolution",
            "included"   => true,
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Min(
        [
            "resolution" => [
                "file"        => "800x600",
                "anotherFile" => "1024x768",
            ],
            "included" => [
                "file"        => false,
                "anotherFile" => true,
            ],
            "message" => [
                "file"        => "Min resolution of file is 800x600",
                "anotherFile" => "Min resolution of file is 1024x768",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Checks if a value has a correct file

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;

$validator = new Validation();

$validator->add(
    "file",
    new Equal(
        [
            "size"     => "2M",
            "included" => true,
            "message"  => ":field exceeds the equal file size (:size)",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Equal(
        [
            "size" => [
                "file"        => "2M",
                "anotherFile" => "4M",
            ],
            "included" => [
                "file"        => false,
                "anotherFile" => true,
            ],
            "message" => [
                "file"        => "file does not have the right file size",
                "anotherFile" => "anotherFile wrong file size (4MB)",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Checks if a value has a correct file

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;

$validator = new Validation();

$validator->add(
    "file",
    new Max(
        [
            "size"     => "2M",
            "included" => true,
            "message"  => ":field exceeds the max file size (:size)",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Max(
        [
            "size" => [
                "file"        => "2M",
                "anotherFile" => "4M",
            ],
            "included" => [
                "file"        => false,
                "anotherFile" => true,
            ],
            "message" => [
                "file"        => "file exceeds the max file size 2M",
                "anotherFile" => "anotherFile exceeds the max file size 4M",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Checks if a value has a correct file

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;

$validator = new Validation();

$validator->add(
    "file",
    new Min(
        [
            "size"     => "2M",
            "included" => true,
            "message"  => ":field exceeds the min file size (:size)",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new Min(
        [
            "size" => [
                "file"        => "2M",
                "anotherFile" => "4M",
            ],
            "included" => [
                "file"        => false,
                "anotherFile" => true,
            ],
            "message" => [
                "file"        => "file exceeds the min file size 2M",
                "anotherFile" => "anotherFile exceeds the min file size 4M",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Identical

Source on GitHub

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

Checks if a value is identical to other

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Identical;

$validator = new Validation();

$validator->add(
    "terms",
    new Identical(
        [
            "accepted" => "yes",
            "message" => "Terms and conditions must be accepted",
        ]
    )
);

$validator->add(
    [
        "terms",
        "anotherTerms",
    ],
    new Identical(
        [
            "accepted" => [
                "terms"        => "yes",
                "anotherTerms" => "yes",
            ],
            "message" => [
                "terms"        => "Terms and conditions must be accepted",
                "anotherTerms" => "Another terms  must be accepted",
            ],
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\InclusionIn

Source on GitHub

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

Check if a value is included into a list of values

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\InclusionIn;

$validator = new Validation();

$validator->add(
    "status",
    new InclusionIn(
        [
            "message" => "The status must be A or B",
            "domain"  => ["A", "B"],
        ]
    )
);

$validator->add(
    [
        "status",
        "type",
    ],
    new InclusionIn(
        [
            "message" => [
                "status" => "The status must be A or B",
                "type"   => "The status must be 1 or 2",
            ],
            "domain" => [
                "status" => ["A", "B"],
                "type"   => [1, 2],
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Ip

Source on GitHub

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

Check for IP addresses

use Phalcon\Filter\Validation\Validator\Ip as IpValidator;

$validator->add(
    "ip_address",
    new IpValidator(
        [
            "message"       => ":field must contain only ip addresses",
            "version"       => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
            "allowReserved" => false,   // False if not specified. Ignored for v6
            "allowPrivate"  => false,   // False if not specified
            "allowEmpty"    => false,
        ]
    )
);

$validator->add(
    [
        "source_address",
        "destination_address",
    ],
    new IpValidator(
        [
            "message" => [
                "source_address"      => "source_address must be a valid IP address",
                "destination_address" => "destination_address must be a valid IP address",
            ],
            "version" => [
                 "source_address"      => Ip::VERSION_4 | IP::VERSION_6,
                 "destination_address" => Ip::VERSION_4,
            ],
            "allowReserved" => [
                 "source_address"      => false,
                 "destination_address" => true,
            ],
            "allowPrivate" => [
                 "source_address"      => false,
                 "destination_address" => true,
            ],
            "allowEmpty" => [
                 "source_address"      => false,
                 "destination_address" => true,
            ],
        ]
    )
);

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 = [] );

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Numericality

Source on GitHub

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

Check for a valid numeric value

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Numericality;

$validator = new Validation();

$validator->add(
    "price",
    new Numericality(
        [
            "message" => ":field is not numeric",
        ]
    )
);

$validator->add(
    [
        "price",
        "amount",
    ],
    new Numericality(
        [
            "message" => [
                "price"  => "price is not numeric",
                "amount" => "amount is not numeric",
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\PresenceOf

Source on GitHub

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

Validates that a value is not null or empty string

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\PresenceOf;

$validator = new Validation();

$validator->add(
    "name",
    new PresenceOf(
        [
            "message" => "The name is required",
        ]
    )
);

$validator->add(
    [
        "name",
        "email",
    ],
    new PresenceOf(
        [
            "message" => [
                "name"  => "The name is required",
                "email" => "The email is required",
            ],
        ]
    )
);

Properties

//
protected template = Field :field is required;

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Regex

Source on GitHub

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

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

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Regex as RegexValidator;

$validator = new Validation();

$validator->add(
    "created_at",
    new RegexValidator(
        [
            "pattern" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
            "message" => "The creation date is invalid",
        ]
    )
);

$validator->add(
    [
        "created_at",
        "name",
    ],
    new RegexValidator(
        [
            "pattern" => [
                "created_at" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
                "name"       => "/^[a-z]$/",
            ],
            "message" => [
                "created_at" => "The creation date is invalid",
                "name"       => "The name is invalid",
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\StringLength

Source on GitHub

Namespace Phalcon\Filter\Validation\Validator   Uses Phalcon\Messages\Message, Phalcon\Filter\Validation\AbstractValidator, Phalcon\Filter\Validation\AbstractValidatorComposite, Phalcon\Filter\Validation\Validator\StringLength\Max, Phalcon\Filter\Validation\Validator\StringLength\Min, Phalcon\Filter\Validation\Exception   Extends AbstractValidatorComposite

Validates that a string has the specified maximum and minimum constraints The test is passed if for a string’s length L, min<=L<=max, i.e. L must be at least min, and at most max. Since Phalcon v4.0 this validator works like a container

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength as StringLength;

$validator = new Validation();

$validation->add(
    "name_last",
    new StringLength(
        [
            "max"             => 50,
            "min"             => 2,
            "messageMaximum"  => "We don't like really long names",
            "messageMinimum"  => "We want more than just their initials",
            "includedMaximum" => true,
            "includedMinimum" => false,
        ]
    )
);

$validation->add(
    [
        "name_last",
        "name_first",
    ],
    new StringLength(
        [
            "max" => [
                "name_last"  => 50,
                "name_first" => 40,
            ],
            "min" => [
                "name_last"  => 2,
                "name_first" => 4,
            ],
            "messageMaximum" => [
                "name_last"  => "We don't like really long last names",
                "name_first" => "We don't like really long first names",
            ],
            "messageMinimum" => [
                "name_last"  => "We don't like too short last names",
                "name_first" => "We don't like too short first names",
            ],
            "includedMaximum" => [
                "name_last"  => false,
                "name_first" => true,
            ],
            "includedMinimum" => [
                "name_last"  => false,
                "name_first" => true,
            ]
        ]
    )
);

Methods

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

Constructor

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

Source on GitHub

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

Validates that a string has the specified maximum constraints The test is passed if for a string’s length L, L<=max, i.e. L must be at most max.

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Max;

$validator = new Validation();

$validation->add(
    "name_last",
    new Max(
        [
            "max"      => 50,
            "message"  => "We don't like really long names",
            "included" => true
        ]
    )
);

$validation->add(
    [
        "name_last",
        "name_first",
    ],
    new Max(
        [
            "max" => [
                "name_last"  => 50,
                "name_first" => 40,
            ],
            "message" => [
                "name_last"  => "We don't like really long last names",
                "name_first" => "We don't like really long first names",
            ],
            "included" => [
                "name_last"  => false,
                "name_first" => true,
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

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

Source on GitHub

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

Validates that a string has the specified minimum constraints The test is passed if for a string’s length L, min<=L, i.e. L must be at least min.

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Min;

$validator = new Validation();

$validation->add(
    "name_last",
    new Min(
        [
            "min"     => 2,
            "message" => "We want more than just their initials",
            "included" => true
        ]
    )
);

$validation->add(
    [
        "name_last",
        "name_first",
    ],
    new Min(
        [
            "min" => [
                "name_last"  => 2,
                "name_first" => 4,
            ],
            "message" => [
                "name_last"  => "We don't like too short last names",
                "name_first" => "We don't like too short first names",
            ],
            "included" => [
                "name_last"  => false,
                "name_first" => true,
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Class Phalcon\Filter\Validation\Validator\Uniqueness

Source on GitHub

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

Check that a field is unique in the related table

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Uniqueness as UniquenessValidator;

$validator = new Validation();

$validator->add(
    "username",
    new UniquenessValidator(
        [
            "model"   => new Users(),
            "message" => ":field must be unique",
        ]
    )
);

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;

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

Methods

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

Source on GitHub

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

Checks if a value has a url format

use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Url as UrlValidator;

$validator = new Validation();

$validator->add(
    "url",
    new UrlValidator(
        [
            "message" => ":field must be a url",
        ]
    )
);

$validator->add(
    [
        "url",
        "homepage",
    ],
    new UrlValidator(
        [
            "message" => [
                "url"      => "url must be a url",
                "homepage" => "homepage must be a url",
            ]
        ]
    )
);

Properties

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

Methods

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

Constructor

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

Executes the validation

Interface Phalcon\Filter\Validation\ValidatorCompositeInterface

Source on GitHub

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

Source on GitHub

Namespace Phalcon\Filter\Validation   Uses Phalcon\Factory\AbstractFactory   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 getExceptionClass(): string;
protected function getServices(): array;

Returns the available adapters

Interface Phalcon\Filter\Validation\ValidatorInterface

Source on GitHub

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

Interface for Phalcon\Filter\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