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

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