Abstract Class Yiisoft\Yii\AuthClient\OAuth2

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

            

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

            

                protected function applyClientCredentialsToRequest(RequestInterface $request): RequestInterface
{
    $request->getBody()->write('&' . http_build_query(
        [
            'client_id' => $this->clientId,
            'client_secret' => $this->clientSecret,
        ],
        arg_separator: '&',
        encoding_type: PHP_QUERY_RFC3986,
    ));
    return $request;
}

            

                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, $this->authParams, $params));
}

            

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

            

                protected function createTokenRequest(array $params): RequestInterface
{
    $request = $this->createRequest('POST', $this->tokenUrl)
        ->withHeader('Content-Type', 'application/x-www-form-urlencoded');
    $request->getBody()->write(http_build_query($params, arg_separator: '&', encoding_type: PHP_QUERY_RFC3986));
    return $request;
}

            

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

            

                public function fetchAccessToken(
    ServerRequestInterface $incomingRequest,
    string $authCode,
    array $params = [],
): OAuthToken {
    if ($this->validateAuthState) {
        /**
         * @var string|null $authState 'authState' is only ever written by
         * {@see buildAuthUrl()} with the string returned from {@see generateAuthState()}.
         */
        $authState = $this->getState('authState');
        $queryParams = $incomingRequest->getQueryParams();
        $bodyParams = $incomingRequest->getParsedBody();
        /**
         * @psalm-suppress MixedAssignment
         */
        $incomingState = $queryParams['state'] ?? ($bodyParams['state'] ?? null);
        if (
            !is_string($incomingState)
            || empty($authState)
            || strcmp($incomingState, $authState) !== 0
        ) {
            throw new InvalidArgumentException('Invalid auth state parameter.');
        }
        $this->removeState('authState');
    }
    $defaultParams = [
        'grant_type' => 'authorization_code',
        'code' => $authCode,
        'redirect_uri' => $this->getOauth2ReturnUrl(),
    ];
    $request = $this->createTokenRequest(array_merge($defaultParams, $params));
    $request = $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $contents = $response->getBody()->getContents();
    $output = $this->parseTokenResponse($contents);
    $token = $this->createToken(['params' => $output]);
    $this->setAccessToken($token);
    return $token;
}

            

                public function fetchAccessTokenWithCodeVerifier(
    ServerRequestInterface $incomingRequest,
    string $authCode,
    array $params = [],
): OAuthToken {
    if ($this->validateAuthState) {
        /**
         * @var string|null $authState 'authState' is only ever written by
         * {@see buildAuthUrl()} with the string returned from {@see generateAuthState()}.
         */
        $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(Header::CONTENT_TYPE, 'application/x-www-form-urlencoded');
    $request->getBody()->write(
        http_build_query($requestBody, arg_separator: '&', encoding_type: PHP_QUERY_RFC3986),
    );
    try {
        $response = $this->httpClient->sendRequest($request);
        $body = $response->getBody()->getContents();
        $output = (array) Json::decode($body);
    } catch (Throwable) {
        $output = [];
    }
    $token = $this->createToken(['params' => $output]);
    $this->setAccessToken($token);
    return $token;
}

            

                protected function fetchCurrentUserJsonArray(
    OAuthToken $token,
    string $url,
    array $headers = [],
    string $authScheme = 'Bearer',
): array {
    $tokenString = (string) $token->getParam('access_token');
    if ($tokenString === '') {
        return [];
    }
    $request = RequestUtil::addHeaders(
        $this->createRequest('GET', $url),
        array_merge(['Authorization' => $authScheme . ' ' . $tokenString], $headers),
    );
    if ($request->getHeaderLine('User-Agent') === '') {
        $request = $request->withHeader('User-Agent', 'yiisoft/yii-auth-client');
    }
    try {
        $body = $this->sendRequest($request)->getBody()->getContents();
    } catch (Throwable) {
        return [];
    }
    return $body === '' ? [] : (array) Json::decode($body);
}

            

                protected function generateAuthState(): string
{
    return hash('sha256', uniqid($this->generateAuthStateBaseString(), true));
}

            

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

            

                public function getAuthParams(): array
{
    return $this->authParams;
}

            

                public function getClientId(): string
{
    return $this->clientId;
}

            

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

            

                public function getCurrentUserJsonArray(OAuthToken $oauthToken): array
{
    return $this->fetchCurrentUserJsonArray($oauthToken, $this->endpoint);
}

            

                public function getLogo(): ?string
{
    return $this->logo;
}

            

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

            

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

            

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

            

                public function refreshAccessToken(OAuthToken $token): OAuthToken
{
    $params = [
        'grant_type' => 'refresh_token',
    ];
    $params = array_merge($token->getParams(), $params);
    $request = $this->createTokenRequest($params);
    $request = $this->applyClientCredentialsToRequest($request);
    $response = $this->sendRequest($request);
    $contents = $response->getBody()->getContents();
    $output = $this->parseTokenResponse($contents);
    return $this->createToken(['params' => $output]);
}

            

                public function setAuthParams(array $authParams): void
{
    $this->authParams = $authParams;
}

            

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

            

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

            

                public function setEnvironment(string $devOrProd): void
{
    $this->environment = $devOrProd;
}

            

                public function setLogo(?string $logo): void
{
    $this->logo = $logo;
}

            

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

            

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

            

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

            

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