LucaDegasperi\OAuth2Server\Grant\RefreshTokenGrant::completeFlow()

Complexity

Conditions	14
Paths	16

Size

Total Lines	130
Code Lines	64

Duplication

Lines	4
Ratio	3.08 %

Importance

Changes

0

<?php
    public function completeFlow()
    {
        // Get clientid from request
        $clientId = $this->server->getRequest()->request->get('client_id', $this->server->getRequest()->getUser());
        if (is_null($clientId)) {
            throw new Exception\InvalidRequestException('client_id');
        }

        // Get client secret from request
        $clientSecret = $this->server->getRequest()->request->get('client_secret',
            $this->server->getRequest()->getPassword());
        if ($this->shouldRequireClientSecret() && is_null($clientSecret)) {
            throw new Exception\InvalidRequestException('client_secret');
        }

        // Validate client ID and client secret and return the client.
        $client = $this->server->getClientStorage()->get(
            $clientId,
            $clientSecret,
            null,
            $this->getIdentifier()
        );

        if (($client instanceof ClientEntity) === false) {

This code seems to be duplicated across your project.

            $this->server->getEventEmitter()->emit(new Event\ClientAuthenticationFailedEvent($this->server->getRequest()));

This line exceeds maximum limit of 120 characters; contains 123 characters

            throw new Exception\InvalidClientException();
        }

        // Gets the active refresh token for the current session.
        $oldRefreshTokenParam = $this->server->getRequest()->request->get('refresh_token', null);
        if ($oldRefreshTokenParam === null) {
            throw new Exception\InvalidRequestException('refresh_token');
        }

        // Validate refresh token
        $oldRefreshToken = $this->server->getRefreshTokenStorage()->get($oldRefreshTokenParam);

        if (($oldRefreshToken instanceof RefreshTokenEntity) === false) {
            throw new Exception\InvalidRefreshException();
        }
        
        if ($oldRefreshToken->getExpireTime() < time()) {
            throw new Exception\InvalidRefreshException();
        }
        
        // Using the expiration time of the current refresh token calculates the 
        // reminding time for the new access token.
        $expireTime = $oldRefreshToken->getExpireTime();
        $remindingTime = $expireTime - time();

        // Ensure the old refresh token hasn't expired
        if ($oldRefreshToken->isExpired() === true) {
            throw new Exception\InvalidRefreshException();
        }

        // It gets the previous access token.
        $oldAccessToken = $oldRefreshToken->getAccessToken();

        // Get the scopes for the original session
        $session = $oldAccessToken->getSession();
        $scopes = $this->formatScopes($session->getScopes());

        // Get and validate any requested scopes
        $requestedScopesString = $this->server->getRequest()->request->get('scope', '');
        $requestedScopes = $this->validateScopes($requestedScopesString, $client);

        // If no new scopes are requested then give the access token the original session scopes
        if (count($requestedScopes) === 0) {
            $newScopes = $scopes;
        } else {
            // The OAuth spec says that a refreshed access token can have the original scopes or fewer so ensure
            //  the request doesn't include any new scopes
            foreach ($requestedScopes as $requestedScope) {
                if (!isset($scopes[$requestedScope->getId()])) {
                    throw new Exception\InvalidScopeException($requestedScope->getId());
                }
            }

            $newScopes = $requestedScopes;
        }

        // Generate a new access token and assign it to the right sessions
        $newAccessToken = new AccessTokenEntity($this->server);
        $newAccessToken->setId(SecureKey::generate());
        $newAccessToken->setExpireTime($expireTime);
        $newAccessToken->setSession($session);

        foreach ($newScopes as $newScope) {
            $newAccessToken->associateScope($newScope);
        }

        // Save the new access token that is going to be returned to the user.
        $newAccessToken->save();

        // We need to assign the new access token to the current user session.
        // The exipiration time should be reminding time on the current refresh token
        // in that way event if you get a new access token a 10 seconds before the 
        // refresh token expires the new access token will have only 10 seconds left.
        $this->server->getTokenType()->setSession($session);
        $this->server->getTokenType()->setParam('access_token', $newAccessToken->getId());
        $this->server->getTokenType()->setParam('expires_in', $remindingTime);

        // Now we need to change the refresh token before exipiring the old access token,
        // otherwise it will delete the refresh token because of the delete cascade constraint 
        if ($this->shouldRotateRefreshTokens()) {
            // Expire the old refresh token
            $oldRefreshToken->expire();

            // Generate a new refresh token
            $newRefreshToken = new RefreshTokenEntity($this->server);
            $newRefreshToken->setId(SecureKey::generate());
            $newRefreshToken->setExpireTime($expireTime);
            $newRefreshToken->setAccessToken($newAccessToken);
            $newRefreshToken->save();

            $this->server->getTokenType()->setParam('refresh_token', $newRefreshToken->getId());
        } else {
            // Here you will change the refresh token and removes the reference to the old access token
            // and set the reference to the new access token.
            $oldRefreshToken->setAccessToken($newAccessToken);
            $oldRefreshToken->save();
            $this->server->getTokenType()->setParam('refresh_token', $oldRefreshToken->getId());
        }

        // Now its save to expire the old token, in that way it won't be available anymore.
        $oldAccessToken->expire();
        
        // Return a response with the tokens details
        return $this->server->getTokenType()->generateResponse();
    }
}