vendor/friendsofsymfony/rest-bundle/Controller/ExceptionController.php line 64

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSRestBundle package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace FOS\RestBundle\Controller;
  14. use FOS\RestBundle\Util\ExceptionValueMap;
  15. use FOS\RestBundle\View\View;
  16. use FOS\RestBundle\View\ViewHandlerInterface;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\Debug\Exception\FlattenException;
  20. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  21. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  23. /**
  24.  * Custom ExceptionController that uses the view layer and supports HTTP response status code mapping.
  25.  */
  26. class ExceptionController
  27. {
  28.     /**
  29.      * @var ViewHandlerInterface
  30.      */
  31.     private $viewHandler;
  33.     /**
  34.      * @var ExceptionValueMap
  35.      */
  36.     private $exceptionCodes;
  38.     /**
  39.      * @var bool
  40.      */
  41.     private $showException;
  43.     public function __construct(
  44.         ViewHandlerInterface $viewHandler,
  45.         ExceptionValueMap $exceptionCodes,
  46.         $showException
  47.     ) {
  48.         $this->viewHandler = $viewHandler;
  49.         $this->exceptionCodes = $exceptionCodes;
  50.         $this->showException = $showException;
  51.     }
  53.     /**
  54.      * Converts an Exception to a Response.
  55.      *
  56.      * @param Request                   $request
  57.      * @param \Exception|\Throwable     $exception
  58.      * @param DebugLoggerInterface|null $logger
  59.      *
  60.      * @throws \InvalidArgumentException
  61.      *
  62.      * @return Response
  63.      */
  64.     public function showAction(Request $request, $exception, DebugLoggerInterface $logger = null)
  65.     {
  66.         $currentContent = $this->getAndCleanOutputBuffering($request->headers->get('X-Php-Ob-Level', -1));
  67.         $code = $this->getStatusCode($exception);
  68.         $templateData = $this->getTemplateData($currentContent, $code, $exception, $logger);
  70.         $view = $this->createView($exception, $code, $templateData, $request, $this->showException);
  71.         $response = $this->viewHandler->handle($view);
  73.         return $response;
  74.     }
  76.     /**
  77.      * @param \Exception $exception
  78.      * @param int        $code
  79.      * @param array      $templateData
  80.      * @param Request    $request
  81.      * @param bool       $showException
  82.      *
  83.      * @return View
  84.      */
  85.     protected function createView(\Exception $exception, $code, array $templateData, Request $request, $showException)
  86.     {
  87.         $view = new View($exception, $code, $exception instanceof HttpExceptionInterface ? $exception->getHeaders() : []);
  88.         $view->setTemplateVar('raw_exception');
  89.         $view->setTemplateData($templateData);
  91.         return $view;
  92.     }
  94.     /**
  95.      * Determines the status code to use for the response.
  96.      *
  97.      * @param \Exception $exception
  98.      *
  99.      * @return int
  100.      */
  101.     protected function getStatusCode(\Exception $exception)
  102.     {
  103.         // If matched
  104.         if ($statusCode = $this->exceptionCodes->resolveException($exception)) {
  105.             return $statusCode;
  106.         }
  108.         // Otherwise, default
  109.         if ($exception instanceof HttpExceptionInterface) {
  110.             return $exception->getStatusCode();
  111.         }
  113.         return 500;
  114.     }
  116.     /**
  117.      * Determines the template parameters to pass to the view layer.
  118.      *
  119.      * @param string               $currentContent
  120.      * @param int                  $code
  121.      * @param \Exception           $exception
  122.      * @param DebugLoggerInterface $logger
  123.      *
  124.      * @return array
  125.      */
  126.     private function getTemplateData($currentContent, $code, \Exception $exception, DebugLoggerInterface $logger = null)
  127.     {
  128.         return [
  129.             'exception' => FlattenException::create($exception),
  130.             'status' => 'error',
  131.             'status_code' => $code,
  132.             'status_text' => array_key_exists($code, Response::$statusTexts) ? Response::$statusTexts[$code] : 'error',
  133.             'currentContent' => $currentContent,
  134.             'logger' => $logger,
  135.         ];
  136.     }
  138.     /**
  139.      * Gets and cleans any content that was already outputted.
  140.      *
  141.      * This code comes from Symfony and should be synchronized on a regular basis
  142.      * see src/Symfony/Bundle/TwigBundle/Controller/ExceptionController.php
  143.      *
  144.      * @return string
  145.      */
  146.     private function getAndCleanOutputBuffering($startObLevel)
  147.     {
  148.         if (ob_get_level() <= $startObLevel) {
  149.             return '';
  150.         }
  151.         Response::closeOutputBuffers($startObLevel + 1, true);
  153.         return ob_get_clean();
  154.     }
  155. }