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

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 class BlockRenderer implements BlockRendererInterface
  28. {
  29.     private BlockServiceManagerInterface $blockServiceManager;
  31.     private StrategyManagerInterface $exceptionStrategyManager;
  33.     private ?LoggerInterface $logger;
  35.     /**
  36.      * This property hold the last response available from the child or sibling block
  37.      * The cacheable attributes must be cascaded to the parent.
  38.      */
  39.     private ?Response $lastResponse = null;
  41.     /**
  42.      * @param BlockServiceManagerInterface $blockServiceManager      Block service manager
  43.      * @param StrategyManagerInterface     $exceptionStrategyManager Exception strategy manager
  44.      * @param LoggerInterface              $logger                   Logger class
  45.      */
  46.     public function __construct(
  47.         BlockServiceManagerInterface $blockServiceManager,
  48.         StrategyManagerInterface $exceptionStrategyManager,
  49.         ?LoggerInterface $logger = null
  50.     ) {
  51.         $this->blockServiceManager = $blockServiceManager;
  52.         $this->exceptionStrategyManager = $exceptionStrategyManager;
  53.         $this->logger = $logger;
  54.     }
  56.     public function render(BlockContextInterface $blockContext, ?Response $response = null): Response
  57.     {
  58.         $block = $blockContext->getBlock();
  60.         if (null !== $this->logger) {
  61.             $this->logger->info(
  62.                 sprintf('[cms::renderBlock] block.id=%d, block.type=%s', $block->getId() ?? '', $block->getType() ?? '')
  63.             );
  64.         }
  66.         try {
  67.             $service = $this->blockServiceManager->get($block);
  68.             $service->load($block);
  70.             $response = $service->execute($blockContext, $this->createResponse($blockContext, $response));
  72.             $response = $this->addMetaInformation($response, $blockContext);
  73.         } catch (\Throwable $exception) {
  74.             if (null !== $this->logger) {
  75.                 $this->logger->error(sprintf(
  76.                     '[cms::renderBlock] block.id=%d - error while rendering block - %s',
  77.                     $block->getId() ?? '',
  78.                     $exception->getMessage()
  79.                 ), compact('exception'));
  80.             }
  82.             // reseting the state object
  83.             $this->lastResponse = null;
  85.             $response = $this->exceptionStrategyManager->handleException($exception, $blockContext->getBlock(), $response);
  86.         }
  88.         return $response;
  89.     }
  91.     private function createResponse(BlockContextInterface $blockContext, ?Response $response = null): Response
  92.     {
  93.         if (null === $response) {
  94.             $response = new Response();
  95.         }
  97.         // set the ttl from the block instance, this can be changed by the BlockService
  98.         if (($ttl = $blockContext->getBlock()->getTtl()) > 0) {
  99.             $response->setTtl($ttl);
  100.         }
  102.         return $response;
  103.     }
  105.     /**
  106.      * This method is responsible to cascade ttl to the parent block.
  107.      */
  108.     private function addMetaInformation(Response $response, BlockContextInterface $blockContext): Response
  109.     {
  110.         // a response exists, use it
  111.         if (null !== $this->lastResponse && $this->lastResponse->isCacheable()) {
  112.             $lastResponseTtl = $this->lastResponse->getTtl();
  113.             if (null !== $lastResponseTtl) {
  114.                 $response->setTtl($lastResponseTtl);
  115.             }
  116.             $response->setPublic();
  117.         } elseif (null !== $this->lastResponse) { // not cacheable
  118.             $response->setPrivate();
  119.             $response->setTtl(0);
  120.             $response->headers->removeCacheControlDirective('s-maxage');
  121.             $response->headers->removeCacheControlDirective('maxage');
  122.         }
  124.         // no more children available in the stack, reseting the state object
  125.         if (!$blockContext->getBlock()->hasParent()) {
  126.             $this->lastResponse = null;
  127.         } else { // contains a parent so storing the response
  128.             $this->lastResponse = $response;
  129.         }
  131.         return $response;
  132.     }
  133. }