Class yii\db\ActiveRecord

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

            

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

            

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

            

                public function __get($name)
{
    if (array_key_exists($name, $this->_attributes)) {
        return $this->_attributes[$name];
    }
    if ($this->hasAttribute($name)) {
        return null;
    }
    if (array_key_exists($name, $this->_related)) {
        return $this->_related[$name];
    }
    $value = parent::__get($name);
    if ($value instanceof ActiveQueryInterface) {
        $this->setRelationDependencies($name, $value);
        return $this->_related[$name] = $value->findFor($name, $this);
    }
    return $value;
}

            

                public function __isset($name)
{
    try {
        return $this->__get($name) !== null;
    } catch (\Exception $t) {
        return false;
    } catch (\Throwable $e) {
        return false;
    }
}

            

                public function __set($name, $value)
{
    if ($this->hasAttribute($name)) {
        if (
            !empty($this->_relationsDependencies[$name])
            && (!array_key_exists($name, $this->_attributes) || $this->_attributes[$name] !== $value)
        ) {
            $this->resetDependentRelations($name);
        }
        $this->_attributes[$name] = $value;
    } else {
        parent::__set($name, $value);
    }
}

            

                public function __unset($name)
{
    if ($this->hasAttribute($name)) {
        unset($this->_attributes[$name]);
        if (!empty($this->_relationsDependencies[$name])) {
            $this->resetDependentRelations($name);
        }
    } elseif (array_key_exists($name, $this->_related)) {
        unset($this->_related[$name]);
    } elseif ($this->getRelation($name, false) === null) {
        parent::__unset($name);
    }
}

            

                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;
}

            

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

            

                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);
        }
    }
}

            

                public function afterDelete()
{
    $this->trigger(self::EVENT_AFTER_DELETE);
}

            

                public function afterFind()
{
    $this->trigger(self::EVENT_AFTER_FIND);
}

            

                public function afterRefresh()
{
    $this->trigger(self::EVENT_AFTER_REFRESH);
}

            

                public function afterSave($insert, $changedAttributes)
{
    $this->trigger($insert ? self::EVENT_AFTER_INSERT : self::EVENT_AFTER_UPDATE, new AfterSaveEvent([
        'changedAttributes' => $changedAttributes,
    ]));
}

            

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

            

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

            

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

            

                public function attributeHints()
{
    return [];
}

            

                public function attributeLabels()
{
    return [];
}

            

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

            

                public function beforeSave($insert)
{
    $event = new ModelEvent();
    $this->trigger($insert ? self::EVENT_BEFORE_INSERT : self::EVENT_BEFORE_UPDATE, $event);
    return $event->isValid;
}

            

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

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (parent::canGetProperty($name, $checkVars, $checkBehaviors)) {
        return true;
    }
    try {
        return $this->hasAttribute($name);
    } catch (\Exception $e) {
        // `hasAttribute()` may fail on base/abstract classes in case automatic attribute list fetching used
        return false;
    }
}

            

                public function canSetOldAttribute($name)
{
    return (isset($this->_oldAttributes[$name]) || $this->hasAttribute($name));
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (parent::canSetProperty($name, $checkVars, $checkBehaviors)) {
        return true;
    }
    try {
        return $this->hasAttribute($name);
    } catch (\Exception $e) {
        // `hasAttribute()` may fail on base/abstract classes in case automatic attribute list fetching used
        return false;
    }
}

            

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

            

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

            

                protected function createRelationQuery($class, $link, $multiple)
{
    /* @var $class ActiveRecordInterface */
    /* @var $query ActiveQuery */
    $query = $class::find();
    $query->primaryModel = $this;
    $query->link = $link;
    $query->multiple = $multiple;
    return $query;
}

            

                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;
}

            

                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;
}

            

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

            

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

            

                public function extraFields()
{
    return [];
}

            

                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);
}

            

                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);
}

            

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

            

                public static function findAll($condition)
{
    return static::findByCondition($condition)->all();
}

            

                public static function findOne($condition)
{
    return static::findByCondition($condition)->one();
}

            

                public function formName()
{
    $reflector = new ReflectionClass($this);
    if (PHP_VERSION_ID >= 70000 && $reflector->isAnonymous()) {
        throw new InvalidConfigException('The "formName()" method should be explicitly defined for anonymous models');
    }
    return $reflector->getShortName();
}

            

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

            

                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;
}

            

                public function getAttribute($name)
{
    return isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
}

            

                public function getAttributeHint($attribute)
{
    $hints = $this->attributeHints();
    if (isset($hints[$attribute])) {
        return $hints[$attribute];
    } elseif (strpos($attribute, '.')) {
        $attributeParts = explode('.', $attribute);
        $neededAttribute = array_pop($attributeParts);
        $relatedModel = $this;
        foreach ($attributeParts as $relationName) {
            if ($relatedModel->isRelationPopulated($relationName) && $relatedModel->$relationName instanceof self) {
                $relatedModel = $relatedModel->$relationName;
            } else {
                try {
                    $relation = $relatedModel->getRelation($relationName);
                } catch (InvalidParamException $e) {
                    return '';
                }
                /* @var $modelClass ActiveRecordInterface */
                $modelClass = $relation->modelClass;
                $relatedModel = $modelClass::instance();
            }
        }
        $hints = $relatedModel->attributeHints();
        if (isset($hints[$neededAttribute])) {
            return $hints[$neededAttribute];
        }
    }
    return '';
}

            

                public function getAttributeLabel($attribute)
{
    $model = $this;
    $modelAttribute = $attribute;
    for (;;) {
        $labels = $model->attributeLabels();
        if (isset($labels[$modelAttribute])) {
            return $labels[$modelAttribute];
        }
        $parts = explode('.', $modelAttribute, 2);
        if (count($parts) < 2) {
            break;
        }
        list ($relationName, $modelAttribute) = $parts;
        if ($model->isRelationPopulated($relationName) && $model->$relationName instanceof self) {
            $model = $model->$relationName;
        } else {
            try {
                $relation = $model->getRelation($relationName);
            } catch (InvalidArgumentException $e) {
                break;
            }
            /* @var $modelClass ActiveRecordInterface */
            $modelClass = $relation->modelClass;
            $model = $modelClass::instance();
        }
    }
    return $this->generateAttributeLabel($attribute);
}

            

                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;
}

            

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

            

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

            

                public function getDirtyAttributes($names = null)
{
    if ($names === null) {
        $names = $this->attributes();
    }
    $names = array_flip($names);
    $attributes = [];
    if ($this->_oldAttributes === null) {
        foreach ($this->_attributes as $name => $value) {
            if (isset($names[$name])) {
                $attributes[$name] = $value;
            }
        }
    } else {
        foreach ($this->_attributes as $name => $value) {
            if (isset($names[$name]) && (!array_key_exists($name, $this->_oldAttributes) || $this->isValueDifferent($value, $this->_oldAttributes[$name]))) {
                $attributes[$name] = $value;
            }
        }
    }
    return $attributes;
}

            

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

            

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

            

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

            

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

            

                public function getIsNewRecord()
{
    return $this->_oldAttributes === null;
}

            

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

            

                public function getOldAttribute($name)
{
    return isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
}

            

                public function getOldAttributes()
{
    return $this->_oldAttributes === null ? [] : $this->_oldAttributes;
}

            

                public function getOldPrimaryKey($asArray = false)
{
    $keys = static::primaryKey();
    if (empty($keys)) {
        throw new Exception(get_class($this) . ' does not have a primary key. You should either define a primary key for the corresponding table or override the primaryKey() method.');
    }
    if (!$asArray && count($keys) === 1) {
        return isset($this->_oldAttributes[$keys[0]]) ? $this->_oldAttributes[$keys[0]] : null;
    }
    $values = [];
    foreach ($keys as $name) {
        $values[$name] = isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
    }
    return $values;
}

            

                public function getPrimaryKey($asArray = false)
{
    $keys = static::primaryKey();
    if (!$asArray && count($keys) === 1) {
        return isset($this->_attributes[$keys[0]]) ? $this->_attributes[$keys[0]] : null;
    }
    $values = [];
    foreach ($keys as $name) {
        $values[$name] = isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
    }
    return $values;
}

            

                public function getRelatedRecords()
{
    return $this->_related;
}

            

                public function getRelation($name, $throwException = true)
{
    $getter = 'get' . $name;
    try {
        // the relation could be defined in a behavior
        $relation = $this->$getter();
    } catch (UnknownMethodException $e) {
        if ($throwException) {
            throw new InvalidArgumentException(get_class($this) . ' has no relation named "' . $name . '".', 0, $e);
        }
        return null;
    }
    if (!$relation instanceof ActiveQueryInterface) {
        if ($throwException) {
            throw new InvalidArgumentException(get_class($this) . ' has no relation named "' . $name . '".');
        }
        return null;
    }
    if (method_exists($this, $getter)) {
        // relation name is case sensitive, trying to validate it when the relation is defined within this class
        $method = new \ReflectionMethod($this, $getter);
        $realName = lcfirst(substr($method->getName(), 3));
        if ($realName !== $name) {
            if ($throwException) {
                throw new InvalidArgumentException('Relation names are case sensitive. ' . get_class($this) . " has a relation named \"$realName\" instead of \"$name\".");
            }
            return null;
        }
    }
    return $relation;
}

            

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

            

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

            

                public function hasAttribute($name)
{
    return isset($this->_attributes[$name]) || in_array($name, $this->attributes(), true);
}

            

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

            

                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);
}

            

                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;
}

            

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

            

                public function init()
{
    parent::init();
    $this->trigger(self::EVENT_INIT);
}

            

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

            

                public static function instantiate($row)
{
    return new static();
}

            

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

            

                public function isAttributeChanged($name, $identical = true)
{
    if (isset($this->_attributes[$name], $this->_oldAttributes[$name])) {
        if ($identical) {
            return $this->_attributes[$name] !== $this->_oldAttributes[$name];
        }
        return $this->_attributes[$name] != $this->_oldAttributes[$name];
    }
    return isset($this->_attributes[$name]) || isset($this->_oldAttributes[$name]);
}

            

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

            

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

            

                public static function isPrimaryKey($keys)
{
    $pks = static::primaryKey();
    if (count($keys) === count($pks)) {
        return count(array_intersect($keys, $pks)) === count($pks);
    }
    return false;
}

            

                public function isRelationPopulated($name)
{
    return array_key_exists($name, $this->_related);
}

            

                public function link($name, $model, $extraColumns = [])
{
    /* @var $relation ActiveQueryInterface|ActiveQuery */
    $relation = $this->getRelation($name);
    if ($relation->via !== null) {
        if ($this->getIsNewRecord() || $model->getIsNewRecord()) {
            throw new InvalidCallException('Unable to link models: the models being linked cannot be newly created.');
        }
        if (is_array($relation->via)) {
            /* @var $viaRelation ActiveQuery */
            list($viaName, $viaRelation) = $relation->via;
            $viaClass = $viaRelation->modelClass;
            // unset $viaName so that it can be reloaded to reflect the change
            unset($this->_related[$viaName]);
        } else {
            $viaRelation = $relation->via;
            $viaTable = reset($relation->via->from);
        }
        $columns = [];
        foreach ($viaRelation->link as $a => $b) {
            $columns[$a] = $this->$b;
        }
        foreach ($relation->link as $a => $b) {
            $columns[$b] = $model->$a;
        }
        foreach ($extraColumns as $k => $v) {
            $columns[$k] = $v;
        }
        if (is_array($relation->via)) {
            /* @var $viaClass ActiveRecordInterface */
            /* @var $record ActiveRecordInterface */
            $record = Yii::createObject($viaClass);
            foreach ($columns as $column => $value) {
                $record->$column = $value;
            }
            $record->insert(false);
        } else {
            /* @var $viaTable string */
            static::getDb()->createCommand()->insert($viaTable, $columns)->execute();
        }
    } else {
        $p1 = $model->isPrimaryKey(array_keys($relation->link));
        $p2 = static::isPrimaryKey(array_values($relation->link));
        if ($p1 && $p2) {
            if ($this->getIsNewRecord()) {
                if ($model->getIsNewRecord()) {
                    throw new InvalidCallException('Unable to link models: at most one model can be newly created.');
                }
                $this->bindModels(array_flip($relation->link), $this, $model);
            } else {
                $this->bindModels($relation->link, $model, $this);
            }
        } elseif ($p1) {
            $this->bindModels(array_flip($relation->link), $this, $model);
        } elseif ($p2) {
            $this->bindModels($relation->link, $model, $this);
        } else {
            throw new InvalidCallException('Unable to link models: the link defining the relation does not involve any primary key.');
        }
    }
    // update lazily loaded related objects
    if (!$relation->multiple) {
        $this->_related[$name] = $model;
    } elseif (isset($this->_related[$name])) {
        if ($relation->indexBy !== null) {
            if ($relation->indexBy instanceof \Closure) {
                $index = call_user_func($relation->indexBy, $model);
            } else {
                $index = $model->{$relation->indexBy};
            }
            $this->_related[$name][$index] = $model;
        } else {
            $this->_related[$name][] = $model;
        }
    }
}

            

                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;
}

            

                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;
}

            

                public function loadRelations($relationNames, $asArray = false)
{
    $models = [$this];
    static::loadRelationsFor($models, $relationNames, $asArray);
}

            

                public static function loadRelationsFor(&$models, $relationNames, $asArray = false)
{
    // ActiveQueryTrait::findWith() called below assumes $models array is non-empty.
    if (empty($models)) {
        return;
    }
    static::find()->asArray($asArray)->findWith((array)$relationNames, $models);
}

            

                public function markAttributeDirty($name)
{
    unset($this->_oldAttributes[$name]);
}

            

                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;
}

            

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

            

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