App\Middleware\ErrorHandlingMiddleware

Complexity

Total Complexity

18

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	handleUnsupportedMediaType()	0	10	1
A	handleException()	0	29	2
A	hideRoot()	0	7	1
A	handleBadRequest()	0	22	2
B	process()	0	20	8
A	handleInvalidEntity()	0	5	1
A	handleMethodNotAllowed()	0	10	1
A	handleRouteNotFound()	0	9	1
A	handleResourceNotFound()	0	9	1

<?php declare(strict_types=1);

namespace App\Middleware;

/**
 * Import classes
 */
use App\ContainerAwareTrait;
use App\Exception\InvalidEntityException;
use App\Exception\ResourceNotFoundException;
use Arus\Http\Response\ResponseFactoryAwareTrait;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Sunrise\Http\Router\Exception\BadRequestException;
use Sunrise\Http\Router\Exception\MethodNotAllowedException;
use Sunrise\Http\Router\Exception\RouteNotFoundException;
use Sunrise\Http\Router\Exception\UnsupportedMediaTypeException;
use Symfony\Component\Validator\ConstraintViolation;
use Symfony\Component\Validator\ConstraintViolationList;
use Whoops\Run as Whoops;
use Whoops\Handler\PrettyPageHandler;
use Throwable;

/**
 * Import functions
 */
use function get_class;
use function implode;
use function preg_quote;
use function preg_replace;
use function sprintf;

/**
 * ErrorHandlingMiddleware
 */
final class ErrorHandlingMiddleware implements MiddlewareInterface
{
    use ContainerAwareTrait;
    use ResponseFactoryAwareTrait;

    /**
     * Error codes
     */
    public const BAD_REQUEST_ERROR_CODE = 'b187c971-810b-455a-baf3-06dc6a1591f4';
    public const METHOD_NOT_ALLOWED_ERROR_CODE = '7d8f78d7-c689-409b-8031-8401ab5836b6';
    public const ROUTE_NOT_FOUND_ERROR_CODE = '979775e6-a43b-414f-bb72-cbe0133f621e';
    public const RESOURCE_NOT_FOUND_ERROR_CODE = 'cb378ff8-a1ec-48ba-baad-2c61f47ce95e';
    public const UNSUPPORTED_MEDIA_TYPE_ERROR_CODE = '87255179-5041-4f1b-a469-b891ad5dc623';
    public const UNCAUGHT_EXCEPTION_ERROR_CODE = '594358d2-b5f1-4cfc-8c60-df43cfd720b3';

    /**
     * {@inheritDoc}
     *
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $handler
     *
     * @return ResponseInterface
     */
    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler
    ) : ResponseInterface {
        try {
            return $handler->handle($request);
        } catch (BadRequestException $e) {
            return $this->handleBadRequest($request, $e);
        } catch (MethodNotAllowedException $e) {
            return $this->handleMethodNotAllowed($request, $e);
        } catch (RouteNotFoundException $e) {
            return $this->handleRouteNotFound($request, $e);
        } catch (ResourceNotFoundException $e) {
            return $this->handleResourceNotFound($request, $e);
        } catch (UnsupportedMediaTypeException $e) {
            return $this->handleUnsupportedMediaType($request, $e);
        } catch (InvalidEntityException $e) {
            return $this->handleInvalidEntity($request, $e);
        } catch (Throwable $e) {
            return $this->handleException($request, $e);
        }
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param BadRequestException $exception
     *
     * @return ResponseInterface
     */
    private function handleBadRequest(
        ServerRequestInterface $request,

The parameter $request is not used and could be removed.

        BadRequestException $exception
    ) : ResponseInterface {
        $violations = new ConstraintViolationList();

        foreach ($exception->getViolations() as $v) {
            $violations->add(new ConstraintViolation(
                $v['message'],
                null,
                [],
                null,
                $v['property'],
                null,
                null,
                self::BAD_REQUEST_ERROR_CODE,
                null,
                null
            ));
        }

        return $this->violations($violations, 400);
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param MethodNotAllowedException $exception
     *
     * @return ResponseInterface
     */
    private function handleMethodNotAllowed(
        ServerRequestInterface $request,
        MethodNotAllowedException $exception
    ) : ResponseInterface {
        return $this->error(
            $exception->getMessage(),
            $request->getUri()->getPath(),
            self::METHOD_NOT_ALLOWED_ERROR_CODE,
            405
        )->withHeader('Allow', implode(',', $exception->getAllowedMethods()));
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param RouteNotFoundException $exception
     *
     * @return ResponseInterface
     */
    private function handleRouteNotFound(
        ServerRequestInterface $request,
        RouteNotFoundException $exception
    ) : ResponseInterface {
        return $this->error(
            $exception->getMessage(),
            $request->getUri()->getPath(),
            self::ROUTE_NOT_FOUND_ERROR_CODE,
            404
        );
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param ResourceNotFoundException $exception
     *
     * @return ResponseInterface
     */
    private function handleResourceNotFound(
        ServerRequestInterface $request,
        ResourceNotFoundException $exception
    ) : ResponseInterface {
        return $this->error(
            $exception->getMessage(),
            $request->getUri()->getPath(),
            self::RESOURCE_NOT_FOUND_ERROR_CODE,
            404
        );
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param UnsupportedMediaTypeException $exception
     *
     * @return ResponseInterface
     */
    private function handleUnsupportedMediaType(
        ServerRequestInterface $request,
        UnsupportedMediaTypeException $exception
    ) : ResponseInterface {
        return $this->error(
            $exception->getMessage(),
            $request->getUri()->getPath(),
            self::UNSUPPORTED_MEDIA_TYPE_ERROR_CODE,
            415
        )->withHeader('Accept', implode(',', $exception->getSupportedTypes()));
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param InvalidEntityException $exception
     *
     * @return ResponseInterface
     */
    private function handleInvalidEntity(
        ServerRequestInterface $request,

The parameter $request is not used and could be removed.

        InvalidEntityException $exception
    ) : ResponseInterface {
        return $this->violations($exception->getEntityViolations(), 400);
    }

    /**
     * Returns a response with the given processed exception
     *
     * @param ServerRequestInterface $request
     * @param Throwable $exception
     *
     * @return ResponseInterface
     *
     * @link https://github.com/filp/whoops
     */
    private function handleException(
        ServerRequestInterface $request,
        Throwable $exception
    ) : ResponseInterface {
        $this->container->get('logger')->error($exception->getMessage(), [
            'exception' => $exception,
        ]);

        if (!$this->container->get('app.display_errors')) {
            return $this->error(
                sprintf(
                    'Caught the exception %s in the file %s on line %d.',
                    get_class($exception),
                    $this->hideRoot($exception->getFile()),
                    $exception->getLine()
                ),
                $request->getUri()->getPath(),
                self::UNCAUGHT_EXCEPTION_ERROR_CODE,
                500
            );
        }

        $whoops = new Whoops();
        $whoops->allowQuit(false);
        $whoops->sendHttpCode(false);
        $whoops->writeToOutput(false);
        $whoops->pushHandler(new PrettyPageHandler());

        return $this->html($whoops->handleException($exception), 500);
    }

    /**
     * Hides the application root from the given path
     *
     * @param string $path
     *
     * @return string
     */
    private function hideRoot(string $path) : string
    {
        $root = preg_quote($this->container->get('app.root'), '/');

        $path = preg_replace('/^' . $root . '/ui', '', $path);

        return $path;
    }
}