Authorization::hasUiLocales() - Code Metrics - Inspection of "Populate metadata and parameters" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 3bf08d...6e3f66 )

by Florent

created 2017-10-02 00:25 UTC

Authorization::hasUiLocales() A

↳ Parent: Authorization

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2017 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\Server\Endpoint\Authorization;

use Assert\Assertion;
use OAuth2Framework\Component\Server\Model\Client\Client;
use OAuth2Framework\Component\Server\Model\ResourceServer\ResourceServerInterface;
use OAuth2Framework\Component\Server\Model\UserAccount\UserAccountInterface;
use OAuth2Framework\Component\Server\ResponseMode\ResponseModeInterface;
use OAuth2Framework\Component\Server\ResponseType\ResponseTypeInterface;
use OAuth2Framework\Component\Server\TokenType\TokenTypeInterface;

final class Authorization
{
    /**
     * @var bool|null
     */
    private $authorized = null;

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

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

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

    /**
     * @var string[]
     */
    private $scopes = [];

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

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

    /**
     * @var ResponseTypeInterface[]
     */
    private $responseTypes = [];

    /**
     * @var ResponseModeInterface|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|ResourceServerInterface
     */
    private $resourceServer = null;

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

    /**
     * @param Client $client
     * @param array  $queryParameters
     *
     * @return Authorization
     */
    public static function create(Client $client, array $queryParameters): Authorization
    {
        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)
    {
        Assertion::true($this->hasQueryParam($param), sprintf('Invalid parameter \'%s\'', $param));

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

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

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

        return $clone;
    }

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

    /**
     * @param ResponseTypeInterface[] $responseTypes
     *
     * @return Authorization
     */
    public function withResponseTypes(array $responseTypes): Authorization
    {
        Assertion::allIsInstanceOf($responseTypes, ResponseTypeInterface::class);
        $clone = clone $this;
        $clone->responseTypes = $responseTypes;

        return $clone;
    }

    /**
     * @return ResponseTypeInterface[]
     */
    public function getResponseTypes(): array
    {
        return $this->responseTypes;
    }

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

        return $clone;
    }

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

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

        return $clone;
    }

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

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

        return $clone;
    }

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

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

        return $clone;
    }

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

    /**
     * @param string $param
     *
     * @return mixed
     */
    public function getResponseParameter(string $param)
    {
        Assertion::true($this->hasResponseParameter($param), 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): Authorization
    {
        $clone = clone $this;
        $clone->responseHeaders[$responseHeader] = $value;

        return $clone;
    }

    /**
     * @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());
    }

    /**
     * @param array $scope
     *
     * @return Authorization
     */
    public function withScopes(array $scope): Authorization
    {
        $clone = clone $this;
        $clone->scopes = $scope;

        return $clone;
    }

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

    /**
     * @param string $scope
     *
     * @return bool
     */
    public function hasScope(string $scope): bool
    {
        return null !== $this->scopes && in_array($scope, $this->scopes);
    }

    /**
     * @param string $scope
     *
     * @return Authorization
     */
    public function withoutScope(string $scope): Authorization
    {
        if (!$this->hasScope($scope)) {
            return $this;
        }
        $clone = clone $this;
        unset($clone->scopes[array_search($scope, $clone->scopes)]);

        return $clone;
    }

    /**
     * @param string $scope
     *
     * @return Authorization
     */
    public function addScope(string $scope): Authorization
    {
        if ($this->hasScope($scope)) {
            return $this;
        }
        $clone = clone $this;
        $clone->scopes[] = $scope;

        return $clone;
    }

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

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

        return $clone;
    }

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

        return $clone;
    }

    /**
     * @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)
    {
        Assertion::true($this->hasData($key), sprintf('Invalid data \'%s\'', $key));

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

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

        return $clone;
    }

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

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

        return $clone;
    }

    /**
     * @return bool
     */
    public function hasOfflineAccess(): bool
    {
        // The scope offline_access is not requested
        if (!in_array('offline_access', $this->getScopes())) {
            return false;
        }

        // The scope offline_access is requested but prompt is not consent
        // The scope offline_access is ignored
        if (!$this->hasQueryParam('prompt') || false === mb_strpos('consent', $this->getQueryParam('prompt'), 0, '8bit')) {

            return false;
        }

        return true;
    }

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

        return $clone;
    }

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

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

        return $clone;
    }
}


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

OAuth2-Framework / oauth2-framework

Push — master ( 3bf08d...6e3f66 )

Authorization::hasUiLocales() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like