Authorization::hasOfflineAccess() - Code Metrics - Inspection of "WIP" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — ng ( f9780e...ccd5de )

by Florent

created 2018-01-16 21:21 UTC

Authorization::hasOfflineAccess() A

↳ Parent: Project

Complexity

Conditions	4
Paths	3

Size

Total Lines	15
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
rs	9.2
c	0
b	0
f	0
cc	4
eloc	6
nc	3
nop	0

<?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\Server\AuthorizationEndpoint;

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

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

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

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

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

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

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

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

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

    /**
     * @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
    {
        $clone = clone $this;
        $clone->tokenType = $tokenType;

        return $clone;
    }

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

    /**
     * @param ResponseType[] $responseTypes
     *
     * @return Authorization
     */
    public function withResponseTypes(array $responseTypes): self
    {
        $clone = clone $this;
        $clone->responseTypes = $responseTypes;

        return $clone;
    }

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

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

        return $clone;
    }

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

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

        return $clone;
    }

    /**
     * @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
    {
        $clone = clone $this;
        $clone->userAccount = $userAccount;
        $clone->userAccountFullyAuthenticated = $isFullyAuthenticated;

        return $clone;
    }

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

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

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

        return $clone;
    }

    /**
     * @return Authorization
     */
    public function deny(): self
    {
        $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)
    {
        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
    {
        $clone = clone $this;
        $clone->data[$key] = $data;

        return $clone;
    }

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

    /**
     * @param ResourceServer $resourceServer
     *
     * @return Authorization
     */
    public function withResourceServer(ResourceServer $resourceServer): self
    {
        $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): self
    {
        $clone = clone $this;
        $clone->consentScreenOptions[$option] = $value;

        return $clone;
    }

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

OAuth2-Framework / oauth2-framework

Push — ng ( f9780e...ccd5de )

Authorization::hasOfflineAccess() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like