Happyr\ApiBundle\EventListener\ExceptionListener

Complexity

Total Complexity

11

Size/Duplication

Total Lines	60
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
D	onKernelException()	0	32	10

<?php

namespace Happyr\ApiBundle\EventListener;

use Fervo\ValidatedMessage\ValidationFailedException;
use Happyr\ApiBundle\Service\ResponseFactory;
use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Validator\ConstraintViolationInterface;

/**
 * @author Tobias Nyholm <tobias.nyholm@gmail.com>
 */
class ExceptionListener
{
    /**
     * @var ResponseFactory
     */
    private $responseFactory;

    /**
     * @var string
     */
    private $pathPrefix;

    /**
     * @param ResponseFactory $responseFactory
     * @param string          $pathPrefix
     */
    public function __construct(ResponseFactory $responseFactory, $pathPrefix)
    {
        $this->responseFactory = $responseFactory;
        $this->pathPrefix = $pathPrefix;
    }

    /**
     * Make sure we print a nice error message to the user when we encounter an exception.
     *
     * @param GetResponseForExceptionEvent $event
     */
    public function onKernelException(GetResponseForExceptionEvent $event)
    {
        // Make sure to match uri before we start to catch exceptions
        if (!preg_match('|^'.$this->pathPrefix.'.*|sim', $event->getRequest()->getPathInfo())) {
            return;
        }

        $exception = $event->getException();
        if ($exception instanceof AccessDeniedException) {
            $response = $this->responseFactory->createForbidden();
        } elseif ($exception instanceof AuthenticationException) {
            $response = $this->responseFactory->createUnauthorized();
        } elseif ($exception instanceof BadRequestHttpException) {
            $response = $this->responseFactory->createWrongArgs();
        } elseif ($exception instanceof MethodNotAllowedException || $exception instanceof MethodNotAllowedHttpException) {
            $response = $this->responseFactory->createWithError('Method not allowed', 405, 'GEN-METHOD');
        } elseif ($exception instanceof NotFoundHttpException) {
            $response = $this->responseFactory->createNotFound();
        } elseif ($exception instanceof ValidationFailedException) {
            $message = '';
            /** @var ConstraintViolationInterface $violation */
            foreach ($exception->getViolations() as $violation) {
                $message .= sprintf('%s: %s ', $violation->getPropertyPath(), $violation->getMessage());
            }

            $response = $this->responseFactory->createWrongArgs($message);
        } else {
            $response = $this->responseFactory->createInternalError();
        }

        $event->setResponse($response);
    }
}