Class yii\authclient\clients\Google

                public function api($apiSubUrl, $method = 'GET', $data = [], $headers = [])
{
    $request = $this->createApiRequest()
        ->setMethod($method)
        ->setUrl($apiSubUrl)
        ->addHeaders($headers);
    if (!empty($data)) {
        if (is_array($data)) {
            $request->setData($data);
        } else {
            $request->setContent($data);
        }
    }
    return $this->sendRequest($request);
}

            

                public function applyAccessTokenToRequest($request, $accessToken)
{
    switch($this->accessTokenLocation) {
        case self::ACCESS_TOKEN_LOCATION_BODY:
            $data = $request->getData();
            $data['access_token'] = $accessToken->getToken();
            $request->setData($data);
            break;
        case self::ACCESS_TOKEN_LOCATION_HEADER:
            $request->getHeaders()->set('Authorization', 'Bearer ' . $accessToken->getToken());
            break;
        default:
            throw new InvalidConfigException('Unknown access token location: ' . $this->accessTokenLocation);
    }
}

            

                protected function applyClientCredentialsToRequest($request)
{
    $request->addData([
        'client_id' => $this->clientId,
        'client_secret' => $this->clientSecret,
    ]);
}

            

                public function authenticateClient($params = [])
{
    $defaultParams = [
        'grant_type' => 'client_credentials',
    ];
    if (!empty($this->scope)) {
        $defaultParams['scope'] = $this->scope;
    }
    $request = $this->createRequest()
        ->setMethod('POST')
        ->setUrl($this->tokenUrl)
        ->setData(array_merge($defaultParams, $params));
    $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $token = $this->createToken(['params' => $response]);
    $this->setAccessToken($token);
    return $token;
}

            

                public function authenticateUser($username, $password, $params = [])
{
    $defaultParams = [
        'grant_type' => 'password',
        'username' => $username,
        'password' => $password,
    ];
    if (!empty($this->scope)) {
        $defaultParams['scope'] = $this->scope;
    }
    $request = $this->createRequest()
        ->setMethod('POST')
        ->setUrl($this->tokenUrl)
        ->setData(array_merge($defaultParams, $params));
    $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $token = $this->createToken(['params' => $response]);
    $this->setAccessToken($token);
    return $token;
}

            

                public function authenticateUserJwt($username, $signature = null, $options = [], $params = [])
{
    if (empty($signature)) {
        $signatureMethod = $this->getSignatureMethod();
    } elseif (is_object($signature)) {
        $signatureMethod = $signature;
    } else {
        $signatureMethod = $this->createSignatureMethod($signature);
    }
    $header = isset($options['header']) ? $options['header'] : [];
    $payload = isset($options['payload']) ? $options['payload'] : [];
    $header = array_merge([
        'typ' => 'JWT'
    ], $header);
    if (!isset($header['alg'])) {
        $signatureName = $signatureMethod->getName();
        if (preg_match('/^([a-z])[a-z]*\-([a-z])[a-z]*([0-9]+)$/is', $signatureName, $matches)) {
            // convert 'RSA-SHA256' to 'RS256' :
            $signatureName = $matches[1] . $matches[2] . $matches[3];
        }
        $header['alg'] = $signatureName;
    }
    $payload = array_merge([
        'iss' => $username,
        'scope' => $this->scope,
        'aud' => $this->tokenUrl,
        'iat' => time(),
    ], $payload);
    if (!isset($payload['exp'])) {
        $payload['exp'] = $payload['iat'] + 3600;
    }
    $signatureBaseString = base64_encode(Json::encode($header)) . '.' . base64_encode(Json::encode($payload));
    $signatureKey = isset($options['signatureKey']) ? $options['signatureKey'] : $this->clientSecret;
    $signature = $signatureMethod->generateSignature($signatureBaseString, $signatureKey);
    $assertion = $signatureBaseString . '.' . $signature;
    $request = $this->createRequest()
        ->setMethod('POST')
        ->setUrl($this->tokenUrl)
        ->setData(array_merge([
            'grant_type' => 'urn:ietf:params:oauth:grant-type:jwt-bearer',
            'assertion' => $assertion,
        ], $params));
    $response = $this->sendRequest($request);
    $token = $this->createToken(['params' => $response]);
    $this->setAccessToken($token);
    return $token;
}

            

                public function beforeApiRequestSend($event)
{
    $accessToken = $this->getAccessToken();
    if (!is_object($accessToken) || (!$accessToken->getIsValid() && !$this->autoRefreshAccessToken)) {
        throw new Exception('Invalid access token.');
    } elseif ($accessToken->getIsExpired() && $this->autoRefreshAccessToken) {
        $accessToken = $this->refreshAccessToken($accessToken);
    }
    $this->applyAccessTokenToRequest($event->request, $accessToken);
}

            

                public function buildAuthUrl(array $params = [])
{
    $defaultParams = [
        'client_id' => $this->clientId,
        'response_type' => 'code',
        'redirect_uri' => $this->getReturnUrl(),
        'xoauth_displayname' => Yii::$app->name,
    ];
    if (!empty($this->scope)) {
        $defaultParams['scope'] = $this->scope;
    }
    if ($this->validateAuthState) {
        $authState = $this->generateAuthState();
        $this->setState('authState', $authState);
        $defaultParams['state'] = $authState;
    }
    if ($this->enablePkce) {
        $codeVerifier = bin2hex(Yii::$app->security->generateRandomKey(64));
        $this->setState('authCodeVerifier', $codeVerifier);
        $defaultParams['code_challenge'] = trim(strtr(base64_encode(hash('sha256', $codeVerifier, true)), '+/', '-_'), '=');
        $defaultParams['code_challenge_method'] = 'S256';
    }
    return $this->composeUrl($this->authUrl, array_merge($defaultParams, $params));
}

            

                protected function composeUrl($url, array $params = [])
{
    if (!empty($params)) {
        if (strpos($url, '?') === false) {
            $url .= '?';
        } else {
            $url .= '&';
        }
        $url .= http_build_query($params, '', '&', PHP_QUERY_RFC3986);
    }
    return $url;
}

            

                public function createApiRequest()
{
    $request = $this->createRequest();
    $request->on(Request::EVENT_BEFORE_SEND, [$this, 'beforeApiRequestSend']);
    return $request;
}

            

                protected function createHttpClient($reference)
{
    $httpClient = parent::createHttpClient($reference);
    $httpClient->baseUrl = $this->apiBaseUrl;
    return $httpClient;
}

            

                public function createRequest()
{
    return $this->getHttpClient()
        ->createRequest()
        ->addOptions($this->defaultRequestOptions())
        ->addOptions($this->getRequestOptions());
}

            

                protected function createSignatureMethod(array $signatureMethodConfig)
{
    if (!array_key_exists('class', $signatureMethodConfig)) {
        $signatureMethodConfig['class'] = signature\HmacSha1::className();
    }
    return Yii::createObject($signatureMethodConfig);
}

            

                protected function createToken(array $tokenConfig = [])
{
    $defaultTokenConfig = ['tokenParamKey' => 'access_token'];
    $tokenConfig = array_merge($defaultTokenConfig, $tokenConfig);
    return parent::createToken($tokenConfig);
}

            

                protected function defaultNormalizeUserAttributeMap()
{
    return [];
}

            

                protected function defaultRequestOptions()
{
    return [
        'userAgent' => Inflector::slug(Yii::$app->name) . ' OAuth ' . $this->version . ' Client',
        'timeout' => 30,
    ];
}

            

                protected function defaultReturnUrl()
{
    $params = Yii::$app->getRequest()->getQueryParams();
    $params = array_intersect_key($params, array_flip($this->parametersToKeepInReturnUrl));
    $params[0] = Yii::$app->controller->getRoute();
    return Yii::$app->getUrlManager()->createAbsoluteUrl($params);
}

            

                protected function defaultViewOptions()
{
    return [];
}

            

                public function fetchAccessToken($authCode, array $params = [])
{
    if ($this->validateAuthState) {
        $authState = $this->getState('authState');
        $incomingRequest = Yii::$app->getRequest();
        $incomingState = $incomingRequest->get('state', $incomingRequest->post('state'));
        if (
            !isset($incomingState)
            || empty($authState)
            || !Yii::$app->getSecurity()->compareString($incomingState, $authState)
        ) {
            throw new HttpException(400, 'Invalid auth state parameter.');
        }
        $this->removeState('authState');
    }
    $defaultParams = [
        'code' => $authCode,
        'grant_type' => 'authorization_code',
        'redirect_uri' => $this->getReturnUrl(),
    ];
    if ($this->enablePkce) {
        $authCodeVerifier = $this->getState('authCodeVerifier');
        if (empty($authCodeVerifier)) {
            // Prevent PKCE Downgrade Attack
            // https://datatracker.ietf.org/doc/html/draft-ietf-oauth-security-topics#name-pkce-downgrade-attack
            throw new HttpException(409, 'Invalid auth code verifier.');
        }
        $defaultParams['code_verifier'] = $authCodeVerifier;
        $this->removeState('authCodeVerifier');
    }
    $request = $this->createRequest()
        ->setMethod('POST')
        ->setUrl($this->tokenUrl)
        ->setData(array_merge($defaultParams, $params));
     // Azure AD will complain if there is no `Origin` header.
    if ($this->enablePkce) {
        $request->addHeaders(['Origin' => Url::to('/')]);
    }
    $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $token = $this->createToken(['params' => $response]);
    $this->setAccessToken($token);
    return $token;
}

            

                protected function generateAuthState()
{
    $baseString = get_class($this) . '-' . time();
    if (Yii::$app->has('session')) {
        $baseString .= '-' . Yii::$app->session->getId();
    }
    return hash('sha256', uniqid($baseString, true));
}

            

                public function getAccessToken()
{
    if (!is_object($this->_accessToken)) {
        $this->_accessToken = $this->restoreAccessToken();
    }
    return $this->_accessToken;
}

            

                public function getHttpClient()
{
    if (!is_object($this->_httpClient)) {
        $this->_httpClient = $this->createHttpClient($this->_httpClient);
    }
    return $this->_httpClient;
}

            

                public function getId()
{
    if (empty($this->_id)) {
        $this->_id = $this->getName();
    }
    return $this->_id;
}

            

                public function getName()
{
    if ($this->_name === null) {
        $this->_name = $this->defaultName();
    }
    return $this->_name;
}

            

                public function getNormalizeUserAttributeMap()
{
    if ($this->_normalizeUserAttributeMap === null) {
        $this->_normalizeUserAttributeMap = $this->defaultNormalizeUserAttributeMap();
    }
    return $this->_normalizeUserAttributeMap;
}

            

                public function getRequestOptions()
{
    return $this->_requestOptions;
}

            

                public function getReturnUrl()
{
    if ($this->_returnUrl === null) {
        $this->_returnUrl = $this->defaultReturnUrl();
    }
    return $this->_returnUrl;
}

            

                public function getSignatureMethod()
{
    if (!is_object($this->_signatureMethod)) {
        $this->_signatureMethod = $this->createSignatureMethod($this->_signatureMethod);
    }
    return $this->_signatureMethod;
}

            

                protected function getState($key)
{
    return $this->getStateStorage()->get($this->getStateKeyPrefix() . $key);
}

            

                protected function getStateKeyPrefix()
{
    return get_class($this) . '_' . $this->getId() . '_';
}

            

                public function getStateStorage()
{
    if (!is_object($this->_stateStorage)) {
        $this->_stateStorage = Yii::createObject($this->_stateStorage);
    }
    return $this->_stateStorage;
}

            

                public function getTitle()
{
    if ($this->_title === null) {
        $this->_title = $this->defaultTitle();
    }
    return $this->_title;
}

            

                public function getUserAttributes()
{
    if ($this->_userAttributes === null) {
        $this->_userAttributes = $this->normalizeUserAttributes($this->initUserAttributes());
    }
    return $this->_userAttributes;
}

            

                public function getViewOptions()
{
    if ($this->_viewOptions === null) {
        $this->_viewOptions = $this->defaultViewOptions();
    }
    return $this->_viewOptions;
}

            

                protected function normalizeUserAttributes($attributes)
{
    foreach ($this->getNormalizeUserAttributeMap() as $normalizedName => $actualName) {
        if (is_scalar($actualName)) {
            if (array_key_exists($actualName, $attributes)) {
                $attributes[$normalizedName] = $attributes[$actualName];
            }
        } else {
            if (is_callable($actualName)) {
                $attributes[$normalizedName] = call_user_func($actualName, $attributes);
            } elseif (is_array($actualName)) {
                $haystack = $attributes;
                $searchKeys = $actualName;
                $isFound = true;
                while (($key = array_shift($searchKeys)) !== null) {
                    if (is_array($haystack) && array_key_exists($key, $haystack)) {
                        $haystack = $haystack[$key];
                    } else {
                        $isFound = false;
                        break;
                    }
                }
                if ($isFound) {
                    $attributes[$normalizedName] = $haystack;
                }
            } else {
                throw new InvalidConfigException('Invalid actual name "' . gettype($actualName) . '" specified at "' . get_class($this) . '::normalizeUserAttributeMap"');
            }
        }
    }
    return $attributes;
}

            

                public function refreshAccessToken(OAuthToken $token)
{
    $params = [
        'grant_type' => 'refresh_token'
    ];
    $params = array_merge($token->getParams(), $params);
    $request = $this->createRequest()
        ->setMethod('POST')
        ->setUrl($this->tokenUrl)
        ->setData($params);
    $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $token = $this->createToken(['params' => $response]);
    $this->setAccessToken($token);
    return $token;
}

            

                protected function removeState($key)
{
    return $this->getStateStorage()->remove($this->getStateKeyPrefix() . $key);
}

            

                protected function restoreAccessToken()
{
    $token = $this->getState('token');
    if (is_object($token)) {
        /* @var $token OAuthToken */
        if ($token->getIsExpired() && $this->autoRefreshAccessToken) {
            $token = $this->refreshAccessToken($token);
        }
    }
    return $token;
}

            

                protected function saveAccessToken($token)
{
    return $this->setState('token', $token);
}

            

                protected function sendRequest($request)
{
    $response = $request->send();
    if (!$response->getIsOk()) {
        $statusCode = (int)$response->getStatusCode();
        if ($statusCode >= 400 && $statusCode < 500) {
            $exceptionClass = 'yii\\authclient\\ClientErrorResponseException';
        } else {
            $exceptionClass = 'yii\\authclient\\InvalidResponseException';
        }
        throw new $exceptionClass(
            $response,
            'Request failed with code: ' . $statusCode . ', message: ' . $response->getContent(),
            $statusCode
        );
    }
    if (stripos($response->headers->get('content-type', ''), 'application/jwt') !== false) {
        return $response->getContent();
    } else {
        return $response->getData();
    }
}

            

                public function setAccessToken($token)
{
    if (!is_object($token) && $token !== null) {
        $token = $this->createToken($token);
    }
    $this->_accessToken = $token;
    $this->saveAccessToken($token);
}

            

                public function setHttpClient($httpClient)
{
    if (is_object($httpClient)) {
        $httpClient = clone $httpClient;
        $httpClient->baseUrl = $this->apiBaseUrl;
    }
    parent::setHttpClient($httpClient);
}

            

                public function setId($id)
{
    $this->_id = $id;
}

            

                public function setName($name)
{
    $this->_name = $name;
}

            

                public function setNormalizeUserAttributeMap($normalizeUserAttributeMap)
{
    $this->_normalizeUserAttributeMap = $normalizeUserAttributeMap;
}

            

                public function setRequestOptions(array $options)
{
    $this->_requestOptions = $options;
}

            

                public function setReturnUrl($returnUrl)
{
    $this->_returnUrl = $returnUrl;
}

            

                public function setSignatureMethod($signatureMethod)
{
    if (!is_object($signatureMethod) && !is_array($signatureMethod)) {
        throw new InvalidArgumentException('"' . get_class($this) . '::signatureMethod" should be instance of "\yii\autclient\signature\BaseMethod" or its array configuration. "' . gettype($signatureMethod) . '" has been given.');
    }
    $this->_signatureMethod = $signatureMethod;
}

            

                protected function setState($key, $value)
{
    $this->getStateStorage()->set($this->getStateKeyPrefix() . $key, $value);
    return $this;
}

            

                public function setStateStorage($stateStorage)
{
    $this->_stateStorage = $stateStorage;
}

            

                public function setTitle($title)
{
    $this->_title = $title;
}

            

                public function setUserAttributes($userAttributes)
{
    $this->_userAttributes = $this->normalizeUserAttributes($userAttributes);
}

            

                public function setViewOptions($viewOptions)
{
    $this->_viewOptions = $viewOptions;
}