0 follower

Class yii\data\DataFilter

Inheritanceyii\data\DataFilter » yii\base\Model » yii\base\Component » yii\base\BaseObject
ImplementsArrayAccess, IteratorAggregate, yii\base\Arrayable, yii\base\Configurable, yii\base\StaticInstanceInterface
Uses Traitsyii\base\ArrayableTrait, yii\base\StaticInstanceTrait
Subclassesyii\data\ActiveDataFilter
Available since version2.0.13
Source Code https://github.com/yiisoft/yii2/blob/master/framework/data/DataFilter.php

DataFilter is a special yii\base\Model for processing query filtering specification.

It allows validating and building a filter condition passed via request.

Filter example:

{
    "or": [
        {
            "and": [
                {
                    "name": "some name",
                },
                {
                    "price": "25",
                }
            ]
        },
        {
            "id": {"in": [2, 5, 9]},
            "price": {
                "gt": 10,
                "lt": 50
            }
        }
    ]
}

In the request the filter should be specified using a key name equal to $filterAttributeName. Thus actual HTTP request body will look like following:

{
    "filter": {"or": {...}},
    "page": 2,
    ...
}

Raw filter value should be assigned to $filter property of the model. You may populate it from request data via load() method:

use yii\data\DataFilter;

$dataFilter = new DataFilter();
$dataFilter->load(Yii::$app->request->getBodyParams());

In order to function this class requires a search model specified via $searchModel. This search model should declare all available search attributes and their validation rules. For example:

class SearchModel extends \yii\base\Model
{
    public $id;
    public $name;

    public function rules()
    {
        return [
            [['id', 'name'], 'trim'],
            ['id', 'integer'],
            ['name', 'string'],
        ];
    }
}

In order to reduce amount of classes, you may use yii\base\DynamicModel instance as a $searchModel. In this case you should specify $searchModel using a PHP callable:

function () {
    return (new \yii\base\DynamicModel(['id' => null, 'name' => null]))
        ->addRule(['id', 'name'], 'trim')
        ->addRule('id', 'integer')
        ->addRule('name', 'string');
}

You can use validate() method to check if filter value is valid. If validation fails you can use getErrors() to get actual error messages.

In order to acquire filter condition suitable for fetching data use build() method.

Note: This is a base class. Its implementation of build() simply returns normalized $filter value. In order to convert filter to particular format you should use descendant of this class that implements buildInternal() method accordingly.

See also yii\data\ActiveDataFilter.

Public Properties

Hide inherited properties

Property Type Description Defined By
$activeValidators yii\validators\Validator[] The validators applicable to the current $scenario. yii\base\Model
$attributeMap array Actual attribute names to be used in searched condition, in format: [filterAttribute => actualAttribute]. yii\data\DataFilter
$attributes array Attribute values (name => value). yii\base\Model
$behaviors yii\base\Behavior[] List of behaviors attached to this component. yii\base\Component
$conditionValidators array Maps filter condition keywords to validation methods. yii\data\DataFilter
$errorMessages array Error messages in format [errorKey => message]. yii\data\DataFilter
$errors array Errors for all attributes or the specified attribute. yii\base\Model
$filter mixed Raw filter value. yii\data\DataFilter
$filterAttributeLabel string Label for the filter attribute specified via $filterAttributeName. yii\data\DataFilter
$filterAttributeName string Name of the attribute that handles filter value. yii\data\DataFilter
$filterControls array Keywords or expressions that could be used in a filter. yii\data\DataFilter
$firstErrors array The first errors. yii\base\Model
$iterator ArrayIterator An iterator for traversing the items in the list. yii\base\Model
$multiValueOperators array List of operators keywords, which should accept multiple values. yii\data\DataFilter
$nullValue string Representation of null instead of literal null in case the latter cannot be used. yii\data\DataFilter
$operatorTypes array Specifies the list of supported search attribute types per each operator. yii\data\DataFilter
$scenario string The scenario that this model is in. yii\base\Model
$searchAttributeTypes array Search attribute type map. yii\data\DataFilter
$searchModel yii\base\Model Model instance. yii\data\DataFilter
$validators ArrayObject|yii\validators\Validator[] All the validators declared in the model. yii\base\Model

Public Methods

Hide inherited methods

Method Description Defined By
__call() Calls the named method which is not a class method. yii\base\Component
__clone() This method is called after the object is created by cloning an existing one. yii\base\Model
__construct() Constructor. yii\base\BaseObject
__get() Returns the value of a component property. yii\data\DataFilter
__isset() Checks if a property is set, i.e. defined and not null. yii\data\DataFilter
__set() Sets the value of a component property. yii\data\DataFilter
__unset() Sets a component property to be null. yii\data\DataFilter
activeAttributes() Returns the attribute names that are subject to validation in the current scenario. yii\base\Model
addError() Adds a new error to the specified attribute. yii\base\Model
addErrors() Adds a list of errors. yii\base\Model
afterValidate() This method is invoked after validation ends. yii\base\Model
attachBehavior() Attaches a behavior to this component. yii\base\Component
attachBehaviors() Attaches a list of behaviors to the component. yii\base\Component
attributeHints() Returns the attribute hints. yii\base\Model
attributeLabels() Returns the attribute labels. yii\data\DataFilter
attributes() Returns the list of attribute names. yii\data\DataFilter
beforeValidate() This method is invoked before validation starts. yii\base\Model
behaviors() Returns a list of behaviors that this component should behave as. yii\base\Component
build() Builds actual filter specification form $filter value. yii\data\DataFilter
canGetProperty() Returns a value indicating whether a property can be read. yii\data\DataFilter
canSetProperty() Returns a value indicating whether a property can be set. yii\data\DataFilter
className() Returns the fully qualified name of this class. yii\base\BaseObject
clearErrors() Removes errors for all attributes or a single attribute. yii\base\Model
createValidators() Creates validator objects based on the validation rules specified in rules(). yii\base\Model
detachBehavior() Detaches a behavior from the component. yii\base\Component
detachBehaviors() Detaches all behaviors from the component. yii\base\Component
ensureBehaviors() Makes sure that the behaviors declared in behaviors() are attached to this component. yii\base\Component
extraFields() Returns the list of fields that can be expanded further and returned by toArray(). yii\base\ArrayableTrait
fields() Returns the list of fields that should be returned by default by toArray() when no specific fields are specified. yii\base\ArrayableTrait
formName() Returns the form name that this model class should use. yii\data\DataFilter
generateAttributeLabel() Generates a user friendly attribute label based on the give attribute name. yii\base\Model
getActiveValidators() Returns the validators applicable to the current $scenario. yii\base\Model
getAttributeHint() Returns the text hint for the specified attribute. yii\base\Model
getAttributeLabel() Returns the text label for the specified attribute. yii\base\Model
getAttributes() Returns attribute values. yii\base\Model
getBehavior() Returns the named behavior object. yii\base\Component
getBehaviors() Returns all behaviors attached to this component. yii\base\Component
getErrorMessages() yii\data\DataFilter
getErrorSummary() Returns the errors for all attributes as a one-dimensional array. yii\base\Model
getErrors() Returns the errors for all attributes or a single attribute. yii\base\Model
getFilter() yii\data\DataFilter
getFirstError() Returns the first error of the specified attribute. yii\base\Model
getFirstErrors() Returns the first error of every attribute in the model. yii\base\Model
getIterator() Returns an iterator for traversing the attributes in the model. yii\base\Model
getScenario() Returns the scenario that this model is used in. yii\base\Model
getSearchAttributeTypes() yii\data\DataFilter
getSearchModel() yii\data\DataFilter
getValidators() Returns all the validators declared in rules(). yii\base\Model
hasErrors() Returns a value indicating whether there is any validation error. yii\base\Model
hasEventHandlers() Returns a value indicating whether there is any handler attached to the named event. yii\base\Component
hasMethod() Returns a value indicating whether a method is defined. yii\base\Component
hasProperty() Returns a value indicating whether a property is defined for this component. yii\base\Component
init() Initializes the object. yii\base\BaseObject
instance() Returns static class instance, which can be used to obtain meta information. yii\base\StaticInstanceTrait
isAttributeActive() Returns a value indicating whether the attribute is active in the current scenario. yii\base\Model
isAttributeRequired() Returns a value indicating whether the attribute is required. yii\base\Model
isAttributeSafe() Returns a value indicating whether the attribute is safe for massive assignments. yii\base\Model
load() Populates the model with input data. yii\base\Model
loadMultiple() Populates a set of models with the data from end user. yii\base\Model
normalize() Normalizes filter value, replacing raw keys according to $filterControls and $attributeMap. yii\data\DataFilter
off() Detaches an existing event handler from this component. yii\base\Component
offsetExists() Returns whether there is an element at the specified offset. yii\base\Model
offsetGet() Returns the element at the specified offset. yii\base\Model
offsetSet() Sets the element at the specified offset. yii\base\Model
offsetUnset() Sets the element value at the specified offset to null. yii\base\Model
on() Attaches an event handler to an event. yii\base\Component
onUnsafeAttribute() This method is invoked when an unsafe attribute is being massively assigned. yii\base\Model
rules() Returns the validation rules for attributes. yii\data\DataFilter
safeAttributes() Returns the attribute names that are safe to be massively assigned in the current scenario. yii\base\Model
scenarios() Returns a list of scenarios and the corresponding active attributes. yii\base\Model
setAttributes() Sets the attribute values in a massive way. yii\base\Model
setErrorMessages() Sets the list of error messages responding to invalid filter structure, in format: [errorKey => message]. yii\data\DataFilter
setFilter() yii\data\DataFilter
setScenario() Sets the scenario for the model. yii\base\Model
setSearchAttributeTypes() yii\data\DataFilter
setSearchModel() yii\data\DataFilter
toArray() Converts the model into an array. yii\base\ArrayableTrait
trigger() Triggers an event. yii\base\Component
validate() Performs the data validation. yii\base\Model
validateFilter() Validates filter attribute value to match filer condition specification. yii\data\DataFilter
validateMultiple() Validates multiple models. yii\base\Model

Protected Methods

Hide inherited methods

Method Description Defined By
buildInternal() Performs actual filter build. yii\data\DataFilter
defaultErrorMessages() Returns default values for $errorMessages. yii\data\DataFilter
detectSearchAttributeType() Detect attribute type from given validator. yii\data\DataFilter
detectSearchAttributeTypes() Composes default value for $searchAttributeTypes from the $searchModel validation rules. yii\data\DataFilter
extractFieldsFor() Extract nested fields from a fields collection for a given root field Nested fields are separated with dots (.). e.g: "item.id" The previous example would extract "id". yii\base\ArrayableTrait
extractRootFields() Extracts the root field names from nested fields. yii\base\ArrayableTrait
filterAttributeValue() Validates attribute value in the scope of $searchModel, applying attribute value filters if any. yii\data\DataFilter
parseErrorMessage() Parses content of the message from $errorMessages, specified by message key. yii\data\DataFilter
resolveFields() Determines which fields can be returned by toArray(). yii\base\ArrayableTrait
validateAttributeCondition() Validates search condition for a particular attribute. yii\data\DataFilter
validateAttributeValue() Validates attribute value in the scope of model. yii\data\DataFilter
validateBlockCondition() Validates block condition that consists of a single condition. yii\data\DataFilter
validateCondition() Validates filter condition. yii\data\DataFilter
validateConjunctionCondition() Validates conjunction condition that consists of multiple independent ones. yii\data\DataFilter
validateOperatorCondition() Validates operator condition. yii\data\DataFilter

Events

Hide inherited events

Event Type Description Defined By
EVENT_AFTER_VALIDATE yii\base\Event An event raised at the end of validate() yii\base\Model
EVENT_BEFORE_VALIDATE yii\base\ModelEvent An event raised at the beginning of validate(). yii\base\Model

Constants

Hide inherited constants

Constant Value Description Defined By
SCENARIO_DEFAULT 'default' The name of the default scenario. yii\base\Model
TYPE_ARRAY 'array' yii\data\DataFilter
TYPE_BOOLEAN 'boolean' yii\data\DataFilter
TYPE_DATE 'date' yii\data\DataFilter
TYPE_DATETIME 'datetime' yii\data\DataFilter
TYPE_FLOAT 'float' yii\data\DataFilter
TYPE_INTEGER 'integer' yii\data\DataFilter
TYPE_STRING 'string' yii\data\DataFilter
TYPE_TIME 'time' yii\data\DataFilter

Property Details

Hide inherited properties

$attributeMap public property

Actual attribute names to be used in searched condition, in format: [filterAttribute => actualAttribute]. For example, in case of using table joins in the search query, attribute map may look like the following:

[
    'authorName' => '{{author}}.[[name]]'
]

Attribute map will be applied to filter condition in normalize() method.

public array $attributeMap = []
$conditionValidators public property

Maps filter condition keywords to validation methods. These methods are used by validateCondition() to validate raw filter conditions.

public array $conditionValidators = [
    
'AND' => 'validateConjunctionCondition',
    
'OR' => 'validateConjunctionCondition',
    
'NOT' => 'validateBlockCondition',
    
'<' => 'validateOperatorCondition',
    
'>' => 'validateOperatorCondition',
    
'<=' => 'validateOperatorCondition',
    
'>=' => 'validateOperatorCondition',
    
'=' => 'validateOperatorCondition',
    
'!=' => 'validateOperatorCondition',
    
'IN' => 'validateOperatorCondition',
    
'NOT IN' => 'validateOperatorCondition',
    
'LIKE' => 'validateOperatorCondition',
]
$errorMessages public property

Error messages in format [errorKey => message]. Note that the type of this property differs in getter and setter. See getErrorMessages() and setErrorMessages() for details.

public array $errorMessages null
$filter public property

Raw filter value.

public mixed $filter null
$filterAttributeLabel public property

Label for the filter attribute specified via $filterAttributeName. It will be used during error messages composition.

$filterAttributeName public property

Name of the attribute that handles filter value. The name is used to load data via load() method.

public string $filterAttributeName 'filter'
$filterControls public property

Keywords or expressions that could be used in a filter. Array keys are the expressions used in raw filter value obtained from user request. Array values are internal build keys used in this class methods.

Any unspecified keyword will not be recognized as a filter control and will be treated as an attribute name. Thus you should avoid conflicts between control keywords and attribute names. For example: in case you have control keyword 'like' and an attribute named 'like', specifying condition for such attribute will be impossible.

You may specify several keywords for the same filter build key, creating multiple aliases. For example:

[
    'eq' => '=',
    '=' => '=',
    '==' => '=',
    '===' => '=',
    // ...
]

Note: while specifying filter controls take actual data exchange format, which your API uses, in mind. Make sure each specified control keyword is valid for the format. For example, in XML tag name can start only with a letter character, thus controls like >, '=' or $gt will break the XML schema.

public array $filterControls = [
    
'and' => 'AND',
    
'or' => 'OR',
    
'not' => 'NOT',
    
'lt' => '<',
    
'gt' => '>',
    
'lte' => '<=',
    
'gte' => '>=',
    
'eq' => '=',
    
'neq' => '!=',
    
'in' => 'IN',
    
'nin' => 'NOT IN',
    
'like' => 'LIKE',
]
$multiValueOperators public property

List of operators keywords, which should accept multiple values.

public array $multiValueOperators = [
    
'IN',
    
'NOT IN',
]
$nullValue public property (available since version 2.0.40)

Representation of null instead of literal null in case the latter cannot be used.

public string $nullValue 'NULL'
$operatorTypes public property

Specifies the list of supported search attribute types per each operator. This field should be in format: 'operatorKeyword' => ['type1', 'type2' ...]. Supported types list can be specified as *, which indicates that operator supports all types available. Any unspecified keyword will not be considered as a valid operator.

public array $operatorTypes = [
    
'<' => [
        
self::TYPE_INTEGER,
        
self::TYPE_FLOAT,
        
self::TYPE_DATETIME,
        
self::TYPE_DATE,
        
self::TYPE_TIME,
    ],
    
'>' => [
        
self::TYPE_INTEGER,
        
self::TYPE_FLOAT,
        
self::TYPE_DATETIME,
        
self::TYPE_DATE,
        
self::TYPE_TIME,
    ],
    
'<=' => [
        
self::TYPE_INTEGER,
        
self::TYPE_FLOAT,
        
self::TYPE_DATETIME,
        
self::TYPE_DATE,
        
self::TYPE_TIME,
    ],
    
'>=' => [
        
self::TYPE_INTEGER,
        
self::TYPE_FLOAT,
        
self::TYPE_DATETIME,
        
self::TYPE_DATE,
        
self::TYPE_TIME,
    ],
    
'=' => '*',
    
'!=' => '*',
    
'IN' => '*',
    
'NOT IN' => '*',
    
'LIKE' => [
        
self::TYPE_STRING,
    ],
]
$searchAttributeTypes public property

Search attribute type map. Note that the type of this property differs in getter and setter. See getSearchAttributeTypes() and setSearchAttributeTypes() for details.

$searchModel public property

Model instance. Note that the type of this property differs in getter and setter. See getSearchModel() and setSearchModel() for details.

Method Details

Hide inherited methods

__call() public method

Defined in: yii\base\Component::__call()

Calls the named method which is not a class method.

This method will check if any attached behavior has the named method and will execute it if available.

Do not call this method directly as it is a PHP magic method that will be implicitly called when an unknown method is being invoked.

public mixed __call ( $name, $params )
$name string

The method name

$params array

Method parameters

return mixed

The method return value

throws yii\base\UnknownMethodException

when calling unknown method

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            
__clone() public method

Defined in: yii\base\Model::__clone()

This method is called after the object is created by cloning an existing one.

It removes all behaviors because they are attached to the old object.

public void __clone ( )

                public function __clone()
{
    parent::__clone();
    $this->_errors = null;
    $this->_validators = null;
}

            
__construct() public method

Defined in: yii\base\BaseObject::__construct()

Constructor.

The default implementation does two things:

  • Initializes the object with the given configuration $config.
  • Call init().

If this method is overridden in a child class, it is recommended that

  • the last parameter of the constructor is a configuration array, like $config here.
  • call the parent implementation at the end of the constructor.
public void __construct ( $config = [] )
$config array

Name-value pairs that will be used to initialize the object properties

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            
__get() public method

Returns the value of a component property.

This method will check in the following order and act accordingly:

  • a property defined by a getter: return the getter result
  • a property of a behavior: return the behavior property value

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing $value = $component->property;.

public mixed __get ( $name )
$name string

The property name

return mixed

The property value or the value of a behavior's property

throws yii\base\UnknownPropertyException

if the property is not defined

throws yii\base\InvalidCallException

if the property is write-only.

                public function __get($name)
{
    if ($name === $this->filterAttributeName) {
        return $this->getFilter();
    }
    return parent::__get($name);
}

            
__isset() public method

Checks if a property is set, i.e. defined and not null.

This method will check in the following order and act accordingly:

  • a property defined by a setter: return whether the property is set
  • a property of a behavior: return whether the property is set
  • return false for non existing properties

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing isset($component->property).

public boolean __isset ( $name )
$name string

The property name or the event name

return boolean

Whether the named property is set

                public function __isset($name)
{
    if ($name === $this->filterAttributeName) {
        return $this->getFilter() !== null;
    }
    return parent::__isset($name);
}

            
__set() public method

Sets the value of a component property.

This method will check in the following order and act accordingly:

  • a property defined by a setter: set the property value
  • an event in the format of "on xyz": attach the handler to the event "xyz"
  • a behavior in the format of "as xyz": attach the behavior named as "xyz"
  • a property of a behavior: set the behavior property value

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing $component->property = $value;.

public void __set ( $name, $value )
$name string

The property name or the event name

$value mixed

The property value

throws yii\base\UnknownPropertyException

if the property is not defined

throws yii\base\InvalidCallException

if the property is read-only.

                public function __set($name, $value)
{
    if ($name === $this->filterAttributeName) {
        $this->setFilter($value);
    } else {
        parent::__set($name, $value);
    }
}

            
__unset() public method

Sets a component property to be null.

This method will check in the following order and act accordingly:

  • a property defined by a setter: set the property value to be null
  • a property of a behavior: set the property value to be null

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing unset($component->property).

public void __unset ( $name )
$name string

The property name

throws yii\base\InvalidCallException

if the property is read only.

                public function __unset($name)
{
    if ($name === $this->filterAttributeName) {
        $this->setFilter(null);
    } else {
        parent::__unset($name);
    }
}

            
activeAttributes() public method

Defined in: yii\base\Model::activeAttributes()

Returns the attribute names that are subject to validation in the current scenario.

public string[] activeAttributes ( )
return string[]

Safe attribute names

                public function activeAttributes()
{
    $scenario = $this->getScenario();
    $scenarios = $this->scenarios();
    if (!isset($scenarios[$scenario])) {
        return [];
    }
    $attributes = array_keys(array_flip($scenarios[$scenario]));
    foreach ($attributes as $i => $attribute) {
        if (strncmp($attribute, '!', 1) === 0) {
            $attributes[$i] = substr($attribute, 1);
        }
    }
    return $attributes;
}

            
addError() public method

Defined in: yii\base\Model::addError()

Adds a new error to the specified attribute.

public void addError ( $attribute, $error '' )
$attribute string

Attribute name

$error string

New error message

                public function addError($attribute, $error = '')
{
    $this->_errors[$attribute][] = $error;
}

            
addErrors() public method (available since version 2.0.2)

Defined in: yii\base\Model::addErrors()

Adds a list of errors.

public void addErrors ( array $items )
$items array

A list of errors. The array keys must be attribute names. The array values should be error messages. If an attribute has multiple errors, these errors must be given in terms of an array. You may use the result of getErrors() as the value for this parameter.

                public function addErrors(array $items)
{
    foreach ($items as $attribute => $errors) {
        if (is_array($errors)) {
            foreach ($errors as $error) {
                $this->addError($attribute, $error);
            }
        } else {
            $this->addError($attribute, $errors);
        }
    }
}

            
afterValidate() public method

Defined in: yii\base\Model::afterValidate()

This method is invoked after validation ends.

The default implementation raises an afterValidate event. You may override this method to do postprocessing after validation. Make sure the parent implementation is invoked so that the event can be raised.

public void afterValidate ( )

                public function afterValidate()
{
    $this->trigger(self::EVENT_AFTER_VALIDATE);
}

            
attachBehavior() public method

Defined in: yii\base\Component::attachBehavior()

Attaches a behavior to this component.

This method will create the behavior object based on the given configuration. After that, the behavior object will be attached to this component by calling the yii\base\Behavior::attach() method.

See also detachBehavior().

public yii\base\Behavior attachBehavior ( $name, $behavior )
$name string

The name of the behavior.

$behavior string|array|yii\base\Behavior

The behavior configuration. This can be one of the following:

return yii\base\Behavior

The behavior object

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            
attachBehaviors() public method

Defined in: yii\base\Component::attachBehaviors()

Attaches a list of behaviors to the component.

Each behavior is indexed by its name and should be a yii\base\Behavior object, a string specifying the behavior class, or an configuration array for creating the behavior.

See also attachBehavior().

public void attachBehaviors ( $behaviors )
$behaviors array

List of behaviors to be attached to the component

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            
attributeHints() public method (available since version 2.0.4)

Defined in: yii\base\Model::attributeHints()

Returns the attribute hints.

Attribute hints are mainly used for display purpose. For example, given an attribute isPublic, we can declare a hint Whether the post should be visible for not logged in users, which provides user-friendly description of the attribute meaning and can be displayed to end users.

Unlike label hint will not be generated, if its explicit declaration is omitted.

Note, in order to inherit hints defined in the parent class, a child class needs to merge the parent hints with child hints using functions such as array_merge().

public array attributeHints ( )
return array

Attribute hints (name => hint)

                public function attributeHints()
{
    return [];
}

            
attributeLabels() public method

Returns the attribute labels.

Attribute labels are mainly used for display purpose. For example, given an attribute firstName, we can declare a label First Name which is more user-friendly and can be displayed to end users.

By default an attribute label is generated using generateAttributeLabel(). This method allows you to explicitly specify attribute labels.

Note, in order to inherit labels defined in the parent class, a child class needs to merge the parent labels with child labels using functions such as array_merge().

public array attributeLabels ( )
return array

Attribute labels (name => label)

                public function attributeLabels()
{
    return [
        $this->filterAttributeName => $this->filterAttributeLabel,
    ];
}

            
attributes() public method

Returns the list of attribute names.

By default, this method returns all public non-static properties of the class. You may override this method to change the default behavior.

public string[] attributes ( )
return string[]

List of attribute names.

                public function attributes()
{
    return [
        $this->filterAttributeName,
    ];
}

            
beforeValidate() public method

Defined in: yii\base\Model::beforeValidate()

This method is invoked before validation starts.

The default implementation raises a beforeValidate event. You may override this method to do preliminary checks before validation. Make sure the parent implementation is invoked so that the event can be raised.

public boolean beforeValidate ( )
return boolean

Whether the validation should be executed. Defaults to true. If false is returned, the validation will stop and the model is considered invalid.

                public function beforeValidate()
{
    $event = new ModelEvent();
    $this->trigger(self::EVENT_BEFORE_VALIDATE, $event);
    return $event->isValid;
}

            
behaviors() public method

Defined in: yii\base\Component::behaviors()

Returns a list of behaviors that this component should behave as.

Child classes may override this method to specify the behaviors they want to behave as.

The return value of this method should be an array of behavior objects or configurations indexed by behavior names. A behavior configuration can be either a string specifying the behavior class or an array of the following structure:

'behaviorName' => [
    'class' => 'BehaviorClass',
    'property1' => 'value1',
    'property2' => 'value2',
]

Note that a behavior class must extend from yii\base\Behavior. Behaviors can be attached using a name or anonymously. When a name is used as the array key, using this name, the behavior can later be retrieved using getBehavior() or be detached using detachBehavior(). Anonymous behaviors can not be retrieved or detached.

Behaviors declared in this method will be attached to the component automatically (on demand).

public array behaviors ( )
return array

The behavior configurations.

                public function behaviors()
{
    return [];
}

            
build() public method

Builds actual filter specification form $filter value.

public mixed|false build ( $runValidation true )
$runValidation boolean

Whether to perform validation (calling validate()) before building the filter. Defaults to true. If the validation fails, no filter will be built and this method will return false.

return mixed|false

Built actual filter value, or false if validation fails.

                public function build($runValidation = true)
{
    if ($runValidation && !$this->validate()) {
        return false;
    }
    return $this->buildInternal();
}

            
buildInternal() protected method

Performs actual filter build.

By default this method returns result of normalize(). The child class may override this method providing more specific implementation.

protected mixed buildInternal ( )
return mixed

Built actual filter value.

                protected function buildInternal()
{
    return $this->normalize(false);
}

            
canGetProperty() public method

Returns a value indicating whether a property can be read.

A property can be read if:

  • the class has a getter method associated with the specified name (in this case, property name is case-insensitive);
  • the class has a member variable with the specified name (when $checkVars is true);
  • an attached behavior has a readable property of the given name (when $checkBehaviors is true).
public boolean canGetProperty ( $name, $checkVars true, $checkBehaviors true )
$name string

The property name

$checkVars boolean

Whether to treat member variables as properties

$checkBehaviors boolean

Whether to treat behaviors' properties as properties of this component

return boolean

Whether the property can be read

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if ($name === $this->filterAttributeName) {
        return true;
    }
    return parent::canGetProperty($name, $checkVars, $checkBehaviors);
}

            
canSetProperty() public method

Returns a value indicating whether a property can be set.

A property can be written if:

  • the class has a setter method associated with the specified name (in this case, property name is case-insensitive);
  • the class has a member variable with the specified name (when $checkVars is true);
  • an attached behavior has a writable property of the given name (when $checkBehaviors is true).
public boolean canSetProperty ( $name, $checkVars true, $checkBehaviors true )
$name string

The property name

$checkVars boolean

Whether to treat member variables as properties

$checkBehaviors boolean

Whether to treat behaviors' properties as properties of this component

return boolean

Whether the property can be written

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if ($name === $this->filterAttributeName) {
        return true;
    }
    return parent::canSetProperty($name, $checkVars, $checkBehaviors);
}

            
className() public static method
Deprecated since 2.0.14. On PHP >=5.5, use ::class instead.

Defined in: yii\base\BaseObject::className()

Returns the fully qualified name of this class.

public static string className ( )
return string

The fully qualified name of this class.

                public static function className()
{
    return get_called_class();
}

            
clearErrors() public method

Defined in: yii\base\Model::clearErrors()

Removes errors for all attributes or a single attribute.

public void clearErrors ( $attribute null )
$attribute string|null

Attribute name. Use null to remove errors for all attributes.

                public function clearErrors($attribute = null)
{
    if ($attribute === null) {
        $this->_errors = [];
    } else {
        unset($this->_errors[$attribute]);
    }
}

            
createValidators() public method

Defined in: yii\base\Model::createValidators()

Creates validator objects based on the validation rules specified in rules().

Unlike getValidators(), each time this method is called, a new list of validators will be returned.

public ArrayObject createValidators ( )
return ArrayObject

Validators

throws yii\base\InvalidConfigException

if any validation rule configuration is invalid

                public function createValidators()
{
    $validators = new ArrayObject();
    foreach ($this->rules() as $rule) {
        if ($rule instanceof Validator) {
            $validators->append($rule);
        } elseif (is_array($rule) && isset($rule[0], $rule[1])) { // attributes, validator type
            $validator = Validator::createValidator($rule[1], $this, (array) $rule[0], array_slice($rule, 2));
            $validators->append($validator);
        } else {
            throw new InvalidConfigException('Invalid validation rule: a rule must specify both attribute names and validator type.');
        }
    }
    return $validators;
}

            
defaultErrorMessages() protected method

Returns default values for $errorMessages.

protected array defaultErrorMessages ( )
return array

Default error messages in [errorKey => message] format.

                protected function defaultErrorMessages()
{
    return [
        'invalidFilter' => Yii::t('yii', 'The format of {filter} is invalid.'),
        'operatorRequireMultipleOperands' => Yii::t('yii', 'Operator "{operator}" requires multiple operands.'),
        'unknownAttribute' => Yii::t('yii', 'Unknown filter attribute "{attribute}"'),
        'invalidAttributeValueFormat' => Yii::t('yii', 'Condition for "{attribute}" should be either a value or valid operator specification.'),
        'operatorRequireAttribute' => Yii::t('yii', 'Operator "{operator}" must be used with a search attribute.'),
        'unsupportedOperatorType' => Yii::t('yii', '"{attribute}" does not support operator "{operator}".'),
    ];
}

            
detachBehavior() public method

Defined in: yii\base\Component::detachBehavior()

Detaches a behavior from the component.

The behavior's yii\base\Behavior::detach() method will be invoked.

public yii\base\Behavior|null detachBehavior ( $name )
$name string

The behavior's name.

return yii\base\Behavior|null

The detached behavior. Null if the behavior does not exist.

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            
detachBehaviors() public method

Defined in: yii\base\Component::detachBehaviors()

Detaches all behaviors from the component.

public void detachBehaviors ( )

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            
detectSearchAttributeType() protected method (available since version 2.0.14)

Detect attribute type from given validator.

protected string|null detectSearchAttributeType ( yii\validators\Validator $validator )
$validator yii\validators\Validator

Validator from which to detect attribute type.

return string|null

Detected attribute type.

                protected function detectSearchAttributeType(Validator $validator)
{
    if ($validator instanceof BooleanValidator) {
        return self::TYPE_BOOLEAN;
    }
    if ($validator instanceof NumberValidator) {
        return $validator->integerOnly ? self::TYPE_INTEGER : self::TYPE_FLOAT;
    }
    if ($validator instanceof StringValidator) {
        return self::TYPE_STRING;
    }
    if ($validator instanceof EachValidator) {
        return self::TYPE_ARRAY;
    }
    if ($validator instanceof DateValidator) {
        if ($validator->type == DateValidator::TYPE_DATETIME) {
            return self::TYPE_DATETIME;
        }
        if ($validator->type == DateValidator::TYPE_TIME) {
            return self::TYPE_TIME;
        }
        return self::TYPE_DATE;
    }
}

            
detectSearchAttributeTypes() protected method

Composes default value for $searchAttributeTypes from the $searchModel validation rules.

protected array detectSearchAttributeTypes ( )
return array

Attribute type map.

                protected function detectSearchAttributeTypes()
{
    $model = $this->getSearchModel();
    $attributeTypes = [];
    foreach ($model->activeAttributes() as $attribute) {
        $attributeTypes[$attribute] = self::TYPE_STRING;
    }
    foreach ($model->getValidators() as $validator) {
        $type = $this->detectSearchAttributeType($validator);
        if ($type !== null) {
            foreach ((array) $validator->attributes as $attribute) {
                $attributeTypes[$attribute] = $type;
            }
        }
    }
    return $attributeTypes;
}

            
ensureBehaviors() public method

Defined in: yii\base\Component::ensureBehaviors()

Makes sure that the behaviors declared in behaviors() are attached to this component.

public void ensureBehaviors ( )

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            
extraFields() public method

Defined in: yii\base\ArrayableTrait::extraFields()

Returns the list of fields that can be expanded further and returned by toArray().

This method is similar to fields() except that the list of fields returned by this method are not returned by default by toArray(). Only when field names to be expanded are explicitly specified when calling toArray(), will their values be exported.

The default implementation returns an empty array.

You may override this method to return a list of expandable fields based on some context information (e.g. the current application user).

See also:

public array extraFields ( )
return array

The list of expandable field names or field definitions. Please refer to fields() on the format of the return value.

                public function extraFields()
{
    return [];
}

            
extractFieldsFor() protected method (available since version 2.0.14)

Defined in: yii\base\ArrayableTrait::extractFieldsFor()

Extract nested fields from a fields collection for a given root field Nested fields are separated with dots (.). e.g: "item.id" The previous example would extract "id".

protected array extractFieldsFor ( array $fields, $rootField )
$fields array

The fields requested for extraction

$rootField string

The root field for which we want to extract the nested fields

return array

Nested fields extracted for the given field

                protected function extractFieldsFor(array $fields, $rootField)
{
    $result = [];
    foreach ($fields as $field) {
        if (0 === strpos($field, "{$rootField}.")) {
            $result[] = preg_replace('/^' . preg_quote($rootField, '/') . '\./i', '', $field);
        }
    }
    return array_unique($result);
}

            
extractRootFields() protected method (available since version 2.0.14)

Defined in: yii\base\ArrayableTrait::extractRootFields()

Extracts the root field names from nested fields.

Nested fields are separated with dots (.). e.g: "item.id" The previous example would extract "item".

protected array extractRootFields ( array $fields )
$fields array

The fields requested for extraction

return array

Root fields extracted from the given nested fields

                protected function extractRootFields(array $fields)
{
    $result = [];
    foreach ($fields as $field) {
        $result[] = current(explode('.', $field, 2));
    }
    if (in_array('*', $result, true)) {
        $result = [];
    }
    return array_unique($result);
}

            
fields() public method

Defined in: yii\base\ArrayableTrait::fields()

Returns the list of fields that should be returned by default by toArray() when no specific fields are specified.

A field is a named element in the returned array by toArray().

This method should return an array of field names or field definitions. If the former, the field name will be treated as an object property name whose value will be used as the field value. If the latter, the array key should be the field name while the array value should be the corresponding field definition which can be either an object property name or a PHP callable returning the corresponding field value. The signature of the callable should be:

function ($model, $field) {
    // return field value
}

For example, the following code declares four fields:

  • email: the field name is the same as the property name email;
  • firstName and lastName: the field names are firstName and lastName, and their values are obtained from the first_name and last_name properties;
  • fullName: the field name is fullName. Its value is obtained by concatenating first_name and last_name.
return [
    'email',
    'firstName' => 'first_name',
    'lastName' => 'last_name',
    'fullName' => function () {
        return $this->first_name . ' ' . $this->last_name;
    },
];

In this method, you may also want to return different lists of fields based on some context information. For example, depending on the privilege of the current application user, you may return different sets of visible fields or filter out some fields.

The default implementation of this method returns the public object member variables indexed by themselves.

See also toArray().

public array fields ( )
return array

The list of field names or field definitions.

                public function fields()
{
    $fields = array_keys(Yii::getObjectVars($this));
    return array_combine($fields, $fields);
}

            
filterAttributeValue() protected method

Validates attribute value in the scope of $searchModel, applying attribute value filters if any.

protected mixed filterAttributeValue ( $attribute, $value )
$attribute string

Attribute name.

$value mixed

Attribute value.

return mixed

Filtered attribute value.

                protected function filterAttributeValue($attribute, $value)
{
    $model = $this->getSearchModel();
    if (!$model->isAttributeSafe($attribute)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return $value;
    }
    $model->{$attribute} = $value;
    if (!$model->validate([$attribute])) {
        $this->addError($this->filterAttributeName, $model->getFirstError($attribute));
        return $value;
    }
    return $model->{$attribute};
}

            
formName() public method

Returns the form name that this model class should use.

The form name is mainly used by yii\widgets\ActiveForm to determine how to name the input fields for the attributes in a model. If the form name is "A" and an attribute name is "b", then the corresponding input name would be "A[b]". If the form name is an empty string, then the input name would be "b".

The purpose of the above naming schema is that for forms which contain multiple different models, the attributes of each model are grouped in sub-arrays of the POST-data and it is easier to differentiate between them.

By default, this method returns the model class name (without the namespace part) as the form name. You may override it when the model is used in different forms.

public string formName ( )
return string

The form name of this model class.

throws yii\base\InvalidConfigException

when form is defined with anonymous class and formName() method is not overridden.

                public function formName()
{
    return '';
}

            
generateAttributeLabel() public method

Defined in: yii\base\Model::generateAttributeLabel()

Generates a user friendly attribute label based on the give attribute name.

This is done by replacing underscores, dashes and dots with blanks and changing the first letter of each word to upper case. For example, 'department_name' or 'DepartmentName' will generate 'Department Name'.

public string generateAttributeLabel ( $name )
$name string

The column name

return string

The attribute label

                public function generateAttributeLabel($name)
{
    return Inflector::camel2words($name, true);
}

            
getActiveValidators() public method

Defined in: yii\base\Model::getActiveValidators()

Returns the validators applicable to the current $scenario.

public yii\validators\Validator[] getActiveValidators ( $attribute null )
$attribute string|null

The name of the attribute whose applicable validators should be returned. If this is null, the validators for ALL attributes in the model will be returned.

return yii\validators\Validator[]

The validators applicable to the current $scenario.

                public function getActiveValidators($attribute = null)
{
    $activeAttributes = $this->activeAttributes();
    if ($attribute !== null && !in_array($attribute, $activeAttributes, true)) {
        return [];
    }
    $scenario = $this->getScenario();
    $validators = [];
    foreach ($this->getValidators() as $validator) {
        if ($attribute === null) {
            $validatorAttributes = $validator->getValidationAttributes($activeAttributes);
            $attributeValid = !empty($validatorAttributes);
        } else {
            $attributeValid = in_array($attribute, $validator->getValidationAttributes($attribute), true);
        }
        if ($attributeValid && $validator->isActive($scenario)) {
            $validators[] = $validator;
        }
    }
    return $validators;
}

            
getAttributeHint() public method (available since version 2.0.4)

Defined in: yii\base\Model::getAttributeHint()

Returns the text hint for the specified attribute.

See also attributeHints().

public string getAttributeHint ( $attribute )
$attribute string

The attribute name

return string

The attribute hint

                public function getAttributeHint($attribute)
{
    $hints = $this->attributeHints();
    return isset($hints[$attribute]) ? $hints[$attribute] : '';
}

            
getAttributeLabel() public method

Defined in: yii\base\Model::getAttributeLabel()

Returns the text label for the specified attribute.

See also:

public string getAttributeLabel ( $attribute )
$attribute string

The attribute name

return string

The attribute label

                public function getAttributeLabel($attribute)
{
    $labels = $this->attributeLabels();
    return isset($labels[$attribute]) ? $labels[$attribute] : $this->generateAttributeLabel($attribute);
}

            
getAttributes() public method

Defined in: yii\base\Model::getAttributes()

Returns attribute values.

public array getAttributes ( $names null, $except = [] )
$names array|null

List of attributes whose value needs to be returned. Defaults to null, meaning all attributes listed in attributes() will be returned. If it is an array, only the attributes in the array will be returned.

$except array

List of attributes whose value should NOT be returned.

return array

Attribute values (name => value).

                public function getAttributes($names = null, $except = [])
{
    $values = [];
    if ($names === null) {
        $names = $this->attributes();
    }
    foreach ($names as $name) {
        $values[$name] = $this->$name;
    }
    foreach ($except as $name) {
        unset($values[$name]);
    }
    return $values;
}

            
getBehavior() public method

Defined in: yii\base\Component::getBehavior()

Returns the named behavior object.

public yii\base\Behavior|null getBehavior ( $name )
$name string

The behavior name

return yii\base\Behavior|null

The behavior object, or null if the behavior does not exist

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            
getBehaviors() public method

Defined in: yii\base\Component::getBehaviors()

Returns all behaviors attached to this component.

public yii\base\Behavior[] getBehaviors ( )
return yii\base\Behavior[]

List of behaviors attached to this component

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            
getErrorMessages() public method

public array getErrorMessages ( )
return array

Error messages in format [errorKey => message].

                public function getErrorMessages()
{
    if (!is_array($this->_errorMessages)) {
        if ($this->_errorMessages === null) {
            $this->_errorMessages = $this->defaultErrorMessages();
        } else {
            $this->_errorMessages = array_merge(
                $this->defaultErrorMessages(),
                call_user_func($this->_errorMessages)
            );
        }
    }
    return $this->_errorMessages;
}

            
getErrorSummary() public method (available since version 2.0.14)

Defined in: yii\base\Model::getErrorSummary()

Returns the errors for all attributes as a one-dimensional array.

See also:

public array getErrorSummary ( $showAllErrors )
$showAllErrors boolean

Boolean, if set to true every error message for each attribute will be shown otherwise only the first error message for each attribute will be shown.

return array

Errors for all attributes as a one-dimensional array. Empty array is returned if no error.

                public function getErrorSummary($showAllErrors)
{
    $lines = [];
    $errors = $showAllErrors ? $this->getErrors() : $this->getFirstErrors();
    foreach ($errors as $es) {
        $lines = array_merge($lines, (array)$es);
    }
    return $lines;
}

            
getErrors() public method

Defined in: yii\base\Model::getErrors()

Returns the errors for all attributes or a single attribute.

See also:

public array getErrors ( $attribute null )
$attribute string|null

Attribute name. Use null to retrieve errors for all attributes.

return array

Errors for all attributes or the specified attribute. Empty array is returned if no error. See getErrors() for detailed description. Note that when returning errors for all attributes, the result is a two-dimensional array, like the following:

[
    'username' => [
        'Username is required.',
        'Username must contain only word characters.',
    ],
    'email' => [
        'Email address is invalid.',
    ]
]

                public function getErrors($attribute = null)
{
    if ($attribute === null) {
        return $this->_errors === null ? [] : $this->_errors;
    }
    return isset($this->_errors[$attribute]) ? $this->_errors[$attribute] : [];
}

            
getFilter() public method

public mixed getFilter ( )
return mixed

Raw filter value.

                public function getFilter()
{
    return $this->_filter;
}

            
getFirstError() public method

Defined in: yii\base\Model::getFirstError()

Returns the first error of the specified attribute.

See also:

public string|null getFirstError ( $attribute )
$attribute string

Attribute name.

return string|null

The error message. Null is returned if no error.

                public function getFirstError($attribute)
{
    return isset($this->_errors[$attribute]) ? reset($this->_errors[$attribute]) : null;
}

            
getFirstErrors() public method

Defined in: yii\base\Model::getFirstErrors()

Returns the first error of every attribute in the model.

See also:

public array getFirstErrors ( )
return array

The first errors. The array keys are the attribute names, and the array values are the corresponding error messages. An empty array will be returned if there is no error.

                public function getFirstErrors()
{
    if (empty($this->_errors)) {
        return [];
    }
    $errors = [];
    foreach ($this->_errors as $name => $es) {
        if (!empty($es)) {
            $errors[$name] = reset($es);
        }
    }
    return $errors;
}

            
getIterator() public method

Defined in: yii\base\Model::getIterator()

Returns an iterator for traversing the attributes in the model.

This method is required by the interface IteratorAggregate.

public ArrayIterator getIterator ( )
return ArrayIterator

An iterator for traversing the items in the list.

                #[\ReturnTypeWillChange]
public function getIterator()
{
    $attributes = $this->getAttributes();
    return new ArrayIterator($attributes);
}

            
getScenario() public method

Defined in: yii\base\Model::getScenario()

Returns the scenario that this model is used in.

Scenario affects how validation is performed and which attributes can be massively assigned.

public string getScenario ( )
return string

The scenario that this model is in. Defaults to SCENARIO_DEFAULT.

                public function getScenario()
{
    return $this->_scenario;
}

            
getSearchAttributeTypes() public method

public array getSearchAttributeTypes ( )
return array

Search attribute type map.

                public function getSearchAttributeTypes()
{
    if ($this->_searchAttributeTypes === null) {
        $this->_searchAttributeTypes = $this->detectSearchAttributeTypes();
    }
    return $this->_searchAttributeTypes;
}

            
getSearchModel() public method

public yii\base\Model getSearchModel ( )
return yii\base\Model

Model instance.

throws yii\base\InvalidConfigException

on invalid configuration.

                public function getSearchModel()
{
    if (!is_object($this->_searchModel) || $this->_searchModel instanceof \Closure) {
        $model = Yii::createObject($this->_searchModel);
        if (!$model instanceof Model) {
            throw new InvalidConfigException('`' . get_class($this) . '::$searchModel` should be an instance of `' . Model::className() . '` or its DI compatible configuration.');
        }
        $this->_searchModel = $model;
    }
    return $this->_searchModel;
}

            
getValidators() public method

Defined in: yii\base\Model::getValidators()

Returns all the validators declared in rules().

This method differs from getActiveValidators() in that the latter only returns the validators applicable to the current $scenario.

Because this method returns an ArrayObject object, you may manipulate it by inserting or removing validators (useful in model behaviors). For example,

$model->validators[] = $newValidator;
public ArrayObject|yii\validators\Validator[] getValidators ( )
return ArrayObject|yii\validators\Validator[]

All the validators declared in the model.

                public function getValidators()
{
    if ($this->_validators === null) {
        $this->_validators = $this->createValidators();
    }
    return $this->_validators;
}

            
hasErrors() public method

Defined in: yii\base\Model::hasErrors()

Returns a value indicating whether there is any validation error.

public boolean hasErrors ( $attribute null )
$attribute string|null

Attribute name. Use null to check all attributes.

return boolean

Whether there is any error.

                public function hasErrors($attribute = null)
{
    return $attribute === null ? !empty($this->_errors) : isset($this->_errors[$attribute]);
}

            
hasEventHandlers() public method

Defined in: yii\base\Component::hasEventHandlers()

Returns a value indicating whether there is any handler attached to the named event.

public boolean hasEventHandlers ( $name )
$name string

The event name

return boolean

Whether there is any handler attached to the event.

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            
hasMethod() public method

Defined in: yii\base\Component::hasMethod()

Returns a value indicating whether a method is defined.

A method is defined if:

  • the class has a method with the specified name
  • an attached behavior has a method with the given name (when $checkBehaviors is true).
public boolean hasMethod ( $name, $checkBehaviors true )
$name string

The property name

$checkBehaviors boolean

Whether to treat behaviors' methods as methods of this component

return boolean

Whether the method is defined

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            
hasProperty() public method

Defined in: yii\base\Component::hasProperty()

Returns a value indicating whether a property is defined for this component.

A property is defined if:

  • the class has a getter or setter method associated with the specified name (in this case, property name is case-insensitive);
  • the class has a member variable with the specified name (when $checkVars is true);
  • an attached behavior has a property of the given name (when $checkBehaviors is true).

See also:

public boolean hasProperty ( $name, $checkVars true, $checkBehaviors true )
$name string

The property name

$checkVars boolean

Whether to treat member variables as properties

$checkBehaviors boolean

Whether to treat behaviors' properties as properties of this component

return boolean

Whether the property is defined

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            
init() public method

Defined in: yii\base\BaseObject::init()

Initializes the object.

This method is invoked at the end of the constructor after the object is initialized with the given configuration.

public void init ( )

                public function init()
{
}

            
instance() public static method

Defined in: yii\base\StaticInstanceTrait::instance()

Returns static class instance, which can be used to obtain meta information.

public static static instance ( $refresh false )
$refresh boolean

Whether to re-create static instance even, if it is already cached.

return yii\data\DataFilter

Class instance.

                public static function instance($refresh = false)
{
    $className = get_called_class();
    if ($refresh || !isset(self::$_instances[$className])) {
        self::$_instances[$className] = Yii::createObject($className);
    }
    return self::$_instances[$className];
}

            
isAttributeActive() public method

Defined in: yii\base\Model::isAttributeActive()

Returns a value indicating whether the attribute is active in the current scenario.

See also activeAttributes().

public boolean isAttributeActive ( $attribute )
$attribute string

Attribute name

return boolean

Whether the attribute is active in the current scenario

                public function isAttributeActive($attribute)
{
    return in_array($attribute, $this->activeAttributes(), true);
}

            
isAttributeRequired() public method

Defined in: yii\base\Model::isAttributeRequired()

Returns a value indicating whether the attribute is required.

This is determined by checking if the attribute is associated with a required validation rule in the current $scenario.

Note that when the validator has a conditional validation applied using $when this method will return false regardless of the when condition because it may be called be before the model is loaded with data.

public boolean isAttributeRequired ( $attribute )
$attribute string

Attribute name

return boolean

Whether the attribute is required

                public function isAttributeRequired($attribute)
{
    foreach ($this->getActiveValidators($attribute) as $validator) {
        if ($validator instanceof RequiredValidator && $validator->when === null) {
            return true;
        }
    }
    return false;
}

            
isAttributeSafe() public method

Defined in: yii\base\Model::isAttributeSafe()

Returns a value indicating whether the attribute is safe for massive assignments.

See also safeAttributes().

public boolean isAttributeSafe ( $attribute )
$attribute string

Attribute name

return boolean

Whether the attribute is safe for massive assignments

                public function isAttributeSafe($attribute)
{
    return in_array($attribute, $this->safeAttributes(), true);
}

            
load() public method

Defined in: yii\base\Model::load()

Populates the model with input data.

This method provides a convenient shortcut for:

if (isset($_POST['FormName'])) {
    $model->attributes = $_POST['FormName'];
    if ($model->save()) {
        // handle success
    }
}

which, with load() can be written as:

if ($model->load($_POST) && $model->save()) {
    // handle success
}

load() gets the 'FormName' from the model's formName() method (which you may override), unless the $formName parameter is given. If the form name is empty, load() populates the model with the whole of $data, instead of $data['FormName'].

Note, that the data being populated is subject to the safety check by setAttributes().

public boolean load ( $data, $formName null )
$data array

The data array to load, typically $_POST or $_GET.

$formName string|null

The form name to use to load the data into the model, empty string when form not use. If not set, formName() is used.

return boolean

Whether load() found the expected form in $data.

                public function load($data, $formName = null)
{
    $scope = $formName === null ? $this->formName() : $formName;
    if ($scope === '' && !empty($data)) {
        $this->setAttributes($data);
        return true;
    } elseif (isset($data[$scope])) {
        $this->setAttributes($data[$scope]);
        return true;
    }
    return false;
}

            
loadMultiple() public static method

Defined in: yii\base\Model::loadMultiple()

Populates a set of models with the data from end user.

This method is mainly used to collect tabular data input. The data to be loaded for each model is $data[formName][index], where formName refers to the value of formName(), and index the index of the model in the $models array. If formName() is empty, $data[index] will be used to populate each model. The data being populated to each model is subject to the safety check by setAttributes().

public static boolean loadMultiple ( $models, $data, $formName null )
$models array

The models to be populated. Note that all models should have the same class.

$data array

The data array. This is usually $_POST or $_GET, but can also be any valid array supplied by end user.

$formName string|null

The form name to be used for loading the data into the models. If not set, it will use the formName() value of the first model in $models. This parameter is available since version 2.0.1.

return boolean

Whether at least one of the models is successfully populated.

                public static function loadMultiple($models, $data, $formName = null)
{
    if ($formName === null) {
        /* @var $first Model|false */
        $first = reset($models);
        if ($first === false) {
            return false;
        }
        $formName = $first->formName();
    }
    $success = false;
    foreach ($models as $i => $model) {
        /* @var $model Model */
        if ($formName == '') {
            if (!empty($data[$i]) && $model->load($data[$i], '')) {
                $success = true;
            }
        } elseif (!empty($data[$formName][$i]) && $model->load($data[$formName][$i], '')) {
            $success = true;
        }
    }
    return $success;
}

            
normalize() public method

Normalizes filter value, replacing raw keys according to $filterControls and $attributeMap.

public array|boolean normalize ( $runValidation true )
$runValidation boolean

Whether to perform validation (calling validate()) before normalizing the filter. Defaults to true. If the validation fails, no filter will be processed and this method will return false.

return array|boolean

Normalized filter value, or false if validation fails.

                public function normalize($runValidation = true)
{
    if ($runValidation && !$this->validate()) {
        return false;
    }
    $filter = $this->getFilter();
    if (!is_array($filter) || empty($filter)) {
        return [];
    }
    return $this->normalizeComplexFilter($filter);
}

            
off() public method

Defined in: yii\base\Component::off()

Detaches an existing event handler from this component.

This method is the opposite of on().

Note: in case wildcard pattern is passed for event name, only the handlers registered with this wildcard will be removed, while handlers registered with plain names matching this wildcard will remain.

See also on().

public boolean off ( $name, $handler null )
$name string

Event name

$handler callable|null

The event handler to be removed. If it is null, all handlers attached to the named event will be removed.

return boolean

If a handler is found and detached

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            
offsetExists() public method

Defined in: yii\base\Model::offsetExists()

Returns whether there is an element at the specified offset.

This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like isset($model[$offset]).

public boolean offsetExists ( $offset )
$offset string

The offset to check on.

return boolean

Whether or not an offset exists.

                #[\ReturnTypeWillChange]
public function offsetExists($offset)
{
    return isset($this->$offset);
}

            
offsetGet() public method

Defined in: yii\base\Model::offsetGet()

Returns the element at the specified offset.

This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like $value = $model[$offset];.

public mixed offsetGet ( $offset )
$offset string

The offset to retrieve element.

return mixed

The element at the offset, null if no element is found at the offset

                #[\ReturnTypeWillChange]
public function offsetGet($offset)
{
    return $this->$offset;
}

            
offsetSet() public method

Defined in: yii\base\Model::offsetSet()

Sets the element at the specified offset.

This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like $model[$offset] = $value;.

public void offsetSet ( $offset, $value )
$offset string

The offset to set element

$value mixed

The element value

                #[\ReturnTypeWillChange]
public function offsetSet($offset, $value)
{
    $this->$offset = $value;
}

            
offsetUnset() public method

Defined in: yii\base\Model::offsetUnset()

Sets the element value at the specified offset to null.

This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like unset($model[$offset]).

public void offsetUnset ( $offset )
$offset string

The offset to unset element

                #[\ReturnTypeWillChange]
public function offsetUnset($offset)
{
    $this->$offset = null;
}

            
on() public method

Defined in: yii\base\Component::on()

Attaches an event handler to an event.

The event handler must be a valid PHP callback. The following are some examples:

function ($event) { ... }         // anonymous function
[$object, 'handleClick']          // $object->handleClick()
['Page', 'handleClick']           // Page::handleClick()
'handleClick'                     // global function handleClick()

The event handler must be defined with the following signature,

function ($event)

where $event is an yii\base\Event object which includes parameters associated with the event.

Since 2.0.14 you can specify event name as a wildcard pattern:

$component->on('event.group.*', function ($event) {
    Yii::trace($event->name . ' is triggered.');
});

See also off().

public void on ( $name, $handler, $data null, $append true )
$name string

The event name

$handler callable

The event handler

$data mixed

The data to be passed to the event handler when the event is triggered. When the event handler is invoked, this data can be accessed via yii\base\Event::$data.

$append boolean

Whether to append new event handler to the end of the existing handler list. If false, the new handler will be inserted at the beginning of the existing handler list.

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            
onUnsafeAttribute() public method

Defined in: yii\base\Model::onUnsafeAttribute()

This method is invoked when an unsafe attribute is being massively assigned.

The default implementation will log a warning message if YII_DEBUG is on. It does nothing otherwise.

public void onUnsafeAttribute ( $name, $value )
$name string

The unsafe attribute name

$value mixed

The attribute value

                public function onUnsafeAttribute($name, $value)
{
    if (YII_DEBUG) {
        Yii::debug("Failed to set unsafe attribute '$name' in '" . get_class($this) . "'.", __METHOD__);
    }
}

            
parseErrorMessage() protected method

Parses content of the message from $errorMessages, specified by message key.

protected string parseErrorMessage ( $messageKey, $params = [] )
$messageKey string

Message key.

$params array

Params to be parsed into the message.

return string

Composed message string.

                protected function parseErrorMessage($messageKey, $params = [])
{
    $messages = $this->getErrorMessages();
    if (isset($messages[$messageKey])) {
        $message = $messages[$messageKey];
    } else {
        $message = Yii::t('yii', 'The format of {filter} is invalid.');
    }
    $params = array_merge(
        [
            'filter' => $this->getAttributeLabel($this->filterAttributeName),
        ],
        $params
    );
    return Yii::$app->getI18n()->format($message, $params, Yii::$app->language);
}

            
resolveFields() protected method

Defined in: yii\base\ArrayableTrait::resolveFields()

Determines which fields can be returned by toArray().

This method will first extract the root fields from the given fields. Then it will check the requested root fields against those declared in fields() and extraFields() to determine which fields can be returned.

protected array resolveFields ( array $fields, array $expand )
$fields array

The fields being requested for exporting

$expand array

The additional fields being requested for exporting

return array

The list of fields to be exported. The array keys are the field names, and the array values are the corresponding object property names or PHP callables returning the field values.

                protected function resolveFields(array $fields, array $expand)
{
    $fields = $this->extractRootFields($fields);
    $expand = $this->extractRootFields($expand);
    $result = [];
    foreach ($this->fields() as $field => $definition) {
        if (is_int($field)) {
            $field = $definition;
        }
        if (empty($fields) || in_array($field, $fields, true)) {
            $result[$field] = $definition;
        }
    }
    if (empty($expand)) {
        return $result;
    }
    foreach ($this->extraFields() as $field => $definition) {
        if (is_int($field)) {
            $field = $definition;
        }
        if (in_array($field, $expand, true)) {
            $result[$field] = $definition;
        }
    }
    return $result;
}

            
rules() public method

Returns the validation rules for attributes.

Validation rules are used by validate() to check if attribute values are valid. Child classes may override this method to declare different validation rules.

Each rule is an array with the following structure:

[
    ['attribute1', 'attribute2'],
    'validator type',
    'on' => ['scenario1', 'scenario2'],
    //...other parameters...
]

where

  • attribute list: required, specifies the attributes array to be validated, for single attribute you can pass a string;
  • validator type: required, specifies the validator to be used. It can be a built-in validator name, a method name of the model class, an anonymous function, or a validator class name.
  • on: optional, specifies the scenarios array in which the validation rule can be applied. If this option is not set, the rule will apply to all scenarios.
  • additional name-value pairs can be specified to initialize the corresponding validator properties. Please refer to individual validator class API for possible properties.

A validator can be either an object of a class extending yii\validators\Validator, or a model class method (called inline validator) that has the following signature:

// $params refers to validation parameters given in the rule
function validatorName($attribute, $params)

In the above $attribute refers to the attribute currently being validated while $params contains an array of validator configuration options such as max in case of string validator. The value of the attribute currently being validated can be accessed as $this->$attribute. Note the $ before attribute; this is taking the value of the variable $attribute and using it as the name of the property to access.

Yii also provides a set of built-in validators. Each one has an alias name which can be used when specifying a validation rule.

Below are some examples:

[
    // built-in "required" validator
    [['username', 'password'], 'required'],
    // built-in "string" validator customized with "min" and "max" properties
    ['username', 'string', 'min' => 3, 'max' => 12],
    // built-in "compare" validator that is used in "register" scenario only
    ['password', 'compare', 'compareAttribute' => 'password2', 'on' => 'register'],
    // an inline validator defined via the "authenticate()" method in the model class
    ['password', 'authenticate', 'on' => 'login'],
    // a validator of class "DateRangeValidator"
    ['dateRange', 'DateRangeValidator'],
];

Note, in order to inherit rules defined in the parent class, a child class needs to merge the parent rules with child rules using functions such as array_merge().

public array rules ( )
return array

Validation rules

                public function rules()
{
    return [
        [$this->filterAttributeName, 'validateFilter', 'skipOnEmpty' => false],
    ];
}

            
safeAttributes() public method

Defined in: yii\base\Model::safeAttributes()

Returns the attribute names that are safe to be massively assigned in the current scenario.

public string[] safeAttributes ( )
return string[]

Safe attribute names

                public function safeAttributes()
{
    $scenario = $this->getScenario();
    $scenarios = $this->scenarios();
    if (!isset($scenarios[$scenario])) {
        return [];
    }
    $attributes = [];
    foreach ($scenarios[$scenario] as $attribute) {
        if (
            $attribute !== ''
            && strncmp($attribute, '!', 1) !== 0
            && !in_array('!' . $attribute, $scenarios[$scenario])
        ) {
            $attributes[] = $attribute;
        }
    }
    return $attributes;
}

            
scenarios() public method

Defined in: yii\base\Model::scenarios()

Returns a list of scenarios and the corresponding active attributes.

An active attribute is one that is subject to validation in the current scenario. The returned array should be in the following format:

[
    'scenario1' => ['attribute11', 'attribute12', ...],
    'scenario2' => ['attribute21', 'attribute22', ...],
    ...
]

By default, an active attribute is considered safe and can be massively assigned. If an attribute should NOT be massively assigned (thus considered unsafe), please prefix the attribute with an exclamation character (e.g. '!rank').

The default implementation of this method will return all scenarios found in the rules() declaration. A special scenario named SCENARIO_DEFAULT will contain all attributes found in the rules(). Each scenario will be associated with the attributes that are being validated by the validation rules that apply to the scenario.

public array scenarios ( )
return array

A list of scenarios and the corresponding active attributes.

                public function scenarios()
{
    $scenarios = [self::SCENARIO_DEFAULT => []];
    foreach ($this->getValidators() as $validator) {
        foreach ($validator->on as $scenario) {
            $scenarios[$scenario] = [];
        }
        foreach ($validator->except as $scenario) {
            $scenarios[$scenario] = [];
        }
    }
    $names = array_keys($scenarios);
    foreach ($this->getValidators() as $validator) {
        if (empty($validator->on) && empty($validator->except)) {
            foreach ($names as $name) {
                foreach ($validator->attributes as $attribute) {
                    $scenarios[$name][$attribute] = true;
                }
            }
        } elseif (empty($validator->on)) {
            foreach ($names as $name) {
                if (!in_array($name, $validator->except, true)) {
                    foreach ($validator->attributes as $attribute) {
                        $scenarios[$name][$attribute] = true;
                    }
                }
            }
        } else {
            foreach ($validator->on as $name) {
                foreach ($validator->attributes as $attribute) {
                    $scenarios[$name][$attribute] = true;
                }
            }
        }
    }
    foreach ($scenarios as $scenario => $attributes) {
        if (!empty($attributes)) {
            $scenarios[$scenario] = array_keys($attributes);
        }
    }
    return $scenarios;
}

            
setAttributes() public method

Defined in: yii\base\Model::setAttributes()

Sets the attribute values in a massive way.

See also:

public void setAttributes ( $values, $safeOnly true )
$values array

Attribute values (name => value) to be assigned to the model.

$safeOnly boolean

Whether the assignments should only be done to the safe attributes. A safe attribute is one that is associated with a validation rule in the current $scenario.

                public function setAttributes($values, $safeOnly = true)
{
    if (is_array($values)) {
        $attributes = array_flip($safeOnly ? $this->safeAttributes() : $this->attributes());
        foreach ($values as $name => $value) {
            if (isset($attributes[$name])) {
                $this->$name = $value;
            } elseif ($safeOnly) {
                $this->onUnsafeAttribute($name, $value);
            }
        }
    }
}

            
setErrorMessages() public method

Sets the list of error messages responding to invalid filter structure, in format: [errorKey => message].

Message may contain placeholders that will be populated depending on the message context. For each message a {filter} placeholder is available referring to the label for $filterAttributeName attribute.

public void setErrorMessages ( $errorMessages )
$errorMessages array|Closure

Error messages in [errorKey => message] format, or a PHP callback returning them.

                public function setErrorMessages($errorMessages)
{
    if (is_array($errorMessages)) {
        $errorMessages = array_merge($this->defaultErrorMessages(), $errorMessages);
    }
    $this->_errorMessages = $errorMessages;
}

            
setFilter() public method

public void setFilter ( $filter )
$filter mixed

Raw filter value.

                public function setFilter($filter)
{
    $this->_filter = $filter;
}

            
setScenario() public method

Defined in: yii\base\Model::setScenario()

Sets the scenario for the model.

Note that this method does not check if the scenario exists or not. The method validate() will perform this check.

public void setScenario ( $value )
$value string

The scenario that this model is in.

                public function setScenario($value)
{
    $this->_scenario = $value;
}

            
setSearchAttributeTypes() public method

public void setSearchAttributeTypes ( $searchAttributeTypes )
$searchAttributeTypes array|null

Search attribute type map.

                public function setSearchAttributeTypes($searchAttributeTypes)
{
    $this->_searchAttributeTypes = $searchAttributeTypes;
}

            
setSearchModel() public method

public void setSearchModel ( $model )
$model yii\base\Model|array|string|callable

Model instance or its DI compatible configuration.

throws yii\base\InvalidConfigException

on invalid configuration.

                public function setSearchModel($model)
{
    if (is_object($model) && !$model instanceof Model && !$model instanceof \Closure) {
        throw new InvalidConfigException('`' . get_class($this) . '::$searchModel` should be an instance of `' . Model::className() . '` or its DI compatible configuration.');
    }
    $this->_searchModel = $model;
}

            
toArray() public method

Defined in: yii\base\ArrayableTrait::toArray()

Converts the model into an array.

This method will first identify which fields to be included in the resulting array by calling resolveFields(). It will then turn the model into an array with these fields. If $recursive is true, any embedded objects will also be converted into arrays. When embedded objects are yii\base\Arrayable, their respective nested fields will be extracted and passed to toArray().

If the model implements the yii\web\Linkable interface, the resulting array will also have a _link element which refers to a list of links as specified by the interface.

public array toArray ( array $fields = [], array $expand = [], $recursive true )
$fields array

The fields being requested. If empty or if it contains '*', all fields as specified by fields() will be returned. Fields can be nested, separated with dots (.). e.g.: item.field.sub-field $recursive must be true for nested fields to be extracted. If $recursive is false, only the root fields will be extracted.

$expand array

The additional fields being requested for exporting. Only fields declared in extraFields() will be considered. Expand can also be nested, separated with dots (.). e.g.: item.expand1.expand2 $recursive must be true for nested expands to be extracted. If $recursive is false, only the root expands will be extracted.

$recursive boolean

Whether to recursively return array representation of embedded objects.

return array

The array representation of the object

                public function toArray(array $fields = [], array $expand = [], $recursive = true)
{
    $data = [];
    foreach ($this->resolveFields($fields, $expand) as $field => $definition) {
        $attribute = is_string($definition) ? $this->$definition : $definition($this, $field);
        if ($recursive) {
            $nestedFields = $this->extractFieldsFor($fields, $field);
            $nestedExpand = $this->extractFieldsFor($expand, $field);
            if ($attribute instanceof Arrayable) {
                $attribute = $attribute->toArray($nestedFields, $nestedExpand);
            } elseif ($attribute instanceof \JsonSerializable) {
                $attribute = $attribute->jsonSerialize();
            } elseif (is_array($attribute)) {
                $attribute = array_map(
                    function ($item) use ($nestedFields, $nestedExpand) {
                        if ($item instanceof Arrayable) {
                            return $item->toArray($nestedFields, $nestedExpand);
                        } elseif ($item instanceof \JsonSerializable) {
                            return $item->jsonSerialize();
                        }
                        return $item;
                    },
                    $attribute
                );
            }
        }
        $data[$field] = $attribute;
    }
    if ($this instanceof Linkable) {
        $data['_links'] = Link::serialize($this->getLinks());
    }
    return $recursive ? ArrayHelper::toArray($data) : $data;
}

            
trigger() public method

Defined in: yii\base\Component::trigger()

Triggers an event.

This method represents the happening of an event. It invokes all attached handlers for the event including class-level handlers.

public void trigger ( $name, yii\base\Event $event null )
$name string

The event name

$event yii\base\Event|null

The event instance. If not set, a default yii\base\Event object will be created.

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            
validate() public method

Defined in: yii\base\Model::validate()

Performs the data validation.

This method executes the validation rules applicable to the current $scenario. The following criteria are used to determine whether a rule is currently applicable:

  • the rule must be associated with the attributes relevant to the current scenario;
  • the rules must be effective for the current scenario.

This method will call beforeValidate() and afterValidate() before and after the actual validation, respectively. If beforeValidate() returns false, the validation will be cancelled and afterValidate() will not be called.

Errors found during the validation can be retrieved via getErrors(), getFirstErrors() and getFirstError().

public boolean validate ( $attributeNames null, $clearErrors true )
$attributeNames string[]|string|null

Attribute name or list of attribute names that should be validated. If this parameter is empty, it means any attribute listed in the applicable validation rules should be validated.

$clearErrors boolean

Whether to call clearErrors() before performing validation

return boolean

Whether the validation is successful without any error.

throws yii\base\InvalidArgumentException

if the current scenario is unknown.

                public function validate($attributeNames = null, $clearErrors = true)
{
    if ($clearErrors) {
        $this->clearErrors();
    }
    if (!$this->beforeValidate()) {
        return false;
    }
    $scenarios = $this->scenarios();
    $scenario = $this->getScenario();
    if (!isset($scenarios[$scenario])) {
        throw new InvalidArgumentException("Unknown scenario: $scenario");
    }
    if ($attributeNames === null) {
        $attributeNames = $this->activeAttributes();
    }
    $attributeNames = (array)$attributeNames;
    foreach ($this->getActiveValidators() as $validator) {
        $validator->validateAttributes($this, $attributeNames);
    }
    $this->afterValidate();
    return !$this->hasErrors();
}

            
validateAttributeCondition() protected method

Validates search condition for a particular attribute.

protected void validateAttributeCondition ( $attribute, $condition )
$attribute string

Search attribute name.

$condition mixed

Search condition.

                protected function validateAttributeCondition($attribute, $condition)
{
    $attributeTypes = $this->getSearchAttributeTypes();
    if (!isset($attributeTypes[$attribute])) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return;
    }
    if (is_array($condition)) {
        $operatorCount = 0;
        foreach ($condition as $rawOperator => $value) {
            if (isset($this->filterControls[$rawOperator])) {
                $operator = $this->filterControls[$rawOperator];
                if (isset($this->operatorTypes[$operator])) {
                    $operatorCount++;
                    $this->validateOperatorCondition($rawOperator, $value, $attribute);
                }
            }
        }
        if ($operatorCount > 0) {
            if ($operatorCount < count($condition)) {
                $this->addError($this->filterAttributeName, $this->parseErrorMessage('invalidAttributeValueFormat', ['attribute' => $attribute]));
            }
        } else {
            // attribute may allow array value:
            $this->validateAttributeValue($attribute, $condition);
        }
    } else {
        $this->validateAttributeValue($attribute, $condition);
    }
}

            
validateAttributeValue() protected method

Validates attribute value in the scope of model.

protected void validateAttributeValue ( $attribute, $value )
$attribute string

Attribute name.

$value mixed

Attribute value.

                protected function validateAttributeValue($attribute, $value)
{
    $model = $this->getSearchModel();
    if (!$model->isAttributeSafe($attribute)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return;
    }
    $model->{$attribute} = $value === $this->nullValue ? null : $value;
    if (!$model->validate([$attribute])) {
        $this->addError($this->filterAttributeName, $model->getFirstError($attribute));
        return;
    }
}

            
validateBlockCondition() protected method

Validates block condition that consists of a single condition.

This covers such operators as not.

protected void validateBlockCondition ( $operator, $condition )
$operator string

Raw operator control keyword.

$condition mixed

Raw condition.

                protected function validateBlockCondition($operator, $condition)
{
    $this->validateCondition($condition);
}

            
validateCondition() protected method

Validates filter condition.

protected void validateCondition ( $condition )
$condition mixed

Raw filter condition.

                protected function validateCondition($condition)
{
    if (!is_array($condition)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('invalidFilter'));
        return;
    }
    if (empty($condition)) {
        return;
    }
    foreach ($condition as $key => $value) {
        $method = 'validateAttributeCondition';
        if (isset($this->filterControls[$key])) {
            $controlKey = $this->filterControls[$key];
            if (isset($this->conditionValidators[$controlKey])) {
                $method = $this->conditionValidators[$controlKey];
            }
        }
        $this->$method($key, $value);
    }
}

            
validateConjunctionCondition() protected method

Validates conjunction condition that consists of multiple independent ones.

This covers such operators as and and or.

protected void validateConjunctionCondition ( $operator, $condition )
$operator string

Raw operator control keyword.

$condition mixed

Raw condition.

                protected function validateConjunctionCondition($operator, $condition)
{
    if (!is_array($condition) || !ArrayHelper::isIndexed($condition)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireMultipleOperands', ['operator' => $operator]));
        return;
    }
    foreach ($condition as $part) {
        $this->validateCondition($part);
    }
}

            
validateFilter() public method

Validates filter attribute value to match filer condition specification.

public void validateFilter ( )

                public function validateFilter()
{
    $value = $this->getFilter();
    if ($value !== null) {
        $this->validateCondition($value);
    }
}

            
validateMultiple() public static method

Defined in: yii\base\Model::validateMultiple()

Validates multiple models.

This method will validate every model. The models being validated may be of the same or different types.

public static boolean validateMultiple ( $models, $attributeNames null )
$models array

The models to be validated

$attributeNames array|null

List of attribute names that should be validated. If this parameter is empty, it means any attribute listed in the applicable validation rules should be validated.

return boolean

Whether all models are valid. False will be returned if one or multiple models have validation error.

                public static function validateMultiple($models, $attributeNames = null)
{
    $valid = true;
    /* @var $model Model */
    foreach ($models as $model) {
        $valid = $model->validate($attributeNames) && $valid;
    }
    return $valid;
}

            
validateOperatorCondition() protected method

Validates operator condition.

protected void validateOperatorCondition ( $operator, $condition, $attribute null )
$operator string

Raw operator control keyword.

$condition mixed

Attribute condition.

$attribute string|null

Attribute name.

                protected function validateOperatorCondition($operator, $condition, $attribute = null)
{
    if ($attribute === null) {
        // absence of an attribute indicates that operator has been placed in a wrong position
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireAttribute', ['operator' => $operator]));
        return;
    }
    $internalOperator = $this->filterControls[$operator];
    // check operator type :
    $operatorTypes = $this->operatorTypes[$internalOperator];
    if ($operatorTypes !== '*') {
        $attributeTypes = $this->getSearchAttributeTypes();
        $attributeType = $attributeTypes[$attribute];
        if (!in_array($attributeType, $operatorTypes, true)) {
            $this->addError($this->filterAttributeName, $this->parseErrorMessage('unsupportedOperatorType', ['attribute' => $attribute, 'operator' => $operator]));
            return;
        }
    }
    if (in_array($internalOperator, $this->multiValueOperators, true)) {
        // multi-value operator:
        if (!is_array($condition)) {
            $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireMultipleOperands', ['operator' => $operator]));
        } else {
            foreach ($condition as $v) {
                $this->validateAttributeValue($attribute, $v);
            }
        }
    } else {
        // single-value operator :
        $this->validateAttributeValue($attribute, $condition);
    }
}