AuthorizationCodeGrant::validateClient() - Code Metrics - phisch/oauth-server - Measure and Improve Code Quality continuously with Scrutinizer

AuthorizationCodeGrant::validateClient() B
last analyzed 2018-01-21 14:01 UTC

↳ Parent: AuthorizationCodeGrant

Complexity

Conditions	4
Paths	4

Size

Total Lines	34
Code Lines	19

Duplication

Lines	34
Ratio	100 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
dl	34
loc	34
c	0
b	0
f	0
ccs	0
cts	26
cp	0
rs	8.5806
cc	4
eloc	19
nc	4
nop	1
crap	20

<?php

namespace Phisch\OAuth\Server\Grant;

use Phisch\OAuth\Server\Entity\ClientEntityInterface;
use Phisch\OAuth\Server\Entity\ScopeEntityInterface;
use Phisch\OAuth\Server\Entity\UserEntityInterface;
use Phisch\OAuth\Server\Exception\AuthorizationServerException;
use Phisch\OAuth\Server\Repository\AccessTokenRepositoryInterface;
use Phisch\OAuth\Server\Repository\ClientRepositoryInterface;
use Phisch\OAuth\Server\Repository\RefreshTokenRepositoryInterface;
use Phisch\OAuth\Server\Repository\ScopeRepositoryInterface;
use Phisch\OAuth\Server\Repository\UserRepositoryInterface;
use Phisch\OAuth\Server\Response\ResponseBuilderInterface;
use Phisch\OAuth\Server\Token\TokenTypeInterface;
use Symfony\Component\HttpFoundation\Request;

class AuthorizationCodeGrant implements AuthorizationGrantInterface

{

    /**
     * @var ClientRepositoryInterface
     */
    private $clientRepository;

    /**
     * @var ScopeRepositoryInterface
     */
    private $scopeRepository;

    /**
     * @var UserRepositoryInterface
     */
    private $userRepository;

    /**
     * @var AccessTokenRepositoryInterface
     */
    private $accessTokenRepository;

    /**
     * @var RefreshTokenRepositoryInterface
     */
    private $refreshTokenRepository;

    /**
     * @var TokenTypeInterface
     */
    private $token;

    /**
     * @param ClientRepositoryInterface $clientRepository
     * @param ScopeRepositoryInterface $scopeRepository
     * @param UserRepositoryInterface $userRepository
     * @param AccessTokenRepositoryInterface $accessTokenRepository
     * @param RefreshTokenRepositoryInterface $refreshTokenRepository
     * @param TokenTypeInterface $token
     */
    public function __construct(
        ClientRepositoryInterface $clientRepository,
        ScopeRepositoryInterface $scopeRepository,
        UserRepositoryInterface $userRepository,
        AccessTokenRepositoryInterface $accessTokenRepository,
        RefreshTokenRepositoryInterface $refreshTokenRepository,
        TokenTypeInterface $token
    ) {
        $this->clientRepository = $clientRepository;
        $this->scopeRepository = $scopeRepository;
        $this->userRepository = $userRepository;
        $this->accessTokenRepository = $accessTokenRepository;
        $this->refreshTokenRepository = $refreshTokenRepository;
        $this->token = $token;
    }

    /**
     * @param Request $request
     * @return bool
     */
    public function supports(Request $request)
    {
        return $request->get('response_type') === $this->getIdentifier();
    }

    /**
     * @param Request $request
     * @param ResponseBuilderInterface $responseBuilder
     * @return mixed
     */
    public function handle(Request $request, ResponseBuilderInterface $responseBuilder)
    {
        $client = $this->validateClient($request);
        $scopes = $this->validateScopes($request);
        $user = $this->validateUser($request);

        // check if scopes fit for client

        $expiryDateTime = (new \DateTime())->add(new \DateInterval('PT1H'));
        $accessToken = $this->accessTokenRepository->createToken($client, $user, $scopes, $expiryDateTime);

        $expiryDateTime = (new \DateTime())->add(new \DateInterval('P1M'));
        $refreshToken = $this->refreshTokenRepository->createToken($accessToken, $expiryDateTime);

        return $responseBuilder->success($this->token, $accessToken, $refreshToken, $scopes);
    }

    /**
     * @param Request $request
     * @return ClientEntityInterface
     * @throws AuthorizationServerException
     */
    private function validateClient(Request $request)
    {
        $clientId = $request->get('client_id');
        $clientSecret = $request->get('client_secret');

        $client = $this->clientRepository->getClient($clientId);

        if ($client instanceof ClientEntityInterface === false) {
            throw new AuthorizationServerException('The requested client is unknown.', null, null, 'invalid_client');
        }

        if ($client->getSecret() !== $clientSecret) {
            throw new AuthorizationServerException(
                'The given client_secret does not match the client.',
                null,
                null,
                'invalid_client'
            );
        }

        if (!in_array($this->getIdentifier(), $client->getGrantTypes())) {
            throw new AuthorizationServerException(
                'The authenticated client is not authorized to use this authorization grant type.',
                null,
                null,
                'unauthorized_client'
            );
        }

        // TODO: check if validating the uri is necessary here, should be irrelevant for password credentials grant
        // TODO: might be necessary if this will be used for multiple grants though

        return $client;
    }

    /**
     * @param Request $request
     * @return ScopeEntityInterface[]
     */
    private function validateScopes(Request $request)
    {
        $scopeParameter = $request->get('scope');
        $scopeIdentifiers = explode(' ', $scopeParameter);

        $scopes = $this->scopeRepository->getScopes($scopeIdentifiers);

        return $scopes;
    }

    private function validateUser(Request $request)
    {
        $username = $request->get('username');
        $password = $request->get('password');

        $user = $this->userRepository->getUser($username, $password);

        if ($user instanceof UserEntityInterface === false) {
            // TODO: check how to correctly handle invalid user credentials, the rfc doesn't really guide that case
            throw new AuthorizationServerException(
                'The given user credentials are invalid.',
                null,
                null,
                'invalid_user_credentials'
            );
        }

        return $user;
    }

    /**
     * @return string
     */
    private function getIdentifier()
    {
        return 'code';
    }

    public function cancel()
    {
        // TODO: Implement cancel() method.
    }

    public function validate(Request $request)
    {
        //throw new AuthorizationServerException('fuck fuck fuck',0, null, 'yeah, something went horribly wrong!');

    }
}


1		<?php
2
3		namespace Phisch\OAuth\Server\Grant;
4
5		use Phisch\OAuth\Server\Entity\ClientEntityInterface;
6		use Phisch\OAuth\Server\Entity\ScopeEntityInterface;
7		use Phisch\OAuth\Server\Entity\UserEntityInterface;
8		use Phisch\OAuth\Server\Exception\AuthorizationServerException;
9		use Phisch\OAuth\Server\Repository\AccessTokenRepositoryInterface;
10		use Phisch\OAuth\Server\Repository\ClientRepositoryInterface;
11		use Phisch\OAuth\Server\Repository\RefreshTokenRepositoryInterface;
12		use Phisch\OAuth\Server\Repository\ScopeRepositoryInterface;
13		use Phisch\OAuth\Server\Repository\UserRepositoryInterface;
14		use Phisch\OAuth\Server\Response\ResponseBuilderInterface;
15		use Phisch\OAuth\Server\Token\TokenTypeInterface;
16		use Symfony\Component\HttpFoundation\Request;
17
18	View Code Duplication	class AuthorizationCodeGrant implements AuthorizationGrantInterface
		0 ignored issues – show Duplication introduced 2017-06-15 23:36 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
19		{
20
21		/**
22		* @var ClientRepositoryInterface
23		*/
24		private $clientRepository;
25
26		/**
27		* @var ScopeRepositoryInterface
28		*/
29		private $scopeRepository;
30
31		/**
32		* @var UserRepositoryInterface
33		*/
34		private $userRepository;
35
36		/**
37		* @var AccessTokenRepositoryInterface
38		*/
39		private $accessTokenRepository;
40
41		/**
42		* @var RefreshTokenRepositoryInterface
43		*/
44		private $refreshTokenRepository;
45
46		/**
47		* @var TokenTypeInterface
48		*/
49		private $token;
50
51		/**
52		* @param ClientRepositoryInterface $clientRepository
53		* @param ScopeRepositoryInterface $scopeRepository
54		* @param UserRepositoryInterface $userRepository
55		* @param AccessTokenRepositoryInterface $accessTokenRepository
56		* @param RefreshTokenRepositoryInterface $refreshTokenRepository
57		* @param TokenTypeInterface $token
58		*/
59		public function __construct(
60		ClientRepositoryInterface $clientRepository,
61		ScopeRepositoryInterface $scopeRepository,
62		UserRepositoryInterface $userRepository,
63		AccessTokenRepositoryInterface $accessTokenRepository,
64		RefreshTokenRepositoryInterface $refreshTokenRepository,
65		TokenTypeInterface $token
66		) {
67		$this->clientRepository = $clientRepository;
68		$this->scopeRepository = $scopeRepository;
69		$this->userRepository = $userRepository;
70		$this->accessTokenRepository = $accessTokenRepository;
71		$this->refreshTokenRepository = $refreshTokenRepository;
72		$this->token = $token;
73		}
74
75		/**
76		* @param Request $request
77		* @return bool
78		*/
79		public function supports(Request $request)
80		{
81		return $request->get('response_type') === $this->getIdentifier();
82		}
83
84		/**
85		* @param Request $request
86		* @param ResponseBuilderInterface $responseBuilder
87		* @return mixed
88		*/
89		public function handle(Request $request, ResponseBuilderInterface $responseBuilder)
90		{
91		$client = $this->validateClient($request);
92		$scopes = $this->validateScopes($request);
93		$user = $this->validateUser($request);
94
95		// check if scopes fit for client
96
97		$expiryDateTime = (new \DateTime())->add(new \DateInterval('PT1H'));
98		$accessToken = $this->accessTokenRepository->createToken($client, $user, $scopes, $expiryDateTime);
99
100		$expiryDateTime = (new \DateTime())->add(new \DateInterval('P1M'));
101		$refreshToken = $this->refreshTokenRepository->createToken($accessToken, $expiryDateTime);
102
103		return $responseBuilder->success($this->token, $accessToken, $refreshToken, $scopes);
104		}
105
106		/**
107		* @param Request $request
108		* @return ClientEntityInterface
109		* @throws AuthorizationServerException
110		*/
111		private function validateClient(Request $request)
112		{
113		$clientId = $request->get('client_id');
114		$clientSecret = $request->get('client_secret');
115
116		$client = $this->clientRepository->getClient($clientId);
117
118		if ($client instanceof ClientEntityInterface === false) {
119		throw new AuthorizationServerException('The requested client is unknown.', null, null, 'invalid_client');
120		}
121
122		if ($client->getSecret() !== $clientSecret) {
123		throw new AuthorizationServerException(
124		'The given client_secret does not match the client.',
125		null,
126		null,
127		'invalid_client'
128		);
129		}
130
131		if (!in_array($this->getIdentifier(), $client->getGrantTypes())) {
132		throw new AuthorizationServerException(
133		'The authenticated client is not authorized to use this authorization grant type.',
134		null,
135		null,
136		'unauthorized_client'
137		);
138		}
139
140		// TODO: check if validating the uri is necessary here, should be irrelevant for password credentials grant
141		// TODO: might be necessary if this will be used for multiple grants though
142
143		return $client;
144		}
145
146		/**
147		* @param Request $request
148		* @return ScopeEntityInterface[]
149		*/
150		private function validateScopes(Request $request)
151		{
152		$scopeParameter = $request->get('scope');
153		$scopeIdentifiers = explode(' ', $scopeParameter);
154
155		$scopes = $this->scopeRepository->getScopes($scopeIdentifiers);
156
157		return $scopes;
158		}
159
160		private function validateUser(Request $request)
161		{
162		$username = $request->get('username');
163		$password = $request->get('password');
164
165		$user = $this->userRepository->getUser($username, $password);
166
167		if ($user instanceof UserEntityInterface === false) {
168		// TODO: check how to correctly handle invalid user credentials, the rfc doesn't really guide that case
169		throw new AuthorizationServerException(
170		'The given user credentials are invalid.',
171		null,
172		null,
173		'invalid_user_credentials'
174		);
175		}
176
177		return $user;
178		}
179
180		/**
181		* @return string
182		*/
183		private function getIdentifier()
184		{
185		return 'code';
186		}
187
188		public function cancel()
189		{
190		// TODO: Implement cancel() method.
191		}
192
193		public function validate(Request $request)
194		{
195		//throw new AuthorizationServerException('fuck fuck fuck',0, null, 'yeah, something went horribly wrong!');
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-06-15 23:36 UTC by Report Bug Copy Issue Report `71%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
196		}
197		}
198

phisch / oauth-server

AuthorizationCodeGrant::validateClient() B last analyzed 2018-01-21 14:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AuthorizationCodeGrant::validateClient() B
last analyzed 2018-01-21 14:01 UTC