Authorization - Code Metrics - Inspection of "Userinfo Endpoint" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( b0e939...893034 )

by Florent

created 2018-06-12 11:46 UTC

Authorization F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	549
Duplicated Lines	0 %

Coupling/Cohesion

Components	14
Dependencies	1

Importance

Changes

Metric	Value
wmc	52
lcom	14
cbo	1
dl	0
loc	549
rs	2.48
c	0
b	0
f	0

45 Methods

Rating	Name	Size	Complexity
A	getResponseParameters()	4	1
A	getResponseParameter()	8	2
A	hasResponseParameter()	4	1
A	__construct()	6	1
A	create()	4	1
A	getQueryParams()	4	1
A	hasQueryParam()	4	1
A	getQueryParam()	8	2
A	getClient()	4	1
A	withTokenType()	6	1
A	getTokenType()	4	1
A	withClaims()	6	1
A	getClaims()	4	1
A	withResponseType()	6	1
A	getResponseType()	4	1
A	withResponseMode()	6	1
A	getResponseMode()	4	1
A	withRedirectUri()	6	1
A	getRedirectUri()	4	1
A	withUserAccount()	7	1
A	getUserAccount()	4	1
A	withResponseParameter()	6	1
A	withResponseHeader()	6	1
A	getResponseHeaders()	4	1
A	isUserAccountFullyAuthenticated()	4	1
A	getPrompt()	8	2
A	hasUiLocales()	4	1
A	getUiLocales()	4	2
A	hasPrompt()	4	1
A	isAuthorized()	4	1
A	allow()	6	1
A	deny()	6	1
A	hasData()	4	1
A	getData()	8	2
A	withData()	6	1
A	getResourceServer()	4	1
A	withResourceServer()	6	1
A	withConsentScreenOption()	6	1
A	withoutConsentScreenOption()	10	2
A	hasScope()	4	1
A	getScope()	4	1
A	withMetadata()	6	1
A	hasMetadata()	4	1
A	getMetadata()	8	2
A	getMetadatas()	4	1

How to fix Complexity

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace OAuth2Framework\Component\AuthorizationEndpoint;

use OAuth2Framework\Component\AuthorizationEndpoint\ResponseMode\ResponseMode;
use OAuth2Framework\Component\Core\Client\Client;
use OAuth2Framework\Component\Core\DataBag\DataBag;
use OAuth2Framework\Component\Core\ResourceServer\ResourceServer;
use OAuth2Framework\Component\Core\UserAccount\UserAccount;
use OAuth2Framework\Component\Core\TokenType\TokenType;

class Authorization

{
    /**
     * @var bool
     */
    private $authorized;

    /**
     * @var Client
     */
    private $client;

    /**
     * @var UserAccount|null
     */
    private $userAccount = null;

    /**
     * @var DataBag
     */
    private $metadata;

    /**
     * @var null|bool
     */
    private $userAccountFullyAuthenticated = null;

    /**
     * @var array
     */
    private $data = [];

    /**
     * @var null|array
     */
    private $claims = null;

    /**
     * @var TokenType|null
     */
    private $tokenType = null;

    /**
     * @var ResponseType]
     */
    private $responseType = null;

    /**
     * @var ResponseMode|null
     */
    private $responseMode = null;

    /**
     * @var array
     */
    private $queryParameters = [];

    /**
     * @var string|null
     */
    private $redirectUri = null;

    /**
     * @var array
     */
    private $consentScreenOptions = [];

    /**
     * @var array
     */
    private $responseParameters = [];

    /**
     * @var array
     */
    private $responseHeaders = [];

    /**
     * @var null|ResourceServer
     */
    private $resourceServer = null;

    /**
     * Authorization constructor.
     *
     * @param Client $client
     * @param array  $queryParameters
     */
    private function __construct(Client $client, array $queryParameters)
    {
        $this->client = $client;
        $this->queryParameters = $queryParameters;
        $this->metadata = DataBag::create([]);
    }

    /**
     * @param Client $client
     * @param array  $queryParameters
     *
     * @return Authorization

     */
    public static function create(Client $client, array $queryParameters): self
    {
        return new self($client, $queryParameters);
    }

    /**
     * @return array
     */
    public function getQueryParams(): array
    {
        return $this->queryParameters;
    }

    /**
     * @param string $param
     *
     * @return bool
     */
    public function hasQueryParam(string $param): bool
    {
        return array_key_exists($param, $this->queryParameters);
    }

    /**
     * @param string $param
     *
     * @return mixed
     */
    public function getQueryParam(string $param)
    {
        if (!$this->hasQueryParam($param)) {
            throw new \InvalidArgumentException(sprintf('Invalid parameter "%s".', $param));
        }

        return $this->queryParameters[$param];
    }

    /**
     * @return Client
     */
    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * @param TokenType $tokenType
     *
     * @return Authorization
     */
    public function withTokenType(TokenType $tokenType): self
    {
        $this->tokenType = $tokenType;

        return $this;
    }

    /**
     * @return null|TokenType
     */
    public function getTokenType(): ? TokenType
    {
        return $this->tokenType;
    }

    /**
     * @param array $claims
     *
     * @return Authorization
     */
    public function withClaims(array $claims): self
    {
        $this->claims = $claims;

        return $this;
    }

    /**
     * @return null|array
     */
    public function getClaims(): ?array
    {
        return $this->claims;
    }

    /**
     * @param ResponseType $responseType
     *
     * @return Authorization
     */
    public function withResponseType(ResponseType $responseType): self
    {
        $this->responseType = $responseType;

        return $this;
    }

    /**
     * @return ResponseType
     */
    public function getResponseType(): ResponseType
    {
        return $this->responseType;
    }

    /**
     * @param ResponseMode $responseMode
     *
     * @return Authorization
     */
    public function withResponseMode(ResponseMode $responseMode): self
    {
        $this->responseMode = $responseMode;

        return $this;
    }

    /**
     * @return null|ResponseMode
     */
    public function getResponseMode(): ? ResponseMode
    {
        return $this->responseMode;
    }

    /**
     * @param string $redirectUri
     *
     * @return Authorization
     */
    public function withRedirectUri(string $redirectUri): self
    {
        $this->redirectUri = $redirectUri;

        return $this;
    }

    /**
     * @return null|string
     */
    public function getRedirectUri(): ? string
    {
        return $this->redirectUri;
    }

    /**
     * @param UserAccount $userAccount
     * @param bool        $isFullyAuthenticated
     *
     * @return Authorization
     */
    public function withUserAccount(UserAccount $userAccount, bool $isFullyAuthenticated): self
    {
        $this->userAccount = $userAccount;
        $this->userAccountFullyAuthenticated = $isFullyAuthenticated;

        return $this;
    }

    /**
     * @return null|UserAccount
     */
    public function getUserAccount(): ? UserAccount
    {
        return $this->userAccount;
    }

    /**
     * @param string $responseParameter
     * @param mixed  $value
     *
     * @return Authorization
     */
    public function withResponseParameter(string $responseParameter, $value): self
    {
        $this->responseParameters[$responseParameter] = $value;

        return $this;
    }

    /**
     * @return array
     */
    public function getResponseParameters(): array
    {
        return $this->responseParameters;
    }

    /**
     * @param string $param
     *
     * @return mixed
     */
    public function getResponseParameter(string $param)
    {
        if (!$this->hasResponseParameter($param)) {
            throw new \InvalidArgumentException(sprintf('Invalid response parameter "%s".', $param));
        }

        return $this->getResponseParameters()[$param];
    }

    /**
     * @param string $param
     *
     * @return bool
     */
    public function hasResponseParameter(string $param): bool
    {
        return array_key_exists($param, $this->getResponseParameters());
    }

    /**
     * @param string $responseHeader
     * @param mixed  $value
     *
     * @return Authorization
     */
    public function withResponseHeader(string $responseHeader, $value): self
    {
        $this->responseHeaders[$responseHeader] = $value;

        return $this;
    }

    /**
     * @return array
     */
    public function getResponseHeaders(): array
    {
        return $this->responseHeaders;
    }

    /**
     * @return bool|null
     */
    public function isUserAccountFullyAuthenticated(): ? bool
    {
        return $this->userAccountFullyAuthenticated;
    }

    /**
     * @return string[]
     */
    public function getPrompt(): array
    {
        if (!$this->hasQueryParam('prompt')) {
            return [];
        }

        return explode(' ', $this->getQueryParam('prompt'));
    }

    /**
     * @return bool
     */
    public function hasUiLocales(): bool
    {
        return $this->hasQueryParam('ui_locales');
    }

    /**
     * @return string[]
     */
    public function getUiLocales(): array
    {
        return $this->hasQueryParam('ui_locales') ? explode(' ', $this->getQueryParam('ui_locales')) : [];
    }

    /**
     * @param string $prompt
     *
     * @return bool
     */
    public function hasPrompt(string $prompt): bool
    {
        return in_array($prompt, $this->getPrompt());
    }

    /**
     * @return bool
     */
    public function isAuthorized(): bool
    {
        return $this->authorized;
    }

    /**
     * @return Authorization
     */
    public function allow(): self
    {
        $this->authorized = true;

        return $this;
    }

    /**
     * @return Authorization
     */
    public function deny(): self
    {
        $this->authorized = false;

        return $this;
    }

    /**
     * @param string $key
     *
     * @return bool
     */
    public function hasData(string $key): bool
    {
        return array_key_exists($key, $this->data);
    }

    /**
     * @param string $key
     *
     * @return mixed
     */
    public function getData(string $key)
    {
        if (!$this->hasData($key)) {
            throw new \InvalidArgumentException(sprintf('Invalid data "%s".', $key));
        }

        return $this->data[$key];
    }

    /**
     * @param string $key
     * @param mixed  $data
     *
     * @return Authorization
     */
    public function withData(string $key, $data): self
    {
        $this->data[$key] = $data;

        return $this;
    }

    /**
     * @return null|ResourceServer
     */
    public function getResourceServer(): ? ResourceServer
    {
        return $this->resourceServer;
    }

    /**
     * @param ResourceServer $resourceServer
     *
     * @return Authorization
     */
    public function withResourceServer(ResourceServer $resourceServer): self
    {
        $this->resourceServer = $resourceServer;

        return $this;
    }

    /**
     * @param string $option
     * @param mixed  $value
     *
     * @return Authorization
     */
    public function withConsentScreenOption(string $option, $value): self
    {
        $this->consentScreenOptions[$option] = $value;

        return $this;
    }

    /**
     * @param string $option
     *
     * @return Authorization
     */
    public function withoutConsentScreenOption(string $option): self
    {
        if (!array_key_exists($option, $this->consentScreenOptions)) {
            return $this;
        }

        unset($this->consentScreenOptions[$option]);

        return $this;
    }

    public function hasScope(): bool
    {
        return $this->hasQueryParam('scope');
    }

    /**
     * @return string
     */
    public function getScope(): string
    {
        return $this->getQueryParam('scope');
    }

    /**
     * @param string     $key
     * @param mixed|null $data
     *
     * @return Authorization
     */
    public function withMetadata(string $key, $data): self
    {
        $this->metadata = $this->metadata->with($key, $data);

        return $this;
    }

    /**
     * @param string $key
     *
     * @return bool
     */
    public function hasMetadata(string $key): bool
    {
        return $this->metadata->has($key);
    }

    /**
     * @param string $key
     *
     * @return bool
     */
    public function getMetadata(string $key): bool
    {
        if (!$this->hasMetadata($key)) {
            throw new \InvalidArgumentException(sprintf('The metadata "%s" does not exist.', $key));
        }

        return $this->metadata->get($key);
    }

    public function getMetadatas(): DataBag
    {
        return $this->metadata;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* The MIT License (MIT)
7			*
8			* Copyright (c) 2014-2018 Spomky-Labs
9			*
10			* This software may be modified and distributed under the terms
11			* of the MIT license. See the LICENSE file for details.
12			*/
13
14			namespace OAuth2Framework\Component\AuthorizationEndpoint;
15
16			use OAuth2Framework\Component\AuthorizationEndpoint\ResponseMode\ResponseMode;
17			use OAuth2Framework\Component\Core\Client\Client;
18			use OAuth2Framework\Component\Core\DataBag\DataBag;
19			use OAuth2Framework\Component\Core\ResourceServer\ResourceServer;
20			use OAuth2Framework\Component\Core\UserAccount\UserAccount;
21			use OAuth2Framework\Component\Core\TokenType\TokenType;
22
23			class Authorization
			0 ignored issues – show Coding Style introduced 2018-02-06 20:36 UTC by Report Bug Copy Issue Report Since you have declared the constructor as private, maybe you should also declare the class as final. Loading history...
24			{
25			/**
26			* @var bool
27			*/
28			private $authorized;
29
30			/**
31			* @var Client
32			*/
33			private $client;
34
35			/**
36			* @var UserAccount\|null
37			*/
38			private $userAccount = null;
39
40			/**
41			* @var DataBag
42			*/
43			private $metadata;
44
45			/**
46			* @var null\|bool
47			*/
48			private $userAccountFullyAuthenticated = null;
49
50			/**
51			* @var array
52			*/
53			private $data = [];
54
55			/**
56			* @var null\|array
57			*/
58			private $claims = null;
59
60			/**
61			* @var TokenType\|null
62			*/
63			private $tokenType = null;
64
65			/**
66			* @var ResponseType]
67			*/
68			private $responseType = null;
69
70			/**
71			* @var ResponseMode\|null
72			*/
73			private $responseMode = null;
74
75			/**
76			* @var array
77			*/
78			private $queryParameters = [];
79
80			/**
81			* @var string\|null
82			*/
83			private $redirectUri = null;
84
85			/**
86			* @var array
87			*/
88			private $consentScreenOptions = [];
89
90			/**
91			* @var array
92			*/
93			private $responseParameters = [];
94
95			/**
96			* @var array
97			*/
98			private $responseHeaders = [];
99
100			/**
101			* @var null\|ResourceServer
102			*/
103			private $resourceServer = null;
104
105			/**
106			* Authorization constructor.
107			*
108			* @param Client $client
109			* @param array $queryParameters
110			*/
111			private function __construct(Client $client, array $queryParameters)
112			{
113			$this->client = $client;
114			$this->queryParameters = $queryParameters;
115			$this->metadata = DataBag::create([]);
116			}
117
118			/**
119			* @param Client $client
120			* @param array $queryParameters
121			*
122			* @return Authorization
			0 ignored issues – show Documentation introduced 2018-01-05 14:16 UTC by Report Bug Copy Issue Report Should the return type not be `\self`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
123			*/
124			public static function create(Client $client, array $queryParameters): self
125			{
126			return new self($client, $queryParameters);
127			}
128
129			/**
130			* @return array
131			*/
132			public function getQueryParams(): array
133			{
134			return $this->queryParameters;
135			}
136
137			/**
138			* @param string $param
139			*
140			* @return bool
141			*/
142			public function hasQueryParam(string $param): bool
143			{
144			return array_key_exists($param, $this->queryParameters);
145			}
146
147			/**
148			* @param string $param
149			*
150			* @return mixed
151			*/
152			public function getQueryParam(string $param)
153			{
154			if (!$this->hasQueryParam($param)) {
155			throw new \InvalidArgumentException(sprintf('Invalid parameter "%s".', $param));
156			}
157
158			return $this->queryParameters[$param];
159			}
160
161			/**
162			* @return Client
163			*/
164			public function getClient(): Client
165			{
166			return $this->client;
167			}
168
169			/**
170			* @param TokenType $tokenType
171			*
172			* @return Authorization
173			*/
174			public function withTokenType(TokenType $tokenType): self
175			{
176			$this->tokenType = $tokenType;
177
178			return $this;
179			}
180
181			/**
182			* @return null\|TokenType
183			*/
184			public function getTokenType(): ? TokenType
185			{
186			return $this->tokenType;
187			}
188
189			/**
190			* @param array $claims
191			*
192			* @return Authorization
193			*/
194			public function withClaims(array $claims): self
195			{
196			$this->claims = $claims;
197
198			return $this;
199			}
200
201			/**
202			* @return null\|array
203			*/
204			public function getClaims(): ?array
205			{
206			return $this->claims;
207			}
208
209			/**
210			* @param ResponseType $responseType
211			*
212			* @return Authorization
213			*/
214			public function withResponseType(ResponseType $responseType): self
215			{
216			$this->responseType = $responseType;
217
218			return $this;
219			}
220
221			/**
222			* @return ResponseType
223			*/
224			public function getResponseType(): ResponseType
225			{
226			return $this->responseType;
227			}
228
229			/**
230			* @param ResponseMode $responseMode
231			*
232			* @return Authorization
233			*/
234			public function withResponseMode(ResponseMode $responseMode): self
235			{
236			$this->responseMode = $responseMode;
237
238			return $this;
239			}
240
241			/**
242			* @return null\|ResponseMode
243			*/
244			public function getResponseMode(): ? ResponseMode
245			{
246			return $this->responseMode;
247			}
248
249			/**
250			* @param string $redirectUri
251			*
252			* @return Authorization
253			*/
254			public function withRedirectUri(string $redirectUri): self
255			{
256			$this->redirectUri = $redirectUri;
257
258			return $this;
259			}
260
261			/**
262			* @return null\|string
263			*/
264			public function getRedirectUri(): ? string
265			{
266			return $this->redirectUri;
267			}
268
269			/**
270			* @param UserAccount $userAccount
271			* @param bool $isFullyAuthenticated
272			*
273			* @return Authorization
274			*/
275			public function withUserAccount(UserAccount $userAccount, bool $isFullyAuthenticated): self
276			{
277			$this->userAccount = $userAccount;
278			$this->userAccountFullyAuthenticated = $isFullyAuthenticated;
279
280			return $this;
281			}
282
283			/**
284			* @return null\|UserAccount
285			*/
286			public function getUserAccount(): ? UserAccount
287			{
288			return $this->userAccount;
289			}
290
291			/**
292			* @param string $responseParameter
293			* @param mixed $value
294			*
295			* @return Authorization
296			*/
297			public function withResponseParameter(string $responseParameter, $value): self
298			{
299			$this->responseParameters[$responseParameter] = $value;
300
301			return $this;
302			}
303
304			/**
305			* @return array
306			*/
307			public function getResponseParameters(): array
308			{
309			return $this->responseParameters;
310			}
311
312			/**
313			* @param string $param
314			*
315			* @return mixed
316			*/
317			public function getResponseParameter(string $param)
318			{
319			if (!$this->hasResponseParameter($param)) {
320			throw new \InvalidArgumentException(sprintf('Invalid response parameter "%s".', $param));
321			}
322
323			return $this->getResponseParameters()[$param];
324			}
325
326			/**
327			* @param string $param
328			*
329			* @return bool
330			*/
331			public function hasResponseParameter(string $param): bool
332			{
333			return array_key_exists($param, $this->getResponseParameters());
334			}
335
336			/**
337			* @param string $responseHeader
338			* @param mixed $value
339			*
340			* @return Authorization
341			*/
342			public function withResponseHeader(string $responseHeader, $value): self
343			{
344			$this->responseHeaders[$responseHeader] = $value;
345
346			return $this;
347			}
348
349			/**
350			* @return array
351			*/
352			public function getResponseHeaders(): array
353			{
354			return $this->responseHeaders;
355			}
356
357			/**
358			* @return bool\|null
359			*/
360			public function isUserAccountFullyAuthenticated(): ? bool
361			{
362			return $this->userAccountFullyAuthenticated;
363			}
364
365			/**
366			* @return string[]
367			*/
368			public function getPrompt(): array
369			{
370			if (!$this->hasQueryParam('prompt')) {
371			return [];
372			}
373
374			return explode(' ', $this->getQueryParam('prompt'));
375			}
376
377			/**
378			* @return bool
379			*/
380			public function hasUiLocales(): bool
381			{
382			return $this->hasQueryParam('ui_locales');
383			}
384
385			/**
386			* @return string[]
387			*/
388			public function getUiLocales(): array
389			{
390			return $this->hasQueryParam('ui_locales') ? explode(' ', $this->getQueryParam('ui_locales')) : [];
391			}
392
393			/**
394			* @param string $prompt
395			*
396			* @return bool
397			*/
398			public function hasPrompt(string $prompt): bool
399			{
400			return in_array($prompt, $this->getPrompt());
401			}
402
403			/**
404			* @return bool
405			*/
406			public function isAuthorized(): bool
407			{
408			return $this->authorized;
409			}
410
411			/**
412			* @return Authorization
413			*/
414			public function allow(): self
415			{
416			$this->authorized = true;
417
418			return $this;
419			}
420
421			/**
422			* @return Authorization
423			*/
424			public function deny(): self
425			{
426			$this->authorized = false;
427
428			return $this;
429			}
430
431			/**
432			* @param string $key
433			*
434			* @return bool
435			*/
436			public function hasData(string $key): bool
437			{
438			return array_key_exists($key, $this->data);
439			}
440
441			/**
442			* @param string $key
443			*
444			* @return mixed
445			*/
446			public function getData(string $key)
447			{
448			if (!$this->hasData($key)) {
449			throw new \InvalidArgumentException(sprintf('Invalid data "%s".', $key));
450			}
451
452			return $this->data[$key];
453			}
454
455			/**
456			* @param string $key
457			* @param mixed $data
458			*
459			* @return Authorization
460			*/
461			public function withData(string $key, $data): self
462			{
463			$this->data[$key] = $data;
464
465			return $this;
466			}
467
468			/**
469			* @return null\|ResourceServer
470			*/
471			public function getResourceServer(): ? ResourceServer
472			{
473			return $this->resourceServer;
474			}
475
476			/**
477			* @param ResourceServer $resourceServer
478			*
479			* @return Authorization
480			*/
481			public function withResourceServer(ResourceServer $resourceServer): self
482			{
483			$this->resourceServer = $resourceServer;
484
485			return $this;
486			}
487
488			/**
489			* @param string $option
490			* @param mixed $value
491			*
492			* @return Authorization
493			*/
494			public function withConsentScreenOption(string $option, $value): self
495			{
496			$this->consentScreenOptions[$option] = $value;
497
498			return $this;
499			}
500
501			/**
502			* @param string $option
503			*
504			* @return Authorization
505			*/
506			public function withoutConsentScreenOption(string $option): self
507			{
508			if (!array_key_exists($option, $this->consentScreenOptions)) {
509			return $this;
510			}
511
512			unset($this->consentScreenOptions[$option]);
513
514			return $this;
515			}
516
517			public function hasScope(): bool
518			{
519			return $this->hasQueryParam('scope');
520			}
521
522			/**
523			* @return string
524			*/
525			public function getScope(): string
526			{
527			return $this->getQueryParam('scope');
528			}
529
530			/**
531			* @param string $key
532			* @param mixed\|null $data
533			*
534			* @return Authorization
535			*/
536			public function withMetadata(string $key, $data): self
537			{
538			$this->metadata = $this->metadata->with($key, $data);
539
540			return $this;
541			}
542
543			/**
544			* @param string $key
545			*
546			* @return bool
547			*/
548			public function hasMetadata(string $key): bool
549			{
550			return $this->metadata->has($key);
551			}
552
553			/**
554			* @param string $key
555			*
556			* @return bool
557			*/
558			public function getMetadata(string $key): bool
559			{
560			if (!$this->hasMetadata($key)) {
561			throw new \InvalidArgumentException(sprintf('The metadata "%s" does not exist.', $key));
562			}
563
564			return $this->metadata->get($key);
565			}
566
567			public function getMetadatas(): DataBag
568			{
569			return $this->metadata;
570			}
571			}
572

OAuth2-Framework / oauth2-framework

Push — master ( b0e939...893034 )

Authorization F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

45 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like