<?php

declare(strict_types=1);

/**

* CakePHP(tm) : Rapid Development Framework (https://cakephp.org)

* Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)

*

* Licensed under The MIT License

* For full copyright and license information, please see the LICENSE.txt

* Redistributions of files must retain the above copyright notice.

*

* @copyright Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)

* @link https://cakephp.org CakePHP(tm) Project

* @since 2.2.0

* @license https://opensource.org/licenses/mit-license.php MIT License

*/

namespace Cake\Validation;

use ArrayAccess;

use ArrayIterator;

use Countable;

use InvalidArgumentException;

use IteratorAggregate;

use Psr\Http\Message\UploadedFileInterface;

use Traversable;

/**

* Validator object encapsulates all methods related to data validations for a model

* It also provides an API to dynamically change validation rules for each model field.

*

* Implements ArrayAccess to easily modify rules in the set

*

* @link https://book.cakephp.org/4/en/core-libraries/validation.html

*/

class Validator implements ArrayAccess, IteratorAggregate, Countable

{

/**

* By using 'create' you can make fields required when records are first created.

*

* @var string

*/

public const WHEN_CREATE = 'create';

/**

* By using 'update', you can make fields required when they are updated.

*

* @var string

*/

public const WHEN_UPDATE = 'update';

/**

* Used to flag nested rules created with addNested() and addNestedMany()

*

* @var string

*/

public const NESTED = '_nested';

/**

* A flag for allowEmptyFor()

*

* When `null` is given, it will be recognized as empty.

*

* @var int

*/

public const EMPTY_NULL = 0;

/**

* A flag for allowEmptyFor()

*

* When an empty string is given, it will be recognized as empty.

*

* @var int

*/

public const EMPTY_STRING = 1;

/**

* A flag for allowEmptyFor()

*

* When an empty array is given, it will be recognized as empty.

*

* @var int

*/

public const EMPTY_ARRAY = 2;

/**

* A flag for allowEmptyFor()

*

* When an array is given, if it has at least the `name`, `type`, `tmp_name` and `error` keys,

* and the value of `error` is equal to `UPLOAD_ERR_NO_FILE`, the value will be recognized as

* empty.

*

* When an instance of \Psr\Http\Message\UploadedFileInterface is given the

* return value of it's getError() method must be equal to `UPLOAD_ERR_NO_FILE`.

*

* @var int

*/

public const EMPTY_FILE = 4;

/**

* A flag for allowEmptyFor()

*

* When an array is given, if it contains the `year` key, and only empty strings

* or null values, it will be recognized as empty.

*

* @var int

*/

public const EMPTY_DATE = 8;

/**

* A flag for allowEmptyFor()

*

* When an array is given, if it contains the `hour` key, and only empty strings

* or null values, it will be recognized as empty.

*

* @var int

*/

public const EMPTY_TIME = 16;

/**

* A combination of the all EMPTY_* flags

*

* @var int

*/

public const EMPTY_ALL = self::EMPTY_STRING

| self::EMPTY_ARRAY

| self::EMPTY_FILE

| self::EMPTY_DATE

| self::EMPTY_TIME;

/**

* Holds the ValidationSet objects array

*

* @var \Cake\Validation\ValidationSet[]

* @psalm-var array<string, \Cake\Validation\ValidationSet>

*/

protected $_fields = [];

/**

* An associative array of objects or classes containing methods

* used for validation

*

* @var array

*/

protected $_providers = [];

/**

* An associative array of objects or classes used as a default provider list

*

* @var array

*/

protected static $_defaultProviders = [];

/**

* Contains the validation messages associated with checking the presence

* for each corresponding field.

*

* @var array

*/

protected $_presenceMessages = [];

/**

* Whether or not to use I18n functions for translating default error messages

*

* @var bool

*/

protected $_useI18n = false;

/**

* Contains the validation messages associated with checking the emptiness

* for each corresponding field.

*

* @var array

*/

protected $_allowEmptyMessages = [];

/**

* Contains the flags which specify what is empty for each corresponding field.

*

* @var array

*/

protected $_allowEmptyFlags = [];

/**

* Whether to apply last flag to generated rule(s).

*

* @var bool

*/

protected $_stopOnFailure = false;

/**

* Constructor

*/

public function __construct()

{

$this->_useI18n = function_exists('__d');

$this->_providers = self::$_defaultProviders;

}

/**

* Whether to stop validation rule evaluation on the first failed rule.

*

* When enabled the first failing rule per field will cause validation to stop.

* When disabled all rules will be run even if there are failures.

*

* @param bool $stopOnFailure If to apply last flag.

* @return $this

*/

public function setStopOnFailure(bool $stopOnFailure = true)

{

$this->_stopOnFailure = $stopOnFailure;

return $this;

}

/**

* Validates and returns an array of failed fields and their error messages.

*

* @param array $data The data to be checked for errors

* @param bool $newRecord whether the data to be validated is new or to be updated.

* @return array[] Array of failed fields

* @deprecated 3.9.0 Renamed to {@link validate()}.

*/

public function errors(array $data, bool $newRecord = true): array

{

deprecationWarning('`Validator::errors()` is deprecated. Use `Validator::validate()` instead.');

return $this->validate($data, $newRecord);

}

/**

* Validates and returns an array of failed fields and their error messages.

*

* @param array $data The data to be checked for errors

* @param bool $newRecord whether the data to be validated is new or to be updated.

* @return array[] Array of failed fields

*/

public function validate(array $data, bool $newRecord = true): array

{

$errors = [];

foreach ($this->_fields as $name => $field) {

$keyPresent = array_key_exists($name, $data);

$providers = $this->_providers;

$context = compact('data', 'newRecord', 'field', 'providers');

if (!$keyPresent && !$this->_checkPresence($field, $context)) {

$errors[$name]['_required'] = $this->getRequiredMessage($name);

continue;

}

if (!$keyPresent) {

continue;

}

$canBeEmpty = $this->_canBeEmpty($field, $context);

$flags = static::EMPTY_NULL;

if (isset($this->_allowEmptyFlags[$name])) {

$flags = $this->_allowEmptyFlags[$name];

}

$isEmpty = $this->isEmpty($data[$name], $flags);

if (!$canBeEmpty && $isEmpty) {

$errors[$name]['_empty'] = $this->getNotEmptyMessage($name);

continue;

}

if ($isEmpty) {

continue;

}

$result = $this->_processRules($name, $field, $data, $newRecord);

if ($result) {

$errors[$name] = $result;

}

}

return $errors;

}

/**

* Returns a ValidationSet object containing all validation rules for a field, if

* passed a ValidationSet as second argument, it will replace any other rule set defined

* before

*

* @param string $name [optional] The fieldname to fetch.

* @param \Cake\Validation\ValidationSet|null $set The set of rules for field

* @return \Cake\Validation\ValidationSet

*/

public function field(string $name, ?ValidationSet $set = null): ValidationSet

{

if (empty($this->_fields[$name])) {

$set = $set ?: new ValidationSet();

$this->_fields[$name] = $set;

}

return $this->_fields[$name];

}

/**

* Check whether or not a validator contains any rules for the given field.

*

* @param string $name The field name to check.

* @return bool

*/

public function hasField(string $name): bool

{

return isset($this->_fields[$name]);

}

/**

* Associates an object to a name so it can be used as a provider. Providers are

* objects or class names that can contain methods used during validation of for

* deciding whether a validation rule can be applied. All validation methods,

* when called will receive the full list of providers stored in this validator.

*

* @param string $name The name under which the provider should be set.

* @param object|string $object Provider object or class name.

* @return $this

*/

public function setProvider(string $name, $object)

{

$this->_providers[$name] = $object;

return $this;

}

/**

* Returns the provider stored under that name if it exists.

*

* @param string $name The name under which the provider should be set.

* @return object|string|null

*/

public function getProvider(string $name)

{

if (isset($this->_providers[$name])) {

return $this->_providers[$name];

}

if ($name !== 'default') {

return null;

}

$this->_providers[$name] = new RulesProvider();

return $this->_providers[$name];

}

/**

* Returns the default provider stored under that name if it exists.

*

* @param string $name The name under which the provider should be retrieved.

* @return object|string|null

*/

public static function getDefaultProvider(string $name)

{

if (!isset(self::$_defaultProviders[$name])) {

return null;

}

return self::$_defaultProviders[$name];

}

/**

* Associates an object to a name so it can be used as a default provider.

*

* @param string $name The name under which the provider should be set.

* @param object|string $object Provider object or class name.

* @return void

*/

public static function addDefaultProvider(string $name, $object): void

{

self::$_defaultProviders[$name] = $object;

}

/**

* Get the list of default providers.

*

* @return string[]

*/

public static function getDefaultProviders(): array

{

return array_keys(self::$_defaultProviders);

}

/**

* Get the list of providers in this validator.

*

* @return string[]

*/

public function providers(): array

{

return array_keys($this->_providers);

}

/**

* Returns whether a rule set is defined for a field or not

*

* @param string $field name of the field to check

* @return bool

*/

public function offsetExists($field): bool

{

return isset($this->_fields[$field]);

}

/**

* Returns the rule set for a field

*

* @param string $field name of the field to check

* @return \Cake\Validation\ValidationSet

*/

public function offsetGet($field): ValidationSet

{

return $this->field($field);

}

/**

* Sets the rule set for a field

*

* @param string $field name of the field to set

* @param array|\Cake\Validation\ValidationSet $rules set of rules to apply to field

* @return void

*/

public function offsetSet($field, $rules): void

{

if (!$rules instanceof ValidationSet) {

$set = new ValidationSet();

foreach ($rules as $name => $rule) {

$set->add($name, $rule);

}

$rules = $set;

}

$this->_fields[$field] = $rules;

}

/**

* Unsets the rule set for a field

*

* @param string $field name of the field to unset

* @return void

*/

public function offsetUnset($field): void

{

unset($this->_fields[$field]);

}

/**

* Returns an iterator for each of the fields to be validated

*

* @return \Cake\Validation\ValidationSet[]

* @psalm-return \Traversable<string, \Cake\Validation\ValidationSet>

*/

public function getIterator(): Traversable

{

return new ArrayIterator($this->_fields);

}

/**

* Returns the number of fields having validation rules

*

* @return int

*/

public function count(): int

{

return count($this->_fields);

}

/**

* Adds a new rule to a field's rule set. If second argument is an array

* then rules list for the field will be replaced with second argument and

* third argument will be ignored.

*

* ### Example:

*

* ```

* $validator

* ->add('title', 'required', ['rule' => 'notBlank'])

* ->add('user_id', 'valid', ['rule' => 'numeric', 'message' => 'Invalid User'])

*

* $validator->add('password', [

* 'size' => ['rule' => ['lengthBetween', 8, 20]],

* 'hasSpecialCharacter' => ['rule' => 'validateSpecialchar', 'message' => 'not valid']

* ]);

* ```

*

* @param string $field The name of the field from which the rule will be added

* @param array|string $name The alias for a single rule or multiple rules array

* @param array|\Cake\Validation\ValidationRule $rule the rule to add

* @throws \InvalidArgumentException If numeric index cannot be resolved to a string one

* @return $this

*/

public function add(string $field, $name, $rule = [])

{

$validationSet = $this->field($field);

if (!is_array($name)) {

$rules = [$name => $rule];

} else {

$rules = $name;

}

foreach ($rules as $name => $rule) {

if (is_array($rule)) {

$rule += [

'rule' => $name,

'last' => $this->_stopOnFailure,

];

}

if (!is_string($name)) {

/** @psalm-suppress PossiblyUndefinedMethod */

$name = $rule['rule'];

if (is_array($name)) {

$name = array_shift($name);

}

if ($validationSet->offsetExists($name)) {

$message = 'You cannot add a rule without a unique name, already existing rule found: ' . $name;

throw new InvalidArgumentException($message);

}

deprecationWarning(

'Adding validation rules without a name key is deprecated. Update rules array to have string keys.'

);

}

$validationSet->add($name, $rule);

}

return $this;

}

/**

* Adds a nested validator.

*

* Nesting validators allows you to define validators for array

* types. For example, nested validators are ideal when you want to validate a

* sub-document, or complex array type.

*

* This method assumes that the sub-document has a 1:1 relationship with the parent.

*

* The providers of the parent validator will be synced into the nested validator, when

* errors are checked. This ensures that any validation rule providers connected

* in the parent will have the same values in the nested validator when rules are evaluated.

*

* @param string $field The root field for the nested validator.

* @param \Cake\Validation\Validator $validator The nested validator.

* @param string|null $message The error message when the rule fails.

* @param string|callable|null $when Either 'create' or 'update' or a callable that returns

* true when the validation rule should be applied.

* @return $this

*/

public function addNested(string $field, Validator $validator, ?string $message = null, $when = null)

{

$extra = array_filter(['message' => $message, 'on' => $when]);

$validationSet = $this->field($field);

$validationSet->add(static::NESTED, $extra + ['rule' => function ($value, $context) use ($validator, $message) {

if (!is_array($value)) {

return false;

}

foreach ($this->providers() as $provider) {

/** @psalm-suppress PossiblyNullArgument */

$validator->setProvider($provider, $this->getProvider($provider));

}

$errors = $validator->validate($value, $context['newRecord']);

$message = $message ? [static::NESTED => $message] : [];

return empty($errors) ? true : $errors + $message;

}]);

return $this;

}

/**

* Adds a nested validator.

*

* Nesting validators allows you to define validators for array

* types. For example, nested validators are ideal when you want to validate many

* similar sub-documents or complex array types.

*

* This method assumes that the sub-document has a 1:N relationship with the parent.

*

* The providers of the parent validator will be synced into the nested validator, when

* errors are checked. This ensures that any validation rule providers connected

* in the parent will have the same values in the nested validator when rules are evaluated.

*

* @param string $field The root field for the nested validator.

* @param \Cake\Validation\Validator $validator The nested validator.

* @param string|null $message The error message when the rule fails.

* @param string|callable|null $when Either 'create' or 'update' or a callable that returns

* true when the validation rule should be applied.

* @return $this

*/

public function addNestedMany(string $field, Validator $validator, ?string $message = null, $when = null)

{

$extra = array_filter(['message' => $message, 'on' => $when]);

$validationSet = $this->field($field);

$validationSet->add(static::NESTED, $extra + ['rule' => function ($value, $context) use ($validator, $message) {

if (!is_array($value)) {

return false;

}

foreach ($this->providers() as $provider) {

/** @psalm-suppress PossiblyNullArgument */

$validator->setProvider($provider, $this->getProvider($provider));

}

$errors = [];

foreach ($value as $i => $row) {

if (!is_array($row)) {

return false;

}

$check = $validator->validate($row, $context['newRecord']);

if (!empty($check)) {

$errors[$i] = $check;

}

}

$message = $message ? [static::NESTED => $message] : [];

return empty($errors) ? true : $errors + $message;

}]);

return $this;

}

/**

* Removes a rule from the set by its name

*

* ### Example:

*

* ```

* $validator

* ->remove('title', 'required')

* ->remove('user_id')

* ```

*

* @param string $field The name of the field from which the rule will be removed

* @param string|null $rule the name of the rule to be removed

* @return $this

*/

public function remove(string $field, ?string $rule = null)

{

if ($rule === null) {

unset($this->_fields[$field]);

} else {

$this->field($field)->remove($rule);

}

return $this;

}

/**

* Sets whether a field is required to be present in data array.

* You can also pass array. Using an array will let you provide the following

* keys:

*

* - `mode` individual mode for field

* - `message` individual error message for field

*

* You can also set mode and message for all passed fields, the individual

* setting takes precedence over group settings.

*

* @param string|array $field the name of the field or list of fields.

* @param bool|string|callable $mode Valid values are true, false, 'create', 'update'.

* If a callable is passed then the field will be required only when the callback

* returns true.

* @param string|null $message The message to show if the field presence validation fails.

* @return $this

*/

public function requirePresence($field, $mode = true, ?string $message = null)

{

$defaults = [

'mode' => $mode,

'message' => $message,

];

if (!is_array($field)) {

$field = $this->_convertValidatorToArray($field, $defaults);

}

foreach ($field as $fieldName => $setting) {

$settings = $this->_convertValidatorToArray($fieldName, $defaults, $setting);

$fieldName = current(array_keys($settings));

$this->field($fieldName)->requirePresence($settings[$fieldName]['mode']);

if ($settings[$fieldName]['message']) {

$this->_presenceMessages[$fieldName] = $settings[$fieldName]['message'];

}

}

return $this;

}

/**

* Allows a field to be empty. You can also pass array.

* Using an array will let you provide the following keys:

*

* - `when` individual when condition for field

* - 'message' individual message for field

*

* You can also set when and message for all passed fields, the individual setting

* takes precedence over group settings.

*

* This is the opposite of notEmpty() which requires a field to not be empty.

* By using $mode equal to 'create' or 'update', you can allow fields to be empty

* when records are first created, or when they are updated.

*

* ### Example:

*

* ```

* // Email can be empty

* $validator->allowEmpty('email');

*

* // Email can be empty on create

* $validator->allowEmpty('email', Validator::WHEN_CREATE);

*

* // Email can be empty on update

* $validator->allowEmpty('email', Validator::WHEN_UPDATE);

*

* // Email and subject can be empty on update

* $validator->allowEmpty(['email', 'subject'], Validator::WHEN_UPDATE;

*

* // Email can be always empty, subject and content can be empty on update.

* $validator->allowEmpty(

* [

* 'email' => [

* 'when' => true

* ],

* 'content' => [

* 'message' => 'Content cannot be empty'

* ],

* 'subject'

* ],

* Validator::WHEN_UPDATE

* );

* ```

*

* It is possible to conditionally allow emptiness on a field by passing a callback

* as a second argument. The callback will receive the validation context array as

* argument:

*

* ```

* $validator->allowEmpty('email', function ($context) {

* return !$context['newRecord'] || $context['data']['role'] === 'admin';

* });

* ```

*

* This method will correctly detect empty file uploads and date/time/datetime fields.

*

* Because this and `notEmpty()` modify the same internal state, the last

* method called will take precedence.

*

* @deprecated 3.7.0 Use {@link allowEmptyString()}, {@link allowEmptyArray()}, {@link allowEmptyFile()},

* {@link allowEmptyDate()}, {@link allowEmptyTime()}, {@link allowEmptyDateTime()} or {@link allowEmptyFor()} instead.

* @param string|array $field the name of the field or a list of fields

* @param bool|string|callable $when Indicates when the field is allowed to be empty

* Valid values are true (always), 'create', 'update'. If a callable is passed then

* the field will allowed to be empty only when the callback returns true.

* @param string|null $message The message to show if the field is not

* @return $this

*/

public function allowEmpty($field, $when = true, $message = null)

{

deprecationWarning(

'allowEmpty() is deprecated. '

. 'Use allowEmptyString(), allowEmptyArray(), allowEmptyFile(), allowEmptyDate(), allowEmptyTime(), '

. 'allowEmptyDateTime() or allowEmptyFor() instead.'

);

$defaults = [

'when' => $when,

'message' => $message,

];

if (!is_array($field)) {

$field = $this->_convertValidatorToArray($field, $defaults);

}

foreach ($field as $fieldName => $setting) {

$settings = $this->_convertValidatorToArray($fieldName, $defaults, $setting);

$fieldName = array_keys($settings)[0];

$this->allowEmptyFor(

$fieldName,

static::EMPTY_ALL,

$settings[$fieldName]['when'],

$settings[$fieldName]['message']

);

}

return $this;

}

/**

* Low-level method to indicate that a field can be empty.

*

* This method should generally not be used and instead you should

* use:

*

* - `allowEmptyString()`

* - `allowEmptyArray()`

* - `allowEmptyFile()`

* - `allowEmptyDate()`

* - `allowEmptyDatetime()`

* - `allowEmptyTime()`

*

* Should be used as their APIs are simpler to operate and read.

*

* You can also set flags, when and message for all passed fields, the individual

* setting takes precedence over group settings.

*

* ### Example:

*

* ```

* // Email can be empty

* $validator->allowEmptyFor('email', Validator::EMPTY_STRING);

*

* // Email can be empty on create

* $validator->allowEmptyFor('email', Validator::EMPTY_STRING, Validator::WHEN_CREATE);

*

* // Email can be empty on update

* $validator->allowEmptyFor('email', Validator::EMPTY_STRING, Validator::WHEN_UPDATE);

* ```

*

* It is possible to conditionally allow emptiness on a field by passing a callback

* as a second argument. The callback will receive the validation context array as

* argument:

*

* ```

* $validator->allowEmpty('email', Validator::EMPTY_STRING, function ($context) {

* return !$context['newRecord'] || $context['data']['role'] === 'admin';

* });

* ```

*

* If you want to allow other kind of empty data on a field, you need to pass other

* flags:

*

* ```

* $validator->allowEmptyFor('photo', Validator::EMPTY_FILE);

* $validator->allowEmptyFor('published', Validator::EMPTY_STRING | Validator::EMPTY_DATE | Validator::EMPTY_TIME);

* $validator->allowEmptyFor('items', Validator::EMPTY_STRING | Validator::EMPTY_ARRAY);

* ```

*

* You can also use convenience wrappers of this method. The following calls are the

* same as above:

*

* ```

* $validator->allowEmptyFile('photo');

* $validator->allowEmptyDateTime('published');

* $validator->allowEmptyArray('items');

* ```

*

* @param string $field The name of the field.

* @param int|null $flags A bitmask of EMPTY_* flags which specify what is empty.

* If no flags/bitmask is provided only `null` will be allowed as empty value.

* @param bool|string|callable $when Indicates when the field is allowed to be empty

* Valid values are true, false, 'create', 'update'. If a callable is passed then

* the field will allowed to be empty only when the callback returns true.

* @param string|null $message The message to show if the field is not

* @since 3.7.0

* @return $this

*/

public function allowEmptyFor(string $field, ?int $flags = null, $when = true, ?string $message = null)

{

$this->field($field)->allowEmpty($when);

if ($message) {

$this->_allowEmptyMessages[$field] = $message;

}

if ($flags !== null) {

$this->_allowEmptyFlags[$field] = $flags;

}

return $this;

}

/**

* Allows a field to be an empty string.

*

* This method is equivalent to calling allowEmptyFor() with EMPTY_STRING flag.

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is not

* @param bool|string|callable $when Indicates when the field is allowed to be empty

* Valid values are true, false, 'create', 'update'. If a callable is passed then

* the field will allowed to be empty only when the callback returns true.

* @return $this

* @see \Cake\Validation\Validator::allowEmptyFor() For detail usage

*/

public function allowEmptyString(string $field, ?string $message = null, $when = true)

{

return $this->allowEmptyFor($field, self::EMPTY_STRING, $when, $message);

}

/**

* Requires a field to be not be an empty string.

*

* Opposite to allowEmptyString()

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is empty.

* @param bool|string|callable $when Indicates when the field is not allowed

* to be empty. Valid values are false (never), 'create', 'update'. If a

* callable is passed then the field will be required to be not empty when

* the callback returns true.

* @return $this

* @see \Cake\Validation\Validator::allowEmptyString()

* @since 3.8.0

*/

public function notEmptyString(string $field, ?string $message = null, $when = false)

{

$when = $this->invertWhenClause($when);

return $this->allowEmptyFor($field, self::EMPTY_STRING, $when, $message);

}

/**

* Allows a field to be an empty array.

*

* This method is equivalent to calling allowEmptyFor() with EMPTY_STRING +

* EMPTY_ARRAY flags.

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is not

* @param bool|string|callable $when Indicates when the field is allowed to be empty

* Valid values are true, false, 'create', 'update'. If a callable is passed then

* the field will allowed to be empty only when the callback returns true.

* @return $this

* @since 3.7.0

* @see \Cake\Validation\Validator::allowEmptyFor() for examples.

*/

public function allowEmptyArray(string $field, ?string $message = null, $when = true)

{

return $this->allowEmptyFor($field, self::EMPTY_STRING | self::EMPTY_ARRAY, $when, $message);

}

/**

* Require a field to be a non-empty array

*

* Opposite to allowEmptyArray()

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is empty.

* @param bool|string|callable $when Indicates when the field is not allowed

* to be empty. Valid values are false (never), 'create', 'update'. If a

* callable is passed then the field will be required to be not empty when

* the callback returns true.

* @return $this

* @see \Cake\Validation\Validator::allowEmptyArray()

*/

public function notEmptyArray(string $field, ?string $message = null, $when = false)

{

$when = $this->invertWhenClause($when);

return $this->allowEmptyFor($field, self::EMPTY_STRING | self::EMPTY_ARRAY, $when, $message);

}

/**

* Allows a field to be an empty file.

*

* This method is equivalent to calling allowEmptyFor() with EMPTY_FILE flag.

* File fields will not accept `''`, or `[]` as empty values. Only `null` and a file

* upload with `error` equal to `UPLOAD_ERR_NO_FILE` will be treated as empty.

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is not

* @param bool|string|callable $when Indicates when the field is allowed to be empty

* Valid values are true, 'create', 'update'. If a callable is passed then

* the field will allowed to be empty only when the callback returns true.

* @return $this

* @since 3.7.0

* @see \Cake\Validation\Validator::allowEmptyFor() For detail usage

*/

public function allowEmptyFile(string $field, ?string $message = null, $when = true)

{

return $this->allowEmptyFor($field, self::EMPTY_FILE, $when, $message);

}

/**

* Require a field to be a not-empty file.

*

* Opposite to allowEmptyFile()

*

* @param string $field The name of the field.

* @param string|null $message The message to show if the field is empty.

* @param bool|string|callable $when Indicates when the field is not allowed

* to be empty. Valid values are false (never), 'create', 'update'. If a

* callable is passed then the field will be required to be not empty when

* the callback returns true.

* @return $this

* @since 3.8.0

* @see \Cake\Validation\Validator::allowEmptyFile()

*/

public function notEmptyFile(string $field, ?string $message = null, $when = false)

{

$when = $this->invertWhenClause($when);

return $this->allowEmptyFor($field, self::EMPTY_FILE, $when, $message);

}

/**