AuthorizationCodeFlow::handleAccessTokenRequest() - Code Metrics - Inspection of "openid init implicit flow" - php-guard/oauth-server - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cd0cec...4b3abd )

by Alexandre

created 2018-03-14 22:12 UTC

AuthorizationCodeFlow::handleAccessTokenRequest() B

↳ Parent: AuthorizationCodeFlow

Complexity

Conditions	8
Paths	7

Size

Total Lines	54
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
eloc	26
nc	7
nop	2
dl	0
loc	54
rs	7.4119
c	0
b	0
f	0

How to fix Long Method

<?php
/**
 * Created by PhpStorm.
 * User: Alexandre
 * Date: 18/02/2018
 * Time: 18:08
 */

namespace OAuth2\Flows;


use OAuth2\Endpoints\AuthorizationEndpoint;
use OAuth2\Endpoints\TokenEndpoint;
use OAuth2\Exceptions\OAuthException;
use OAuth2\GrantTypes\AbstractGrantType;
use OAuth2\Storages\AccessTokenStorageInterface;
use OAuth2\Storages\AuthorizationCodeStorageInterface;
use OAuth2\Storages\RefreshTokenStorageInterface;

class AuthorizationCodeFlow extends AbstractGrantType implements FlowInterface
{
    protected $authorizationCodeStorage;

    public function __construct(AuthorizationCodeStorageInterface $authorizationCodeStorage,
                                AccessTokenStorageInterface $accessTokenStorage,
                                RefreshTokenStorageInterface $refreshTokenStorage)
    {
        parent::__construct($accessTokenStorage, $refreshTokenStorage);
        $this->authorizationCodeStorage = $authorizationCodeStorage;
    }

    public function getResponseTypes(): array
    {
        return ['code'];
    }

    public function verifyAuthorizationRequest(AuthorizationEndpoint $authorizationEndpoint, array $requestData)
    {
    }

    public function handleAuthorizationRequest(AuthorizationEndpoint $authorizationEndpoint, array $requestData): array
    {
        $authorizationCode = $this->authorizationCodeStorage->create(
            implode(' ', $authorizationEndpoint->getScopes()),
            $authorizationEndpoint->getClient()->getIdentifier(),
            $authorizationEndpoint->getResourceOwner()->getIdentifier(),
            $requestData['scope'] ?? null,
            $requestData['redirect_uri'] ?? null
        );
        $this->authorizationCodeStorage->save($authorizationCode);
        return ['code' => $authorizationCode->getCode()];
    }

    public function getDefaultResponseMode(): string
    {
        return 'query';
    }

    public function getUnsupportedResponseModes(): array
    {
        return [];
    }

    public function getGrantTypes(): array
    {
        return ['authorization_code'];
    }

    /**
     * @param TokenEndpoint $tokenEndpoint
     * @param array         $requestData
     * @return array
     * @throws OAuthException
     */
    public function handleAccessTokenRequest(TokenEndpoint $tokenEndpoint, array $requestData): array
    {
        if (empty($requestData['code'])) {
            throw new OAuthException('invalid_request',
                'The request is missing the required parameter code.',
                'https://tools.ietf.org/html/rfc7636#section-4.4');
        }
        $code = $requestData['code'];

        $authorizationCode = $this->authorizationCodeStorage->find($code);

        /**
         * ensure that the authorization code was issued to the authenticated
         * confidential client, or if the client is public, ensure that the
         * code was issued to "client_id" in the request,
         */
        if (!$authorizationCode || $authorizationCode->getClientIdentifier() !== $tokenEndpoint->getClient()->getIdentifier()) {
            throw new OAuthException('invalid_grant',
                'The request includes the invalid parameter code.',
                'https://tools.ietf.org/html/rfc7636#section-4.4');
        }

        $this->authorizationCodeStorage->revoke($code);

        /**
         * verify that the authorization code is valid
         */
        if ($this->authorizationCodeStorage->hasExpired($authorizationCode)) {
            throw new OAuthException('invalid_grant',
                'The request includes the invalid parameter code. The code has expired.',
                'https://tools.ietf.org/html/rfc7636#section-4.4');
        }

        /**
         * ensure that the "redirect_uri" parameter is present if the
         * "redirect_uri" parameter was included in the initial authorization
         * request as described in Section 4.1.1, and if included ensure that
         * their values are identical.
         */
        if ($authorizationCode->getRedirectUri()) {
            if (empty($requestData['redirect_uri'])) {
                throw new OAuthException('invalid_request',
                    'The request is missing the required parameter redirect_uri',
                    'https://tools.ietf.org/html/rfc7636#section-4.1');
            }
            if ($requestData['redirect_uri'] !== $authorizationCode->getRedirectUri()) {
                throw new OAuthException('invalid_request',
                    'The request includes the invalid parameter redirect_uri',
                    'https://tools.ietf.org/html/rfc7636#section-4.1');
            }
        }

        return $this->issueTokens($authorizationCode->getScope(),
            $authorizationCode->getResourceOwnerIdentifier(), $authorizationCode->getCode());
    }
}

1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: Alexandre
5			* Date: 18/02/2018
6			* Time: 18:08
7			*/
8
9			namespace OAuth2\Flows;
10
11
12			use OAuth2\Endpoints\AuthorizationEndpoint;
13			use OAuth2\Endpoints\TokenEndpoint;
14			use OAuth2\Exceptions\OAuthException;
15			use OAuth2\GrantTypes\AbstractGrantType;
16			use OAuth2\Storages\AccessTokenStorageInterface;
17			use OAuth2\Storages\AuthorizationCodeStorageInterface;
18			use OAuth2\Storages\RefreshTokenStorageInterface;
19
20			class AuthorizationCodeFlow extends AbstractGrantType implements FlowInterface
21			{
22			protected $authorizationCodeStorage;
23
24			public function __construct(AuthorizationCodeStorageInterface $authorizationCodeStorage,
25			AccessTokenStorageInterface $accessTokenStorage,
26			RefreshTokenStorageInterface $refreshTokenStorage)
27			{
28			parent::__construct($accessTokenStorage, $refreshTokenStorage);
29			$this->authorizationCodeStorage = $authorizationCodeStorage;
30			}
31
32			public function getResponseTypes(): array
33			{
34			return ['code'];
35			}
36
37			public function verifyAuthorizationRequest(AuthorizationEndpoint $authorizationEndpoint, array $requestData)
38			{
39			}
40
41			public function handleAuthorizationRequest(AuthorizationEndpoint $authorizationEndpoint, array $requestData): array
42			{
43			$authorizationCode = $this->authorizationCodeStorage->create(
44			implode(' ', $authorizationEndpoint->getScopes()),
45			$authorizationEndpoint->getClient()->getIdentifier(),
46			$authorizationEndpoint->getResourceOwner()->getIdentifier(),
47			$requestData['scope'] ?? null,
48			$requestData['redirect_uri'] ?? null
49			);
50			$this->authorizationCodeStorage->save($authorizationCode);
51			return ['code' => $authorizationCode->getCode()];
52			}
53
54			public function getDefaultResponseMode(): string
55			{
56			return 'query';
57			}
58
59			public function getUnsupportedResponseModes(): array
60			{
61			return [];
62			}
63
64			public function getGrantTypes(): array
65			{
66			return ['authorization_code'];
67			}
68
69			/**
70			* @param TokenEndpoint $tokenEndpoint
71			* @param array $requestData
72			* @return array
73			* @throws OAuthException
74			*/
75			public function handleAccessTokenRequest(TokenEndpoint $tokenEndpoint, array $requestData): array
76			{
77			if (empty($requestData['code'])) {
78			throw new OAuthException('invalid_request',
79			'The request is missing the required parameter code.',
80			'https://tools.ietf.org/html/rfc7636#section-4.4');
81			}
82			$code = $requestData['code'];
83
84			$authorizationCode = $this->authorizationCodeStorage->find($code);
85
86			/**
87			* ensure that the authorization code was issued to the authenticated
88			* confidential client, or if the client is public, ensure that the
89			* code was issued to "client_id" in the request,
90			*/
91			if (!$authorizationCode \|\| $authorizationCode->getClientIdentifier() !== $tokenEndpoint->getClient()->getIdentifier()) {
92			throw new OAuthException('invalid_grant',
93			'The request includes the invalid parameter code.',
94			'https://tools.ietf.org/html/rfc7636#section-4.4');
95			}
96
97			$this->authorizationCodeStorage->revoke($code);
98
99			/**
100			* verify that the authorization code is valid
101			*/
102			if ($this->authorizationCodeStorage->hasExpired($authorizationCode)) {
103			throw new OAuthException('invalid_grant',
104			'The request includes the invalid parameter code. The code has expired.',
105			'https://tools.ietf.org/html/rfc7636#section-4.4');
106			}
107
108			/**
109			* ensure that the "redirect_uri" parameter is present if the
110			* "redirect_uri" parameter was included in the initial authorization
111			* request as described in Section 4.1.1, and if included ensure that
112			* their values are identical.
113			*/
114			if ($authorizationCode->getRedirectUri()) {
115			if (empty($requestData['redirect_uri'])) {
116			throw new OAuthException('invalid_request',
117			'The request is missing the required parameter redirect_uri',
118			'https://tools.ietf.org/html/rfc7636#section-4.1');
119			}
120			if ($requestData['redirect_uri'] !== $authorizationCode->getRedirectUri()) {
121			throw new OAuthException('invalid_request',
122			'The request includes the invalid parameter redirect_uri',
123			'https://tools.ietf.org/html/rfc7636#section-4.1');
124			}
125			}
126
127			return $this->issueTokens($authorizationCode->getScope(),
128			$authorizationCode->getResourceOwnerIdentifier(), $authorizationCode->getCode());
129			}
130			}

php-guard / oauth-server

Push — master ( cd0cec...4b3abd )

AuthorizationCodeFlow::handleAccessTokenRequest() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like