Phalcon Filter

public function __construct( string $name );

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

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

public function get( string $name ): mixed;

public static function getDefaultMapper(): array;

public function has( string $name ): bool;

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

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

protected function init( array $mapper ): void;

public function newInstance(): FilterInterface;

protected function getServices(): array;

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

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke( mixed $input );

public function __invoke(
    string $input,
    int $filter = 0
): string|false;

public function __invoke( string $input );

public function __invoke( string $input );

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

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

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

public function __invoke( mixed $input );

public function __invoke( mixed $input );

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

public function __invoke( mixed $input );

public function __invoke( string $input );

public function __invoke( string $input );

public function __invoke( string $input );

public function __invoke( string $input );

public function __invoke( string $input );

public function __invoke( mixed $input );

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

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

public function appendMessage( MessageInterface $message ): static;

public function bind(
    mixed $entity,
    mixed $data,
    array $whitelist = []
): static;

$entity = new Author();
$fields = ['name', 'email', 'imageUrl'];
$validation = new AuthorValidation();
$validation->bind($entity, $_POST, $fields);
$validation->validate();

public function fails(): bool;

public function getData(): mixed;

public function getEntity(): mixed;

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

public function getLabel( mixed $field ): string;

public function getMessages(): Messages;

public function getValidators(): array;

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

public function getValueByData(
    mixed $data,
    string $field
): mixed|null;

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

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

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

public function setEntity( mixed $entity ): void;

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

public function setLabels( array $labels ): void;

public function setValidators( array $validators ): static;

public function validate(
    mixed $data = null,
    mixed $entity = null,
    array $whitelist = []
): Messages|bool;

// using bind() with $whitelist fields
$entity = new Author();
$fields = ['name', 'email', 'imageUrl'];
$validation = new AuthorValidation();
$validation->bind($entity, $_POST, $fields);
$validation->validate();

// directly using validate
$validation = new AuthorValidation();
$validation->validate($_POST, $entity, $fields);

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

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

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

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

public function getTemplates(): array;

public function hasOption( string $key ): bool;

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

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

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

public function setTemplate( string $template ): ValidatorInterface;

public function setTemplates( array $templates ): ValidatorInterface;

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

protected function allowEmpty(
    mixed $field,
    mixed $value
): bool;

protected function checkArray(
    mixed $value,
    string $field
): mixed;

protected function prepareCode( string $field ): int;

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

public function getValidators(): array;

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

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct( string $className );

public function __construct();

public function __construct();

public function __construct();

public function __construct();

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

public function appendMessage( MessageInterface $message ): ValidationInterface;

public function bind(
    mixed $entity,
    mixed $data,
    array $whitelist = []
): ValidationInterface;

public function getEntity(): mixed;

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

public function getLabel( string $field ): string;

public function getMessages(): Messages;

public function getValidators(): array;

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

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

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

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

public function setLabels( array $labels ): void;

public function validate(
    mixed $data = null,
    mixed $entity = null,
    array $whitelist = []
): Messages|bool;

public function getValidators(): array;

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

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

public function newInstance( string $name ): ValidatorInterface;

protected function getExceptionClass(): string;

protected function getServices(): array;

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

public function getTemplate( string $field ): string;

public function getTemplates(): array;

public function hasOption( string $key ): bool;

public function setTemplate( string $template ): ValidatorInterface;

public function setTemplates( array $templates ): ValidatorInterface;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$validator = new Validation();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public function getFileSizeInBytes( string $size ): double;

public function getMessageFileEmpty(): string;

public function getMessageIniSize(): string;

public function getMessageValid(): string;

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

public function setMessageFileEmpty( string $message ): void;

public function setMessageIniSize( string $message ): void;

public function setMessageValid( string $message ): void;

protected function checkIsUploadedFile( string $name ): bool;

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

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

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

$validator = new Validation();

$validator->add(
    "file",
    new AspectRatio(
        [
            "ratio"   => "16x9",
            "message" => "The aspect ratio of the field :field has to be :ratio",
        ]
    )
);

$validator->add(
    [
        "file",
        "anotherFile",
    ],
    new AspectRatio(
        [
            "ratio" => [
                "file"        => "16x9",
                "anotherFile" => "4x3",
            ],
            "message" => [
                "file"        => "Aspect ratio of file has to be 16x9",
                "anotherFile" => "Aspect ratio of anotherFile has to be 4x3",
            ],
        ]
    )
);

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

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

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

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