OAuth2Framework\Component\AuthorizationEndpoint\AuthorizationRequest\AuthorizationRequest

Complexity

Total Complexity

45

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Coupling/Cohesion

Components	8
Dependencies	1

Importance

Changes

0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getQueryParams()	0	4	1
A	hasQueryParam()	0	4	1
A	getQueryParam()	0	8	2
A	getClient()	0	4	1
A	setTokenType()	0	4	1
A	getTokenType()	0	4	1
A	setResponseType()	0	4	1
A	getResponseType()	0	4	1
A	setResponseMode()	0	4	1
A	getResponseMode()	0	4	1
A	setRedirectUri()	0	5	1
A	getRedirectUri()	0	4	1
A	setUserAccount()	0	5	1
A	getUserAccount()	0	4	1
A	setResponseParameter()	0	4	1
A	getResponseParameters()	0	4	1
A	getResponseParameter()	0	8	2
A	hasResponseParameter()	0	4	1
A	setResponseHeader()	0	4	1
A	getResponseHeaders()	0	4	1
A	isUserAccountFullyAuthenticated()	0	4	1
A	getPrompt()	0	8	2
A	hasUiLocales()	0	4	1
A	getUiLocales()	0	4	2
A	hasPrompt()	0	4	1
A	isAuthorized()	0	4	1
A	allow()	0	4	1
A	deny()	0	4	1
A	hasData()	0	4	1
A	getData()	0	8	2
A	setData()	0	4	1
A	getResourceServer()	0	4	1
A	setResourceServer()	0	4	1
A	setConsentScreenOption()	0	4	1
A	unsetConsentScreenOption()	0	8	2
A	hasScope()	0	4	1
A	getScope()	0	4	1
A	getMetadata()	0	4	1

<?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\AuthorizationRequest;

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

class AuthorizationRequest
{
    /**
     * @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 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;

    public function __construct(Client $client, array $queryParameters)
    {
        $this->client = $client;
        $this->queryParameters = $queryParameters;
        $this->metadata = new DataBag([]);
    }

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

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

    public function getQueryParam(string $param)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (!$this->hasQueryParam($param)) {
            throw new \InvalidArgumentException(\sprintf('Invalid parameter "%s".', $param));
        }

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

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

    public function setTokenType(TokenType $tokenType): void
    {
        $this->tokenType = $tokenType;
    }

    public function getTokenType(): ?TokenType
    {
        return $this->tokenType;
    }

    public function setResponseType(ResponseType $responseType): void
    {
        $this->responseType = $responseType;
    }

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

    public function setResponseMode(ResponseMode $responseMode): void
    {
        $this->responseMode = $responseMode;
    }

    public function getResponseMode(): ?ResponseMode
    {
        return $this->responseMode;
    }

    public function setRedirectUri(string $redirectUri): void
    {
        $this->redirectUri = $redirectUri;
        $this->metadata->set('redirect_uri', $redirectUri);
    }

    public function getRedirectUri(): ?string
    {
        return $this->redirectUri;
    }

    public function setUserAccount(UserAccount $userAccount, bool $isFullyAuthenticated): void
    {
        $this->userAccount = $userAccount;
        $this->userAccountFullyAuthenticated = $isFullyAuthenticated;
    }

    public function getUserAccount(): ?UserAccount
    {
        return $this->userAccount;
    }

    public function setResponseParameter(string $responseParameter, $value): void
    {
        $this->responseParameters[$responseParameter] = $value;
    }

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

    public function getResponseParameter(string $param)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (!$this->hasResponseParameter($param)) {
            throw new \InvalidArgumentException(\sprintf('Invalid response parameter "%s".', $param));
        }

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

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

    public function setResponseHeader(string $responseHeader, $value): void
    {
        $this->responseHeaders[$responseHeader] = $value;
    }

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

    public function isUserAccountFullyAuthenticated(): ?bool
    {
        return $this->userAccountFullyAuthenticated;
    }

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

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

    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')) : [];
    }

    public function hasPrompt(string $prompt): bool
    {
        return \in_array($prompt, $this->getPrompt(), true);
    }

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

    public function allow(): void
    {
        $this->authorized = true;
    }

    public function deny(): void
    {
        $this->authorized = false;
    }

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

    public function getData(string $key)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (!$this->hasData($key)) {
            throw new \InvalidArgumentException(\sprintf('Invalid data "%s".', $key));
        }

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

    public function setData(string $key, $data): void
    {
        $this->data[$key] = $data;
    }

    public function getResourceServer(): ?ResourceServer
    {
        return $this->resourceServer;
    }

    public function setResourceServer(ResourceServer $resourceServer): void
    {
        $this->resourceServer = $resourceServer;
    }

    public function setConsentScreenOption(string $option, $value): void
    {
        $this->consentScreenOptions[$option] = $value;
    }

    public function unsetConsentScreenOption(string $option): void
    {
        if (!\array_key_exists($option, $this->consentScreenOptions)) {
            return;
        }

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

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

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

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