Final Class Yiisoft\Yii\AuthClient\Client\TikTok

                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: ' . $response->getBody(),
        );
    }
    return (array) Json::decode($response->getBody()->getContents());
}

            

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

            

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

            

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

            

                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 defaultNormalizeUserAttributeMap(): array
{
    return [];
}

            

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

            

                protected function defaultViewOptions(): array
{
    return [
        'popupWidth' => 860,
        'popupHeight' => 480,
    ];
}

            

                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 getAccessToken(): ?OAuthToken
{
    if (!is_object($this->accessToken)) {
        $this->accessToken = $this->restoreAccessToken();
    }
    return $this->accessToken;
}

            

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

            

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

            

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

            

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

            

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

            

                public function getUserAttributes(): array
{
    $attributes = $this->initUserAttributes();
    $normalizeMap = $this->getNormalizeUserAttributeMap();
    return array_merge($attributes, $this->normalizeUserAttributes($attributes, $normalizeMap));
}

            

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

            

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

            

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

            

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

            

                protected function restoreAccessToken(): ?OAuthToken
{
    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)) {
        $newToken = $this->createToken($token);
        $this->accessToken = $newToken;
        $this->saveAccessToken($newToken);
    }
    if ($token instanceof OAuthToken) {
        $this->accessToken = $token;
        $this->saveAccessToken($token);
    }
}

            

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

            

                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 setEnvironment(string $devOrProd): void
{
    $this->environment = $devOrProd;
}

            

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

            

                public function setName(string $name): void
{
    $this->name = $name;
}

            

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

            

                public function setScope(string $scope): void
{
    $this->scope = $scope;
}

            

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

            

                public function setTitle(string $title): void
{
    $this->title = $title;
}

            

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