M6Web\Bundle\ApiExceptionBundle\EventListener\ExceptionListener

Complexity

Total Complexity

23

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

95.38%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
C	onKernelException()	0	49	10
A	getStatusCode()	0	12	3
A	getMessage()	0	10	2
A	getHeaders()	0	12	3
A	isApiException()	0	8	2
A	isFlattenErrorException()	0	8	2

<?php

namespace M6Web\Bundle\ApiExceptionBundle\EventListener;

use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface as SymfonyHttpExceptionInterface;
use M6Web\Bundle\ApiExceptionBundle\Manager\ExceptionManager;
use M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface;
use M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\HttpExceptionInterface;
use M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\FlattenErrorExceptionInterface;

/**
 * Class ExceptionListener
 */
class ExceptionListener
{
    /**
     * @var boolean
     */
    protected $stackTrace;

    /**
     * @var array
     */
    protected $default;

    /**
     * @var Kernel
     */
    protected $kernel;

    /**
     * @var ExceptionManager
     */
    protected $exceptionManager;

    /**
     * @var boolean
     */
    protected $matchAll;

    /**
     * Constructor
     *
     * @param Kernel           $kernel
     * @param ExceptionManager $exceptionManager
     * @param boolean          $matchAll
     * @param array            $default
     * @param boolean          $stackTrace
     */
    public function __construct(
        Kernel $kernel,
        ExceptionManager $exceptionManager,
        $matchAll,
        array $default,
        $stackTrace = false
    ) {
        $this->kernel           = $kernel;
        $this->exceptionManager = $exceptionManager;
        $this->matchAll         = $matchAll;
        $this->default          = $default;
        $this->stackTrace       = $stackTrace;
    }

    /**
     * Format response exception
     *
     * @param GetResponseForExceptionEvent $event
     */
    public function onKernelException(GetResponseForExceptionEvent $event)
    {
        $exception = $event->getException();

        if (!($event->getRequest())
            || ($this->matchAll === false && !$this->isApiException($exception))
        ) {
            return;
        }

        $data = [];

        if ($this->isApiException($exception)) {
            $exception = $this->exceptionManager->configure($exception);

$exception is of type object<Exception>, but the function expects a object<M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface>.

        }

        $statusCode = $this->getStatusCode($exception);

It seems like $exception defined by $this->exceptionManager->configure($exception) on line 85 can also be of type object<M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface>; however, M6Web\Bundle\ApiExceptionBundle\EventListener\ExceptionListener::getStatusCode() does only seem to accept object<Exception>, maybe add an additional type check?

        $data['error']['status']  = $statusCode;

        if ($code = $exception->getCode()) {
            $data['error']['code'] = $code;
        }

        $data['error']['message'] = $this->getMessage($exception);

It seems like $exception defined by $this->exceptionManager->configure($exception) on line 85 can also be of type object<M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface>; however, M6Web\Bundle\ApiExceptionBundle\EventListener\ExceptionListener::getMessage() does only seem to accept object<Exception>, maybe add an additional type check?

        if ($this->isFlattenErrorException($exception)) {

It seems like $exception defined by $this->exceptionManager->configure($exception) on line 85 can also be of type object<M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface>; however, M6Web\Bundle\ApiExceptionBundle\EventListener\ExceptionListener::isFlattenErrorException() does only seem to accept object<Exception>, maybe add an additional type check?

            $data['error']['errors'] = $exception->getFlattenErrors();
        }

        if ($this->stackTrace) {
            $data['error']['stack_trace'] = $exception->getTrace();

The method getTrace does only exist in Exception, but not in M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface.

            // Clean stacktrace to avoid circular reference or invalid type
            array_walk_recursive(
                $data['error']['stack_trace'],
                function(&$item) {
                    if (is_object($item)) {
                        $item = get_class($item);
                    } elseif (is_resource($item)) {
                        $item = get_resource_type($item);
                    }
                }
            );
        }

        $response = new JsonResponse($data, $statusCode, $this->getHeaders($exception));

It seems like $exception defined by $this->exceptionManager->configure($exception) on line 85 can also be of type object<M6Web\Bundle\ApiExceptionBundle\Exception\Interfaces\ExceptionInterface>; however, M6Web\Bundle\ApiExceptionBundle\EventListener\ExceptionListener::getHeaders() does only seem to accept object<Exception>, maybe add an additional type check?

        $event->setResponse($response);
    }

    /**
     * Get exception status code
     *
     * @param \Exception $exception
     *
     * @return integer
     */
    private function getStatusCode(\Exception $exception)
    {
        $statusCode = $this->default['status'];

        if ($exception instanceof SymfonyHttpExceptionInterface
            || $exception instanceof HttpExceptionInterface
        ) {
            $statusCode = $exception->getStatusCode();
        }

        return $statusCode;
    }

    /**
     * Get exception message
     *
     * @param \Exception $exception
     *
     * @return integer
     */
    private function getMessage(\Exception $exception)
    {
        $message = $exception->getMessage();

        if ($this->isApiException($exception)) {
            $message = $exception->getMessageWithVariables();

The method getMessageWithVariables() does not exist on Exception. Did you maybe mean getMessage()?

        }

        return $message;
    }

    /**
     * Get exception headers
     *
     * @param \Exception $exception
     *
     * @return array
     */
    private function getHeaders(\Exception $exception)
    {
        $headers = $this->default['headers'];

        if ($exception instanceof SymfonyHttpExceptionInterface
            || $exception instanceof HttpExceptionInterface
        ) {
            $headers = $exception->getHeaders();
        }

        return $headers;
    }

    /**
     * Is api exception
     *
     * @param \Exception $exception
     *
     * @return boolean
     */
    private function isApiException(\Exception $exception)
    {
        if ($exception instanceof ExceptionInterface) {
            return true;
        }

        return false;
    }

    /**
     * Is flatten error exception
     *
     * @param \Exception $exception
     *
     * @return boolean
     */
    private function isFlattenErrorException(\Exception $exception)
    {
        if ($exception instanceof FlattenErrorExceptionInterface) {
            return true;
        }

        return false;
    }
}