vendor/sonata-project/block-bundle/src/Block/BlockRenderer.php line 73

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\BlockBundle\Block;
  16. use Psr\Log\LoggerInterface;
  17. use Sonata\BlockBundle\Exception\Strategy\StrategyManagerInterface;
  18. use Symfony\Component\HttpFoundation\Response;
  20. /**
  21.  * Handles the execution and rendering of a block.
  22.  *
  23.  * This function render a block and make sure the cacheable information are correctly retrieved
  24.  * and set to the upper response (container can have child blocks, so the smallest ttl from a child
  25.  * must be used in the container).
  26.  *
  27.  * @final since sonata-project/block-bundle 3.0
  28.  */
  29. class BlockRenderer implements BlockRendererInterface
  30. {
  31.     /**
  32.      * @var BlockServiceManagerInterface
  33.      */
  34.     protected $blockServiceManager;
  36.     /**
  37.      * @var StrategyManagerInterface
  38.      */
  39.     protected $exceptionStrategyManager;
  41.     /**
  42.      * @var LoggerInterface|null
  43.      */
  44.     protected $logger;
  46.     /**
  47.      * @var bool
  48.      */
  49.     protected $debug;
  51.     /**
  52.      * This property hold the last response available from the child or sibling block
  53.      * The cacheable attributes must be cascaded to the parent.
  54.      *
  55.      * @var Response|null
  56.      */
  57.     private $lastResponse;
  59.     /**
  60.      * @param BlockServiceManagerInterface $blockServiceManager      Block service manager
  61.      * @param StrategyManagerInterface     $exceptionStrategyManager Exception strategy manager
  62.      * @param LoggerInterface              $logger                   Logger class
  63.      * @param bool                         $debug                    Whether in debug mode or not
  64.      */
  65.     public function __construct(BlockServiceManagerInterface $blockServiceManager, StrategyManagerInterface $exceptionStrategyManager, LoggerInterface $logger = null, $debug = false)
  66.     {
  67.         $this->blockServiceManager = $blockServiceManager;
  68.         $this->exceptionStrategyManager = $exceptionStrategyManager;
  69.         $this->logger = $logger;
  70.         $this->debug = $debug;
  71.     }
  73.     public function render(BlockContextInterface $blockContext, Response $response = null)
  74.     {
  75.         $block = $blockContext->getBlock();
  77.         if ($this->logger) {
  78.             $this->logger->info(sprintf('[cms::renderBlock] block.id=%d, block.type=%s ', $block->getId(), $block->getType()));
  79.         }
  81.         try {
  82.             $service = $this->blockServiceManager->get($block);
  83.             $service->load($block);
  85.             $response = $service->execute($blockContext, $this->createResponse($blockContext, $response));
  87.             if (!$response instanceof Response) {
  88.                 $response = null;
  90.                 throw new \RuntimeException('A block service must return a Response object');
  91.             }
  93.             $response = $this->addMetaInformation($response, $blockContext, $service);
  94.         } catch (\Exception $exception) {
  95.             if ($this->logger) {
  96.                 $this->logger->error(sprintf(
  97.                     '[cms::renderBlock] block.id=%d - error while rendering block - %s',
  98.                     $block->getId(),
  99.                     $exception->getMessage()
  100.                 ), compact('exception'));
  101.             }
  103.             // reseting the state object
  104.             $this->lastResponse = null;
  106.             $response = $this->exceptionStrategyManager->handleException($exception, $blockContext->getBlock(), $response);
  107.         }
  109.         return $response;
  110.     }
  112.     /**
  113.      * @return Response
  114.      */
  115.     protected function createResponse(BlockContextInterface $blockContext, Response $response = null)
  116.     {
  117.         if (null === $response) {
  118.             $response = new Response();
  119.         }
  121.         // set the ttl from the block instance, this can be changed by the BlockService
  122.         if (($ttl = $blockContext->getBlock()->getTtl()) > 0) {
  123.             $response->setTtl($ttl);
  124.         }
  126.         return $response;
  127.     }
  129.     /**
  130.      * This method is responsible to cascade ttl to the parent block.
  131.      *
  132.      * @return Response
  133.      */
  134.     protected function addMetaInformation(Response $response, BlockContextInterface $blockContext, BlockServiceInterface $service)
  135.     {
  136.         // a response exists, use it
  137.         if ($this->lastResponse && $this->lastResponse->isCacheable()) {
  138.             $response->setTtl($this->lastResponse->getTtl());
  139.             $response->setPublic();
  140.         } elseif ($this->lastResponse) { // not cacheable
  141.             $response->setPrivate();
  142.             $response->setTtl(0);
  143.             $response->headers->removeCacheControlDirective('s-maxage');
  144.             $response->headers->removeCacheControlDirective('maxage');
  145.         }
  147.         // no more children available in the stack, reseting the state object
  148.         if (!$blockContext->getBlock()->hasParent()) {
  149.             $this->lastResponse = null;
  150.         } else { // contains a parent so storing the response
  151.             $this->lastResponse = $response;
  152.         }
  154.         return $response;
  155.     }
  156. }