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

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 as LegacyFlattenException;
  20. use Symfony\Component\ErrorRenderer\Exception\FlattenException;
  21. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  22. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  24. /**
  25.  * Custom ExceptionController that uses the view layer and supports HTTP response status code mapping.
  26.  */
  27. class ExceptionController
  28. {
  29.     /**
  30.      * @var ViewHandlerInterface
  31.      */
  32.     private $viewHandler;
  34.     /**
  35.      * @var ExceptionValueMap
  36.      */
  37.     private $exceptionCodes;
  39.     /**
  40.      * @var bool
  41.      */
  42.     private $showException;
  44.     public function __construct(
  45.         ViewHandlerInterface $viewHandler,
  46.         ExceptionValueMap $exceptionCodes,
  47.         $showException
  48.     ) {
  49.         $this->viewHandler = $viewHandler;
  50.         $this->exceptionCodes = $exceptionCodes;
  51.         $this->showException = $showException;
  52.     }
  54.     /**
  55.      * Converts an Exception to a Response.
  56.      *
  57.      * @param Request                   $request
  58.      * @param \Exception|\Throwable     $exception
  59.      * @param DebugLoggerInterface|null $logger
  60.      *
  61.      * @throws \InvalidArgumentException
  62.      *
  63.      * @return Response
  64.      */
  65.     public function showAction(Request $request, $exception, DebugLoggerInterface $logger = null)
  66.     {
  67.         $currentContent = $this->getAndCleanOutputBuffering($request->headers->get('X-Php-Ob-Level', -1));
  68.         $code = $this->getStatusCode($exception);
  69.         $templateData = $this->getTemplateData($currentContent, $code, $exception, $logger);
  71.         $view = $this->createView($exception, $code, $templateData, $request, $this->showException);
  72.         $response = $this->viewHandler->handle($view);
  74.         return $response;
  75.     }
  77.     /**
  78.      * @param \Exception $exception
  79.      * @param int        $code
  80.      * @param array      $templateData
  81.      * @param Request    $request
  82.      * @param bool       $showException
  83.      *
  84.      * @return View
  85.      */
  86.     protected function createView(\Exception $exception, $code, array $templateData, Request $request, $showException)
  87.     {
  88.         $view = new View($exception, $code, $exception instanceof HttpExceptionInterface ? $exception->getHeaders() : []);
  89.         $view->setTemplateVar('raw_exception');
  90.         $view->setTemplateData($templateData);
  92.         return $view;
  93.     }
  95.     /**
  96.      * Determines the status code to use for the response.
  97.      *
  98.      * @param \Exception $exception
  99.      *
  100.      * @return int
  101.      */
  102.     protected function getStatusCode(\Exception $exception)
  103.     {
  104.         // If matched
  105.         if ($statusCode = $this->exceptionCodes->resolveException($exception)) {
  106.             return $statusCode;
  107.         }
  109.         // Otherwise, default
  110.         if ($exception instanceof HttpExceptionInterface) {
  111.             return $exception->getStatusCode();
  112.         }
  114.         return 500;
  115.     }
  117.     /**
  118.      * Determines the template parameters to pass to the view layer.
  119.      *
  120.      * @param string               $currentContent
  121.      * @param int                  $code
  122.      * @param \Exception           $exception
  123.      * @param DebugLoggerInterface $logger
  124.      *
  125.      * @return array
  126.      */
  127.     private function getTemplateData($currentContent, $code, \Exception $exception, DebugLoggerInterface $logger = null)
  128.     {
  129.         if (class_exists(FlattenException::class)) {
  130.             $exception = FlattenException::createFromThrowable($exception);
  131.         } else {
  132.             $exception = LegacyFlattenException::create($exception);
  133.         }
  135.         return [
  136.             'exception' => $exception,
  137.             'status' => 'error',
  138.             'status_code' => $code,
  139.             'status_text' => array_key_exists($code, Response::$statusTexts) ? Response::$statusTexts[$code] : 'error',
  140.             'currentContent' => $currentContent,
  141.             'logger' => $logger,
  142.         ];
  143.     }
  145.     /**
  146.      * Gets and cleans any content that was already outputted.
  147.      *
  148.      * This code comes from Symfony and should be synchronized on a regular basis
  149.      * see src/Symfony/Bundle/TwigBundle/Controller/ExceptionController.php
  150.      *
  151.      * @return string
  152.      */
  153.     private function getAndCleanOutputBuffering($startObLevel)
  154.     {
  155.         if (ob_get_level() <= $startObLevel) {
  156.             return '';
  157.         }
  158.         Response::closeOutputBuffers($startObLevel + 1, true);
  160.         return ob_get_clean();
  161.     }
  162. }