OAuth2OLD\Endpoints\TokenEndpoint

Complexity

Total Complexity

14

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
C	handle()	0	78	14

<?php
/**
 * Created by PhpStorm.
 * User: Alexandre
 * Date: 07/01/2018
 * Time: 13:57
 */

namespace OAuth2OLD\Endpoints;


use OAuth2OLD\EndpointMessages\Token\AccessTokenRequest;
use OAuth2OLD\EndpointMessages\Token\ErrorResponse;
use OAuth2OLD\Exceptions\OAuthException;
use OAuth2OLD\Storages\ClientStorageInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class TokenEndpoint extends AbstractEndpoint
{
    /**
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     * @throws \Exception
     */
    function handle(ServerRequestInterface $request): ResponseInterface

It is generally recommended to explicitly declare the visibility for methods.

    {
        if (!isset($request->getParsedBody()['grant_type'])) {
            return new ErrorResponse('invalid_request', 'Missing a required parameter : grant_type',
                'https://tools.ietf.org/html/rfc6749#section-5.2');
        }

//        $accessTokenRequest = AccessTokenRequest::createFromServerRequest($request);

50% of this comment could be valid code. Did you maybe forget this after debugging?

        $grantTypeName = $request->getParsedBody()['grant_type'];
        $grantType = $this->server->getGrantTypeRepository()->getGrantType($grantTypeName);
        if (!$grantType) {
            return new ErrorResponse('unsupported_grant_type',
                'Unsupported grant type : ' . $grantTypeName,
                'https://tools.ietf.org/html/rfc6749#section-5.2');
        }

        /**
         * @var ClientStorageInterface $clientStorage
         */
        $clientStorage = $this->server->getStorageRepository()->getStorage('client');
        $guard = $this->server->getGuard();
        $client = null;

        try {
            if ($guard->authenticate($request)) {
                $client = $guard->getClient();
            }
        } catch (OAuthException $e) {
            if ($e->getError() == 'invalid_client' && $request->hasHeader('Authorization')) {
                return new ErrorResponse($e->getError(),
                    'Client authentication failed : ' . $e->getMessage(),
                    $e->getErrorUri(), 401, [
                        'WWW-Authenticate' => 'Basic'
                    ]);
            } else {
                return new ErrorResponse($e->getError(),
                    'Client authentication failed : ' . $e->getMessage(),
                    $e->getErrorUri(), 401);
            }
        }

        if(!$client) {
            if (!isset($request->getParsedBody()['client_id'])) {
                return new ErrorResponse('invalid_request',
                    'Client authentication not included, missing a parameter : client_id : ',
                    'https://tools.ietf.org/html/rfc6749#section-5.2');
            }

            $client = $clientStorage->get($request->getParsedBody()['client_id']);
            if (!$client) {
                return new ErrorResponse('invalid_client',
                    'Parameter client_id invalid',
                    'https://tools.ietf.org/html/rfc6749#section-5.2');
            }

            if ($client->hasCredentials()) {
                return new ErrorResponse('invalid_client',
                    'Client authentication failed : ' . $guard->getError(),
                    'https://tools.ietf.org/html/rfc6749#section-5.2', 401, [
                        'WWW-Authenticate' => 'Basic'
                    ]);
            }
        }

        if (is_array($client->getSupportedGrantTypes()) && !in_array($grantType->getUri(), $client->getSupportedGrantTypes())) {
            return new ErrorResponse('unauthorized_client',
                'Unauthorized grant type : ' . $grantType->getUri(),
                'https://tools.ietf.org/html/rfc6749#section-5.2');
        }

        try {
            return $grantType->grant($request, $client);
        }
        catch (OAuthException $e) {
            return new ErrorResponse($e->getError(),
                $e->getErrorDescription(),
                $e->getErrorUri());
        }
    }
}