Class luya\web\GroupUser

                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()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

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

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                protected function afterLogin($identity, $cookieBased, $duration)
{
    $this->trigger(self::EVENT_AFTER_LOGIN, new UserEvent([
        'identity' => $identity,
        'cookieBased' => $cookieBased,
        'duration' => $duration,
    ]));
}

            

                protected function afterLogout($identity)
{
    $this->trigger(self::EVENT_AFTER_LOGOUT, new UserEvent([
        'identity' => $identity,
    ]));
}

            

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

            

                protected function beforeLogin($identity, $cookieBased, $duration)
{
    $event = new UserEvent([
        'identity' => $identity,
        'cookieBased' => $cookieBased,
        'duration' => $duration,
    ]);
    $this->trigger(self::EVENT_BEFORE_LOGIN, $event);
    return $event->isValid;
}

            

                protected function beforeLogout($identity)
{
    $event = new UserEvent([
        'identity' => $identity,
    ]);
    $this->trigger(self::EVENT_BEFORE_LOGOUT, $event);
    return $event->isValid;
}

            

                public function behaviors()
{
    return [];
}

            

                public function can($permissionName, $params = [], $allowCaching = true)
{
    if ($allowCaching && empty($params) && isset($this->_access[$permissionName])) {
        return $this->_access[$permissionName];
    }
    if (($accessChecker = $this->getAccessChecker()) === null) {
        return false;
    }
    $access = $accessChecker->checkAccess($this->getId(), $permissionName, $params);
    if ($allowCaching && empty($params)) {
        $this->_access[$permissionName] = $access;
    }
    return $access;
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function checkRedirectAcceptable()
{
    $acceptableTypes = Yii::$app->getRequest()->getAcceptableContentTypes();
    if (empty($acceptableTypes) || (count($acceptableTypes) === 1 && array_keys($acceptableTypes)[0] === '*/*')) {
        return true;
    }
    foreach ($acceptableTypes as $type => $params) {
        if (in_array($type, $this->acceptableRedirectTypes, true)) {
            return true;
        }
    }
    return false;
}

            

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

            

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

            

                protected function getAccessChecker()
{
    return $this->accessChecker !== null ? $this->accessChecker : $this->getAuthManager();
}

            

                protected function getAuthManager()
{
    return Yii::$app->getAuthManager();
}

            

                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 getId()
{
    $identity = $this->getIdentity();
    return $identity !== null ? $identity->getId() : null;
}

            

                public function getIdentity($autoRenew = true)
{
    if ($this->_identity === false) {
        if ($this->enableSession && $autoRenew) {
            try {
                $this->_identity = null;
                $this->renewAuthStatus();
            } catch (\Exception $e) {
                $this->_identity = false;
                throw $e;
            } catch (\Throwable $e) {
                $this->_identity = false;
                throw $e;
            }
        } else {
            return null;
        }
    }
    return $this->_identity;
}

            

                protected function getIdentityAndDurationFromCookie()
{
    $value = Yii::$app->getRequest()->getCookies()->getValue($this->identityCookie['name']);
    if ($value === null) {
        return null;
    }
    $data = json_decode($value, true);
    if (is_array($data) && count($data) == 3) {
        list($id, $authKey, $duration) = $data;
        /* @var $class IdentityInterface */
        $class = $this->identityClass;
        $identity = $class::findIdentity($id);
        if ($identity !== null) {
            if (!$identity instanceof IdentityInterface) {
                throw new InvalidValueException("$class::findIdentity() must return an object implementing IdentityInterface.");
            } elseif (!$identity->validateAuthKey($authKey)) {
                $ip = Yii::$app->getRequest()->getUserIP();
                Yii::warning("Invalid cookie auth key attempted for user '$id' from $ip: $authKey", __METHOD__);
            } else {
                return ['identity' => $identity, 'duration' => $duration];
            }
        }
    }
    $this->removeIdentityCookie();
    return null;
}

            

                public function getIsGuest()
{
    return $this->getIdentity() === null;
}

            

                public function getReturnUrl($defaultUrl = null)
{
    $url = Yii::$app->getSession()->get($this->returnUrlParam, $defaultUrl);
    if (is_array($url)) {
        if (isset($url[0])) {
            return Yii::$app->getUrlManager()->createUrl($url);
        }
        $url = null;
    }
    return $url === null ? Yii::$app->getHomeUrl() : $url;
}

            

                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();
    if ($this->identityClass === null) {
        throw new InvalidConfigException('User::identityClass must be set.');
    }
    if ($this->enableAutoLogin && !isset($this->identityCookie['name'])) {
        throw new InvalidConfigException('User::identityCookie must contain the "name" element.');
    }
    if ($this->accessChecker !== null) {
        $this->accessChecker = Instance::ensure($this->accessChecker, '\yii\rbac\CheckAccessInterface');
    }
}

            

                public function login(IdentityInterface $identity, $duration = 0)
{
    if ($this->beforeLogin($identity, false, $duration)) {
        $this->switchIdentity($identity, $duration);
        $id = $identity->getId();
        $ip = Yii::$app->getRequest()->getUserIP();
        if ($this->enableSession) {
            $log = "User '$id' logged in from $ip with duration $duration.";
        } else {
            $log = "User '$id' logged in from $ip. Session not enabled.";
        }
        $this->regenerateCsrfToken();
        Yii::info($log, __METHOD__);
        $this->afterLogin($identity, false, $duration);
    }
    return !$this->getIsGuest();
}

            

                public function loginByAccessToken($token, $type = null)
{
    /* @var $class IdentityInterface */
    $class = $this->identityClass;
    $identity = $class::findIdentityByAccessToken($token, $type);
    if ($identity && $this->login($identity)) {
        return $identity;
    }
    return null;
}

            

                protected function loginByCookie()
{
    $data = $this->getIdentityAndDurationFromCookie();
    if (isset($data['identity'], $data['duration'])) {
        $identity = $data['identity'];
        $duration = $data['duration'];
        if ($this->beforeLogin($identity, true, $duration)) {
            $this->switchIdentity($identity, $this->autoRenewCookie ? $duration : 0);
            $id = $identity->getId();
            $ip = Yii::$app->getRequest()->getUserIP();
            Yii::info("User '$id' logged in from $ip via cookie.", __METHOD__);
            $this->afterLogin($identity, true, $duration);
        }
    }
}

            

                public function loginRequired($checkAjax = true, $checkAcceptHeader = true)
{
    $request = Yii::$app->getRequest();
    $canRedirect = !$checkAcceptHeader || $this->checkRedirectAcceptable();
    if ($this->enableSession
        && $request->getIsGet()
        && (!$checkAjax || !$request->getIsAjax())
        && $canRedirect
    ) {
        $this->setReturnUrl($request->getAbsoluteUrl());
    }
    if ($this->loginUrl !== null && $canRedirect) {
        $loginUrl = (array) $this->loginUrl;
        if ($loginUrl[0] !== Yii::$app->requestedRoute) {
            return Yii::$app->getResponse()->redirect($this->loginUrl);
        }
    }
    throw new ForbiddenHttpException(Yii::t('yii', 'Login Required'));
}

            

                public function logout($destroySession = true)
{
    $identity = $this->getIdentity();
    if ($identity !== null && $this->beforeLogout($identity)) {
        $this->switchIdentity(null);
        $id = $identity->getId();
        $ip = Yii::$app->getRequest()->getUserIP();
        Yii::info("User '$id' logged out from $ip.", __METHOD__);
        if ($destroySession && $this->enableSession) {
            Yii::$app->getSession()->destroy();
        }
        $this->afterLogout($identity);
    }
    return $this->getIsGuest();
}

            

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

            

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

            

                protected function regenerateCsrfToken()
{
    $request = Yii::$app->getRequest();
    if ($request->enableCsrfCookie || $this->enableSession) {
        $request->getCsrfToken(true);
    }
}

            

                protected function removeIdentityCookie()
{
    Yii::$app->getResponse()->getCookies()->remove(Yii::createObject(array_merge($this->identityCookie, [
        'class' => 'yii\web\Cookie',
    ])));
}

            

                protected function renewAuthStatus()
{
    $session = Yii::$app->getSession();
    $id = $session->getHasSessionId() || $session->getIsActive() ? $session->get($this->idParam) : null;
    if ($id === null) {
        $identity = null;
    } else {
        /* @var $class IdentityInterface */
        $class = $this->identityClass;
        $identity = $class::findIdentity($id);
        if ($identity === null) {
            $this->switchIdentity(null);
        }
    }
    if ($identity !== null) {
        $authKey = $session->get($this->authKeyParam);
        if ($authKey !== null && !$identity->validateAuthKey($authKey)) {
            $identity = null;
            $ip = Yii::$app->getRequest()->getUserIP();
            Yii::warning("Invalid session auth key attempted for user '$id' from $ip: $authKey", __METHOD__);
        }
    }
    $this->setIdentity($identity);
    if ($identity !== null && ($this->authTimeout !== null || $this->absoluteAuthTimeout !== null)) {
        $expire = $this->authTimeout !== null ? $session->get($this->authTimeoutParam) : null;
        $expireAbsolute = $this->absoluteAuthTimeout !== null ? $session->get($this->absoluteAuthTimeoutParam) : null;
        if ($expire !== null && $expire < time() || $expireAbsolute !== null && $expireAbsolute < time()) {
            $this->logout(false);
        } elseif ($this->authTimeout !== null) {
            $session->set($this->authTimeoutParam, time() + $this->authTimeout);
        }
    }
    if ($this->enableAutoLogin) {
        if ($this->getIsGuest()) {
            $this->loginByCookie();
        } elseif ($this->autoRenewCookie) {
            $this->renewIdentityCookie();
        }
    }
}

            

                protected function renewIdentityCookie()
{
    $name = $this->identityCookie['name'];
    $value = Yii::$app->getRequest()->getCookies()->getValue($name);
    if ($value !== null) {
        $data = json_decode($value, true);
        if (is_array($data) && isset($data[2])) {
            $cookie = Yii::createObject(array_merge($this->identityCookie, [
                'class' => 'yii\web\Cookie',
                'value' => $value,
                'expire' => time() + (int) $data[2],
            ]));
            Yii::$app->getResponse()->getCookies()->add($cookie);
        }
    }
}

            

                protected function sendIdentityCookie($identity, $duration)
{
    $cookie = Yii::createObject(array_merge($this->identityCookie, [
        'class' => 'yii\web\Cookie',
        'value' => json_encode([
            $identity->getId(),
            $identity->getAuthKey(),
            $duration,
        ], JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE),
        'expire' => time() + $duration,
    ]));
    Yii::$app->getResponse()->getCookies()->add($cookie);
}

            

                public function setIdentity($identity)
{
    if ($identity instanceof IdentityInterface) {
        $this->_identity = $identity;
    } elseif ($identity === null) {
        $this->_identity = null;
    } else {
        throw new InvalidValueException('The identity object must implement IdentityInterface.');
    }
    $this->_access = [];
}

            

                public function setReturnUrl($url)
{
    Yii::$app->getSession()->set($this->returnUrlParam, $url);
}

            

                public function switchIdentity($identity, $duration = 0)
{
    $this->setIdentity($identity);
    if (!$this->enableSession) {
        return;
    }
    /* Ensure any existing identity cookies are removed. */
    if ($this->enableAutoLogin && ($this->autoRenewCookie || $identity === null)) {
        $this->removeIdentityCookie();
    }
    $session = Yii::$app->getSession();
    $session->regenerateID(true);
    $session->remove($this->idParam);
    $session->remove($this->authTimeoutParam);
    $session->remove($this->authKeyParam);
    if ($identity) {
        $session->set($this->idParam, $identity->getId());
        $session->set($this->authKeyParam, $identity->getAuthKey());
        if ($this->authTimeout !== null) {
            $session->set($this->authTimeoutParam, time() + $this->authTimeout);
        }
        if ($this->absoluteAuthTimeout !== null) {
            $session->set($this->absoluteAuthTimeoutParam, time() + $this->absoluteAuthTimeout);
        }
        if ($this->enableAutoLogin && $duration > 0) {
            $this->sendIdentityCookie($identity, $duration);
        }
    }
}

            

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