Phauthentic\Authentication\Middleware\AuthenticationErrorHandlerMiddleware

Complexity

Total Complexity

7

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Test Coverage

Coverage

96%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	createUnauthorizedResponse()	0	15	2
A	__construct()	0	6	1
A	process()	0	8	3
A	createErrorResponse()	0	9	1

<?php
declare(strict_types=1);
/**
 * Copyright (c) Phauthentic (https://github.com/Phauthentic)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Phauthentic (https://github.com/Phauthentic)
 * @link          https://github.com/Phauthentic
 * @license       https://opensource.org/licenses/mit-license.php MIT License
 */
namespace Phauthentic\Authentication\Middleware;

use Phauthentic\Authentication\AuthenticationServiceProviderInterface;
use Phauthentic\Authentication\Authenticator\Exception\AuthenticationExceptionInterface;
use Phauthentic\Authentication\Authenticator\Exception\UnauthorizedException;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

/**
 * Handles the case when the authentication middleware has thrown an exception
 */
class AuthenticationErrorHandlerMiddleware implements MiddlewareInterface
{
    /**
     * Response factory
     *
     * @var \Psr\Http\Message\ResponseFactoryInterface
     */
    protected $responseFactory;

    /**
     * PSR Stream Interface
     *
     * @var \Psr\Http\Message\StreamFactoryInterface
     */
    protected $streamFactory;

    /**
     * Constructor.
     *
     * @param \Psr\Http\Message\ResponseFactoryInterface $responseFactory Factory.
     * @param \Psr\Http\Message\StreamFactoryInterface $streamFactory Factory.
     */
    public function __construct(
        ResponseFactoryInterface $responseFactory,
        StreamFactoryInterface $streamFactory
    ) {
        $this->responseFactory = $responseFactory;
        $this->streamFactory = $streamFactory;
    }

    /**
     * {@inheritDoc}
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        try {
            return $handler->handle($request);
        } catch (UnauthorizedException $e) {
            return $this->createUnauthorizedResponse($e);
        } catch (AuthenticationExceptionInterface $e) {
            return $this->createErrorResponse($e);
        }
    }

    /**
     * Creates an unauthorized response.
     *
     * @param UnauthorizedException $e Exception.
     * @return ResponseInterface
     */
    protected function createUnauthorizedResponse(UnauthorizedException $e): ResponseInterface
    {
        $body = $this->streamFactory->createStream();
        $body->write($e->getBody());

        $response = $this
            ->responseFactory
            ->createResponse($e->getCode())
            ->withBody($body);

        foreach ($e->getHeaders() as $header => $value) {
            $response = $response->withHeader($header, $value);
        }

        return $response;
    }

    /**
     * Creates an error response.
     *
     * @param UnauthorizedException $e Exception.
     * @return ResponseInterface
     */
    protected function createErrorResponse(AuthenticationExceptionInterface $e, int $responseCode = 500): ResponseInterface
    {
        $body = $this->streamFactory->createStream();
        $body->write($e->getMessage());

        return $this
            ->responseFactory
            ->createResponse($responseCode)
            ->withBody($body);
    }
}