Class yii\base\Model

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

Adds a new error to the specified attribute.

Adds a list of errors.

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.

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().

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().

See also generateAttributeLabel().

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.

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.

Removes errors for all attributes or a single attribute.

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.

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 ($model) {
        return $model->first_name . ' ' . $model->last_name;
    },
];

In this method, you may also want to return different lists of fields based on some context information. For example, depending on \yii\base\scenario or 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 attributes() indexed by the same attribute names.

See also toArray().

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.

See also load().

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'.

Returns the validators applicable to the current \yii\base\scenario.

Returns the text hint for the specified attribute.

See also attributeHints().

Returns the text label for the specified attribute.

See also:

• generateAttributeLabel()
• attributeLabels()

Returns attribute values.

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

See also:

• getErrors()
• getFirstErrors()

Returns the errors for all attributes or a single attribute.

See also:

• getFirstErrors()
• getFirstError()

Returns the first error of the specified attribute.

See also:

• getErrors()
• getFirstErrors()

Returns the first error of every attribute in the model.

See also:

• getErrors()
• getFirstError()

Returns an iterator for traversing the attributes in the model.

This method is required by the interface IteratorAggregate.

Returns the scenario that this model is used in.

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

Returns all the validators declared in rules().

This method differs from getActiveValidators() in that the latter only returns the validators applicable to the current \yii\base\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;

Returns a value indicating whether there is any validation error.

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

See also activeAttributes().

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 \yii\base\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.

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

See also safeAttributes().

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().

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().

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]).

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];.

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] = $item;.

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]).

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.

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 \yii\base\scenario 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().

See also scenarios().

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

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.

Sets the attribute values in a massive way.

See also:

• safeAttributes()
• attributes()

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.

Performs the data validation.

This method executes the validation rules applicable to the current \yii\base\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().

Validates multiple models.

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