Ecas::handleProxyCallback() - Code Metrics - drupol/ecas - Measure and Improve Code Quality continuously with Scrutinizer

Ecas::handleProxyCallback() A
last analyzed 2020-01-06 13:13 UTC

↳ Parent: Ecas

Complexity

Conditions	2
Paths	2

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2.0054

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	10
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	19
ccs	8
cts	9
cp	0.8889
crap	2.0054
rs	9.9332

<?php

declare(strict_types=1);

namespace drupol\ecas;

use drupol\psrcas\Cas;
use drupol\psrcas\CasInterface;
use drupol\psrcas\Configuration\Properties;
use drupol\psrcas\Configuration\PropertiesInterface;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UriFactoryInterface;
use Psr\Log\LoggerInterface;

/**
 * Class Ecas.
 */
final class Ecas implements CasInterface
{
    /**
     * @var \drupol\psrcas\CasInterface
     */
    private $cas;

    /**
     * @var \Psr\Http\Message\StreamFactoryInterface
     */
    private $streamFactory;

    /**
     * Ecas constructor.
     *
     * @param \Psr\Http\Message\ServerRequestInterface $serverRequest
     * @param \drupol\psrcas\Configuration\PropertiesInterface $properties
     * @param \Psr\Http\Client\ClientInterface $client
     * @param \Psr\Http\Message\UriFactoryInterface $uriFactory
     * @param \Psr\Http\Message\ResponseFactoryInterface $responseFactory
     * @param \Psr\Http\Message\RequestFactoryInterface $requestFactory
     * @param \Psr\Http\Message\StreamFactoryInterface $streamFactory
     * @param \Psr\Cache\CacheItemPoolInterface $cache
     * @param \Psr\Log\LoggerInterface $logger
     */
    public function __construct(
        ServerRequestInterface $serverRequest,
        PropertiesInterface $properties,
        ClientInterface $client,
        UriFactoryInterface $uriFactory,
        ResponseFactoryInterface $responseFactory,
        RequestFactoryInterface $requestFactory,
        StreamFactoryInterface $streamFactory,
        CacheItemPoolInterface $cache,
        LoggerInterface $logger
    ) {
        $ecasProperties = $properties->all();

        $ecasProperties['protocol']['serviceValidate']['allowed_parameters'][] = 'userDetails';
        $ecasProperties['protocol']['proxyValidate']['allowed_parameters'][] = 'userDetails';
        $ecasProperties['protocol']['serviceValidate']['default_parameters']['format'] = 'XML';
        $ecasProperties['protocol']['proxyValidate']['default_parameters']['format'] = 'XML';

        $this->cas = new Cas(
            $serverRequest,
            new Properties($ecasProperties),
            $client,
            $uriFactory,
            $responseFactory,
            $requestFactory,
            $streamFactory,
            $cache,
            $logger
        );

        $this->streamFactory = $streamFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function authenticate(): ?array
    {
        return $this->cas->authenticate();
    }

    /**
     * {@inheritdoc}
     */
    public function getProperties(): PropertiesInterface
    {
        return $this->cas->getProperties();
    }

    /**
     * {@inheritdoc}
     */
    public function handleProxyCallback(
        array $parameters = [],
        ?ResponseInterface $response = null
    ): ?ResponseInterface {
        $body = '<?xml version="1.0" encoding="utf-8"?><proxySuccess xmlns="http://www.yale.edu/tp/casClient" />';

        $response = $this
            ->cas
            ->handleProxyCallback($parameters, $response);

        if (null !== $response) {
            return $response->withBody(
                $this
                    ->streamFactory
                    ->createStream($body)
            );
        }

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    public function login(array $parameters = []): ?ResponseInterface
    {
        return $this->cas->login($parameters);
    }

    /**
     * {@inheritdoc}
     */
    public function logout(array $parameters = []): ResponseInterface
    {
        return $this->cas->logout($parameters);

    }

    /**
     * {@inheritdoc}
     */
    public function requestProxyTicket(
        array $parameters = [],
        ?ResponseInterface $response = null
    ): ?ResponseInterface {
        return $this->cas->requestProxyTicket($parameters, $response);
    }

    /**
     * {@inheritdoc}
     */
    public function requestProxyValidate(
        array $parameters = [],
        ?ResponseInterface $response = null
    ): ?ResponseInterface {
        return $this->cas->requestProxyValidate($parameters, $response);
    }

    /**
     * {@inheritdoc}
     */
    public function requestServiceValidate(
        array $parameters = [],
        ?ResponseInterface $response = null
    ): ?ResponseInterface {
        return $this->cas->requestServiceValidate($parameters, $response);
    }

    /**
     * {@inheritdoc}
     */
    public function requestTicketValidation(
        array $parameters = [],
        ?ResponseInterface $response = null
    ): ?ResponseInterface {
        return $this->cas->requestTicketValidation($parameters, $response);
    }

    /**
     * {@inheritdoc}
     */
    public function supportAuthentication(): bool
    {
        return $this->cas->supportAuthentication();
    }

    /**
     * {@inheritdoc}
     */
    public function withServerRequest(ServerRequestInterface $serverRequest): CasInterface
    {
        $clone = clone $this;
        $clone->cas = $clone->cas->withServerRequest($serverRequest);

        return $clone;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace drupol\ecas;
6
7		use drupol\psrcas\Cas;
8		use drupol\psrcas\CasInterface;
9		use drupol\psrcas\Configuration\Properties;
10		use drupol\psrcas\Configuration\PropertiesInterface;
11		use Psr\Cache\CacheItemPoolInterface;
12		use Psr\Http\Client\ClientInterface;
13		use Psr\Http\Message\RequestFactoryInterface;
14		use Psr\Http\Message\ResponseFactoryInterface;
15		use Psr\Http\Message\ResponseInterface;
16		use Psr\Http\Message\ServerRequestInterface;
17		use Psr\Http\Message\StreamFactoryInterface;
18		use Psr\Http\Message\UriFactoryInterface;
19		use Psr\Log\LoggerInterface;
20
21		/**
22		* Class Ecas.
23		*/
24		final class Ecas implements CasInterface
25		{
26		/**
27		* @var \drupol\psrcas\CasInterface
28		*/
29		private $cas;
30
31		/**
32		* @var \Psr\Http\Message\StreamFactoryInterface
33		*/
34		private $streamFactory;
35
36		/**
37		* Ecas constructor.
38		*
39		* @param \Psr\Http\Message\ServerRequestInterface $serverRequest
40		* @param \drupol\psrcas\Configuration\PropertiesInterface $properties
41		* @param \Psr\Http\Client\ClientInterface $client
42		* @param \Psr\Http\Message\UriFactoryInterface $uriFactory
43		* @param \Psr\Http\Message\ResponseFactoryInterface $responseFactory
44		* @param \Psr\Http\Message\RequestFactoryInterface $requestFactory
45		* @param \Psr\Http\Message\StreamFactoryInterface $streamFactory
46		* @param \Psr\Cache\CacheItemPoolInterface $cache
47		* @param \Psr\Log\LoggerInterface $logger
48		*/
49	1	public function __construct(
50		ServerRequestInterface $serverRequest,
51		PropertiesInterface $properties,
52		ClientInterface $client,
53		UriFactoryInterface $uriFactory,
54		ResponseFactoryInterface $responseFactory,
55		RequestFactoryInterface $requestFactory,
56		StreamFactoryInterface $streamFactory,
57		CacheItemPoolInterface $cache,
58		LoggerInterface $logger
59		) {
60	1	$ecasProperties = $properties->all();
61
62	1	$ecasProperties['protocol']['serviceValidate']['allowed_parameters'][] = 'userDetails';
63	1	$ecasProperties['protocol']['proxyValidate']['allowed_parameters'][] = 'userDetails';
64	1	$ecasProperties['protocol']['serviceValidate']['default_parameters']['format'] = 'XML';
65	1	$ecasProperties['protocol']['proxyValidate']['default_parameters']['format'] = 'XML';
66
67	1	$this->cas = new Cas(
68	1	$serverRequest,
69	1	new Properties($ecasProperties),
70		$client,
71		$uriFactory,
72		$responseFactory,
73		$requestFactory,
74		$streamFactory,
75		$cache,
76		$logger
77		);
78
79	1	$this->streamFactory = $streamFactory;
80	1	}
81
82		/**
83		* {@inheritdoc}
84		*/
85		public function authenticate(): ?array
86		{
87		return $this->cas->authenticate();
88		}
89
90		/**
91		* {@inheritdoc}
92		*/
93		public function getProperties(): PropertiesInterface
94		{
95		return $this->cas->getProperties();
96		}
97
98		/**
99		* {@inheritdoc}
100		*/
101	1	public function handleProxyCallback(
102		array $parameters = [],
103		?ResponseInterface $response = null
104		): ?ResponseInterface {
105	1	$body = '<?xml version="1.0" encoding="utf-8"?><proxySuccess xmlns="http://www.yale.edu/tp/casClient" />';
106
107		$response = $this
108	1	->cas
109	1	->handleProxyCallback($parameters, $response);
110
111	1	if (null !== $response) {
112	1	return $response->withBody(
113		$this
114	1	->streamFactory
115	1	->createStream($body)
116		);
117		}
118
119		return $response;
120		}
121
122		/**
123		* {@inheritdoc}
124		*/
125		public function login(array $parameters = []): ?ResponseInterface
126		{
127		return $this->cas->login($parameters);
128		}
129
130		/**
131		* {@inheritdoc}
132		*/
133		public function logout(array $parameters = []): ResponseInterface
134		{
135		return $this->cas->logout($parameters);
		0 ignored issues – show Bug Best Practice introduced 2019-12-06 11:38 UTC by Report Bug Copy Issue Report The expression `return $this->cas->logout($parameters)` could return the type `null` which is incompatible with the type-hinted return `Psr\Http\Message\ResponseInterface`. Consider adding an additional type-check to rule them out. Loading history...
136		}
137
138		/**
139		* {@inheritdoc}
140		*/
141		public function requestProxyTicket(
142		array $parameters = [],
143		?ResponseInterface $response = null
144		): ?ResponseInterface {
145		return $this->cas->requestProxyTicket($parameters, $response);
146		}
147
148		/**
149		* {@inheritdoc}
150		*/
151		public function requestProxyValidate(
152		array $parameters = [],
153		?ResponseInterface $response = null
154		): ?ResponseInterface {
155		return $this->cas->requestProxyValidate($parameters, $response);
156		}
157
158		/**
159		* {@inheritdoc}
160		*/
161		public function requestServiceValidate(
162		array $parameters = [],
163		?ResponseInterface $response = null
164		): ?ResponseInterface {
165		return $this->cas->requestServiceValidate($parameters, $response);
166		}
167
168		/**
169		* {@inheritdoc}
170		*/
171		public function requestTicketValidation(
172		array $parameters = [],
173		?ResponseInterface $response = null
174		): ?ResponseInterface {
175		return $this->cas->requestTicketValidation($parameters, $response);
176		}
177
178		/**
179		* {@inheritdoc}
180		*/
181		public function supportAuthentication(): bool
182		{
183		return $this->cas->supportAuthentication();
184		}
185
186		/**
187		* {@inheritdoc}
188		*/
189	1	public function withServerRequest(ServerRequestInterface $serverRequest): CasInterface
190		{
191	1	$clone = clone $this;
192	1	$clone->cas = $clone->cas->withServerRequest($serverRequest);
193
194	1	return $clone;
195		}
196		}
197

drupol / ecas

Ecas::handleProxyCallback() A last analyzed 2020-01-06 13:13 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Ecas::handleProxyCallback() A
last analyzed 2020-01-06 13:13 UTC