Class Yiisoft\Yii\AuthClient\Client\Google

                public function __construct(
    ClientInterface $httpClient,
    RequestFactoryInterface $requestFactory,
    StateStorageInterface $stateStorage,
    protected YiisoftFactory $factory,
    protected SessionInterface $session,
) {
    parent::__construct($httpClient, $requestFactory, $stateStorage, $this->factory);
}

            

                public function api($apiSubUrl, $method = 'GET', $data = [], $headers = []): array
{
    $request = $this->createApiRequest($method, $apiSubUrl);
    $request = RequestUtil::addHeaders($request, $headers);
    if (!empty($data)) {
        if (is_array($data)) {
            $request = RequestUtil::addParams($request, $data);
        } else {
            $request->getBody()->write($data);
        }
    }
    $request = $this->beforeApiRequestSend($request);
    $response = $this->sendRequest($request);
    if ($response->getStatusCode() !== 200) {
        throw new InvalidResponseException(
            $response,
            'Request failed with code: ' . $response->getStatusCode() . ', message: ' . (string)$response->getBody()
        );
    }
    return (array)Json::decode($response->getBody()->getContents());
}

            

                #[\Override]
public function applyAccessTokenToRequest(RequestInterface $request, OAuthToken $accessToken): RequestInterface
{
    return RequestUtil::addParams(
        $request,
        [
            'access_token' => $accessToken->getToken(),
        ]
    );
}

            

                protected function applyClientCredentialsToRequest(RequestInterface $request): RequestInterface
{
    return RequestUtil::addParams(
        $request,
        [
            'client_id' => $this->clientId,
            'client_secret' => $this->clientSecret,
        ]
    );
}

            

                public function beforeApiRequestSend(RequestInterface $request): RequestInterface
{
    $accessToken = $this->getAccessToken();
    if (!is_object($accessToken) || !$accessToken->getIsValid()) {
        throw new Exception('Invalid access token.');
    }
    return $this->applyAccessTokenToRequest($request, $accessToken);
}

            

                #[\Override]
public function buildAuthUrl(
    ServerRequestInterface $incomingRequest,
    array $params = []
): string {
    $defaultParams = [
        'client_id' => $this->clientId,
        'response_type' => 'code',
        'redirect_uri' => $this->getOauth2ReturnUrl(),
        'xoauth_displayname' => $incomingRequest->getAttribute(AuthAction::AUTH_NAME),
    ];
    if (!empty($this->getScope())) {
        $defaultParams['scope'] = $this->getScope();
    }
    if ($this->validateAuthState) {
        $authState = $this->generateAuthState();
        $this->setState('authState', $authState);
        $defaultParams['state'] = $authState;
    }
    return RequestUtil::composeUrl($this->authUrl, array_merge($defaultParams, $params));
}

            

                public function createApiRequest(string $method, string $uri): RequestInterface
{
    return $this->createRequest($method, $this->endpoint . $uri);
}

            

                public function createRequest(string $method, string $uri): RequestInterface
{
    return $this->requestFactory->createRequest($method, $uri);
}

            

                #[\Override]
protected function createToken(array $tokenConfig = []): OAuthToken
{
    $tokenConfig['tokenParamKey'] = 'access_token';
    return parent::createToken($tokenConfig);
}

            

                protected function defaultNormalizeUserAttributeMap(): array
{
    return [];
}

            

                #[\Override]
protected function defaultReturnUrl(ServerRequestInterface $request): string
{
    $params = $request->getQueryParams();
    unset($params['code'], $params['state']);
    return (string)$request->getUri()->withQuery(http_build_query($params, '', '&', PHP_QUERY_RFC3986));
}

            

                public function fetchAccessToken(
    ServerRequestInterface $incomingRequest,
    string $authCode,
    array $params = []
): OAuthToken {
    if ($this->validateAuthState) {
        /**
         * @psalm-suppress MixedAssignment
         */
        $authState = $this->getState('authState');
        $queryParams = $incomingRequest->getQueryParams();
        $bodyParams = $incomingRequest->getParsedBody();
        /**
         * @psalm-suppress MixedAssignment
         */
        $incomingState = $queryParams['state'] ?? ($bodyParams['state'] ?? null);
        if (is_string($incomingState)) {
            if (strcmp($incomingState, (string)$authState) !== 0) {
                throw new InvalidArgumentException('Invalid auth state parameter.');
            }
        }
        if ($incomingState === null) {
            throw new InvalidArgumentException('Invalid auth state parameter.');
        }
        if (empty($authState)) {
            throw new InvalidArgumentException('Invalid auth state parameter.');
        }
        $this->removeState('authState');
    }
    $defaultParams = [
        'code' => $authCode,
        'redirect_uri' => $this->getOauth2ReturnUrl(),
    ];
    $request = $this->createRequest('POST', $this->tokenUrl);
    $request = RequestUtil::addParams($request, array_merge($defaultParams, $params));
    $request = $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $contents = $response->getBody()->getContents();
    $output = $this->parse_str_clean($contents);
    $token = new OAuthToken();
    /**
     * @var string $key
     * @var string $value
     */
    foreach ($output as $key => $value) {
        $token->setParam($key, $value);
    }
    return $token;
}

            

                public function fetchAccessTokenWithCodeVerifier(
    ServerRequestInterface $incomingRequest,
    string $authCode,
    array $params = [],
): OAuthToken {
    if ($this->validateAuthState) {
        /**
         * @psalm-suppress MixedAssignment
         */
        $authState = $this->getState('authState');
        $queryParams = $incomingRequest->getQueryParams();
        $bodyParams = $incomingRequest->getParsedBody();
        /**
         * @psalm-suppress MixedAssignment
         */
        $incomingState = $queryParams['state'] ?? ($bodyParams['state'] ?? null);
        if (is_string($incomingState)) {
            if (strcmp($incomingState, (string)$authState) !== 0) {
                throw new InvalidArgumentException('Invalid auth state parameter.');
            }
        }
        if ($incomingState === null) {
            throw new InvalidArgumentException('Invalid auth state parameter.');
        }
        if (empty($authState)) {
            throw new InvalidArgumentException('Invalid auth state parameter.');
        }
        $this->removeState('authState');
    }
    $requestBody = [
        'code' => $authCode,
        'grant_type' => 'authorization_code',
        'client_id' => $this->clientId,
        'client_secret' => $this->clientSecret,
        'redirect_uri' => $params['redirect_uri'] ?? '',
        'code_verifier' => $params['code_verifier'] ?? '',
    ];
    $request = $this->requestFactory
        ->createRequest('POST', $this->tokenUrl)
        ->withHeader('Content-Type', 'application/x-www-form-urlencoded');
    $request->getBody()->write(http_build_query($requestBody));
    try {
        $response = $this->httpClient->sendRequest($request);
        $body = $response->getBody()->getContents();
        if (strlen($body) > 0) {
            $output = (array) json_decode($body, true);
        } else {
            $output = [];
        }
    } catch (\Throwable $e) {
        $output = [];
    }
    $token = new OAuthToken();
    /**
     * @var string $key
     * @var string $value
     */
    foreach ($output as $key => $value) {
        $token->setParam($key, $value);
    }
    return $token;
}

            

                protected function generateAuthState(): string
{
    $baseString = static::class . '-' . time();
    $sessionId = $this->session->getId();
    if (null !== $sessionId) {
        if ($this->session->isActive()) {
            $baseString .= '-' . $sessionId;
        }
    }
    return hash('sha256', uniqid($baseString, true));
}

            

                public function getAccessToken(): ?OAuthToken
{
    if (!is_object($this->accessToken)) {
        $this->accessToken = $this->restoreAccessToken();
    }
    return $this->accessToken;
}

            

                #[\Override]
public function getClientId(): string
{
    return $this->clientId;
}

            

                public function getClientSecret(): string
{
    return $this->clientSecret;
}

            

                public function getNormalizeUserAttributeMap(): array
{
    if (empty($this->normalizeUserAttributeMap)) {
        $this->normalizeUserAttributeMap = $this->defaultNormalizeUserAttributeMap();
    }
    return $this->normalizeUserAttributeMap;
}

            

                public function getOauth2ReturnUrl(): string
{
    return $this->returnUrl;
}

            

                public function getRequestFactory(): RequestFactoryInterface
{
    return $this->requestFactory;
}

            

                public function getReturnUrl(ServerRequestInterface $request): string
{
    if ($this->returnUrl === '') {
        $this->returnUrl = $this->defaultReturnUrl($request);
    }
    return $this->returnUrl;
}

            

                public function getScope(): string
{
    if ($this->scope === null) {
        return $this->getDefaultScope();
    }
    return $this->scope;
}

            

                public function getSessionAuthState(): mixed
{
    /**
     * @see src\AuthClient protected function getState('authState')
     */
    return $this->getState('authState');
}

            

                protected function getState(string $key): mixed
{
    return $this->stateStorage->get($this->getStateKeyPrefix() . $key);
}

            

                protected function getStateKeyPrefix(): string
{
    return static::class . '_' . $this->getName() . '_';
}

            

                public function getTokenUrl(): string
{
    return $this->tokenUrl;
}

            

                #[\Override]
public function getViewOptions(): array
{
    if (empty($this->viewOptions)) {
        $this->viewOptions = $this->defaultViewOptions();
    }
    return $this->viewOptions;
}

            

                public function getYiisoftFactory(): YiisoftFactory
{
    return $this->factory;
}

            

                #[\Override]
public function refreshAccessToken(OAuthToken $token): OAuthToken
{
    $params = [
        'grant_type' => 'refresh_token',
    ];
    $params = array_merge($token->getParams(), $params);
    $request = $this->createRequest('POST', $this->tokenUrl);
    $request = RequestUtil::addParams($request, $params);
    $request = $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $contents = $response->getBody()->getContents();
    $output = $this->parse_str_clean($contents);
    $token = new OAuthToken();
    /**
     * @var string $key
     * @var string $value
     */
    foreach ($output as $key => $value) {
        $token->setParam($key, $value);
    }
    return $token;
}

            

                protected function removeState(string $key): void
{
    $this->stateStorage->remove($this->getStateKeyPrefix() . $key);
}

            

                protected function restoreAccessToken(): ?OAuthToken
{
    /**
     * @psalm-suppress MixedAssignment $token
     */
    if (($token = $this->getState('token')) instanceof OAuthToken) {
        if ($token->getIsExpired() && $this->autoRefreshAccessToken) {
            return $this->refreshAccessToken($token);
        }
        return $token;
    }
    return null;
}

            

                protected function saveAccessToken(OAuthToken $token = null): self
{
    return $this->setState('token', $token);
}

            

                protected function sendRequest(RequestInterface $request): ResponseInterface
{
    return $this->httpClient->sendRequest($request);
}

            

                public function setAccessToken(array|OAuthToken $token): void
{
    if (is_array($token) && !empty($token)) {
        /**
         * @psalm-suppress MixedAssignment $newToken
         */
        $newToken = $this->createToken($token);
        /**
         * @psalm-suppress MixedAssignment $this->accessToken
         */
        $this->accessToken = $newToken;
        /**
         * @psalm-suppress MixedArgument $newToken
         */
        $this->saveAccessToken($newToken);
    }
    if ($token instanceof OAuthToken) {
        $this->accessToken = $token;
        $this->saveAccessToken($token);
    }
}

            

                public function setAuthUrl(string $authUrl): void
{
    $this->authUrl = $authUrl;
}

            

                public function setClientId(string $clientId): void
{
    $this->clientId = $clientId;
}

            

                public function setClientSecret(string $clientSecret): void
{
    $this->clientSecret = $clientSecret;
}

            

                public function setOauth2ReturnUrl(string $returnUrl): void
{
    $this->returnUrl = $returnUrl;
}

            

                public function setRequestFactory(RequestFactoryInterface $requestFactory): void
{
    $this->requestFactory = $requestFactory;
}

            

                public function setReturnUrl(string $returnUrl): void
{
    $this->returnUrl = $returnUrl;
}

            

                protected function setState(string $key, $value): self
{
    $this->stateStorage->set($this->getStateKeyPrefix() . $key, $value);
    return $this;
}

            

                public function setTokenUrl(string $tokenUrl): void
{
    $this->tokenUrl = $tokenUrl;
}

            

                public function setYiisoftFactory(YiisoftFactory $factory): void
{
    $this->factory = $factory;
}

            

                public function withValidateAuthState(): self
{
    $new = clone $this;
    $new->validateAuthState = true;
    return $new;
}

            

                public function withoutValidateAuthState(): self
{
    $new = clone $this;
    $new->validateAuthState = false;
    return $new;
}