vendor/netgen/layouts-core/bundles/LayoutsBundle/Templating/Twig/Runtime/RenderingRuntime.php line 144

  1. <?php
  3. declare(strict_types=1);
  5. namespace Netgen\Bundle\LayoutsBundle\Templating\Twig\Runtime;
  7. use Generator;
  8. use Netgen\Layouts\API\Service\BlockService;
  9. use Netgen\Layouts\API\Values\Block\Block;
  10. use Netgen\Layouts\API\Values\Collection\Slot;
  11. use Netgen\Layouts\API\Values\Layout\Layout;
  12. use Netgen\Layouts\API\Values\Layout\Zone;
  13. use Netgen\Layouts\Collection\Result\ManualItem;
  14. use Netgen\Layouts\Collection\Result\Result;
  15. use Netgen\Layouts\Error\ErrorHandlerInterface;
  16. use Netgen\Layouts\Exception\InvalidArgumentException;
  17. use Netgen\Layouts\Item\CmsItemInterface;
  18. use Netgen\Layouts\Locale\LocaleProviderInterface;
  19. use Netgen\Layouts\View\RendererInterface;
  20. use Netgen\Layouts\View\Twig\ContextualizedTwigTemplate;
  21. use Netgen\Layouts\View\View\ZoneView\ZoneReference;
  22. use Netgen\Layouts\View\ViewInterface;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\HttpFoundation\RequestStack;
  25. use Throwable;
  26. use Twig\Environment;
  27. use Twig\Template;
  28. use Twig\TemplateWrapper;
  30. use function get_debug_type;
  31. use function is_object;
  32. use function is_scalar;
  33. use function iterator_to_array;
  34. use function method_exists;
  35. use function sprintf;
  37. final class RenderingRuntime
  38. {
  39.     private BlockService $blockService;
  41.     private RendererInterface $renderer;
  43.     private LocaleProviderInterface $localeProvider;
  45.     private RequestStack $requestStack;
  47.     private ErrorHandlerInterface $errorHandler;
  49.     private Environment $simpleTwig;
  51.     public function __construct(
  52.         BlockService $blockService,
  53.         RendererInterface $renderer,
  54.         LocaleProviderInterface $localeProvider,
  55.         RequestStack $requestStack,
  56.         ErrorHandlerInterface $errorHandler,
  57.         Environment $simpleTwig
  58.     ) {
  59.         $this->blockService = $blockService;
  60.         $this->renderer = $renderer;
  61.         $this->localeProvider = $localeProvider;
  62.         $this->requestStack = $requestStack;
  63.         $this->errorHandler = $errorHandler;
  64.         $this->simpleTwig = $simpleTwig;
  65.     }
  67.     /**
  68.      * Renders the provided item.
  69.      *
  70.      * @param array<string, mixed> $context
  71.      * @param array<string, mixed> $parameters
  72.      */
  73.     public function renderItem(array $context, CmsItemInterface $item, string $viewType, array $parameters = [], ?string $viewContext = null): string
  74.     {
  75.         try {
  76.             return $this->renderer->renderValue(
  77.                 $item,
  78.                 $this->getViewContext($context, $viewContext),
  79.                 ['view_type' => $viewType] + $parameters,
  80.             );
  81.         } catch (Throwable $t) {
  82.             $message = sprintf(
  83.                 'Error rendering an item with value "%s" and value type "%s"',
  84.                 $item->getValue(),
  85.                 $item->getValueType(),
  86.             );
  88.             $this->errorHandler->handleError($t, $message);
  89.         }
  91.         return '';
  92.     }
  94.     /**
  95.      * Renders the provided result.
  96.      *
  97.      * @param array<string, mixed> $context
  98.      * @param array<string, mixed> $parameters
  99.      */
  100.     public function renderResult(array $context, Result $result, ?string $overrideViewType = null, ?string $fallbackViewType = null, array $parameters = [], ?string $viewContext = null): string
  101.     {
  102.         $item = $result->getItem();
  103.         $slot = $result->getSlot();
  105.         try {
  106.             $viewType = $fallbackViewType;
  108.             if ($overrideViewType !== null) {
  109.                 $viewType = $overrideViewType;
  110.             } elseif ($item instanceof ManualItem && $item->getCollectionItem()->getViewType() !== null) {
  111.                 $viewType = $item->getCollectionItem()->getViewType();
  112.             } elseif ($slot instanceof Slot && $slot->getViewType() !== null) {
  113.                 $viewType = $slot->getViewType();
  114.             }
  116.             if ($viewType === null) {
  117.                 throw new InvalidArgumentException(
  118.                     'fallbackViewType',
  119.                     'To render a result item, view type needs to be set through slot, or provided via "overrideViewType" or "fallbackViewType" parameters.',
  120.                 );
  121.             }
  123.             return $this->renderItem($context, $item, $viewType, $parameters, $viewContext);
  124.         } catch (Throwable $t) {
  125.             $message = sprintf(
  126.                 'Error rendering an item with value "%s" and value type "%s"',
  127.                 $item->getValue(),
  128.                 $item->getValueType(),
  129.             );
  131.             $this->errorHandler->handleError($t, $message);
  132.         }
  134.         return '';
  135.     }
  137.     /**
  138.      * Renders the provided value.
  139.      *
  140.      * @param array<string, mixed> $context
  141.      * @param mixed $value
  142.      * @param array<string, mixed> $parameters
  143.      */
  144.     public function renderValue(array $context, $value, array $parameters = [], ?string $viewContext = null): string
  145.     {
  146.         try {
  147.             return $this->renderer->renderValue(
  148.                 $value,
  149.                 $this->getViewContext($context, $viewContext),
  150.                 $parameters,
  151.             );
  152.         } catch (Throwable $t) {
  153.             $message = sprintf('Error rendering a value of type "%s"', get_debug_type($value));
  155.             $this->errorHandler->handleError($t, $message, ['object' => $value]);
  156.         }
  158.         return '';
  159.     }
  161.     /**
  162.      * Displays the provided zone.
  163.      */
  164.     public function displayZone(Layout $layout, string $zoneIdentifier, string $viewContext, ContextualizedTwigTemplate $twigTemplate): void
  165.     {
  166.         $locales = null;
  168.         $request = $this->requestStack->getCurrentRequest();
  169.         if ($request instanceof Request) {
  170.             $locales = $this->localeProvider->getRequestLocales($request);
  171.         }
  173.         $zone = $layout->getZone($zoneIdentifier);
  174.         $linkedZone = $zone->getLinkedZone();
  176.         $blocks = $this->blockService->loadZoneBlocks(
  177.             $linkedZone instanceof Zone ? $linkedZone : $zone,
  178.             $locales,
  179.         );
  181.         echo $this->renderValue(
  182.             [],
  183.             new ZoneReference($layout, $zoneIdentifier),
  184.             [
  185.                 'blocks' => $blocks,
  186.                 'twig_template' => $twigTemplate,
  187.             ],
  188.             $viewContext,
  189.         );
  190.     }
  192.     /**
  193.      * Renders the provided block.
  194.      *
  195.      * @param array<string, mixed> $context
  196.      * @param array<string, mixed> $parameters
  197.      */
  198.     public function renderBlock(array $context, Block $block, array $parameters = [], ?string $viewContext = null): string
  199.     {
  200.         try {
  201.             return $this->renderer->renderValue(
  202.                 $block,
  203.                 $this->getViewContext($context, $viewContext),
  204.                 [
  205.                     'twig_template' => $context['twig_template'] ?? null,
  206.                 ] + $parameters,
  207.             );
  208.         } catch (Throwable $t) {
  209.             $message = sprintf('Error rendering a block with UUID "%s"', $block->getId()->toString());
  211.             $this->errorHandler->handleError($t, $message);
  212.         }
  214.         return '';
  215.     }
  217.     /**
  218.      * Renders the provided placeholder.
  219.      *
  220.      * @param array<string, mixed> $context
  221.      * @param array<string, mixed> $parameters
  222.      */
  223.     public function renderPlaceholder(array $context, Block $block, string $placeholder, array $parameters = [], ?string $viewContext = null): string
  224.     {
  225.         try {
  226.             return $this->renderer->renderValue(
  227.                 $block->getPlaceholder($placeholder),
  228.                 $this->getViewContext($context, $viewContext),
  229.                 [
  230.                     'block' => $block,
  231.                     'twig_template' => $context['twig_template'] ?? null,
  232.                 ] + $parameters,
  233.             );
  234.         } catch (Throwable $t) {
  235.             $message = sprintf(
  236.                 'Error rendering a placeholder "%s" in block with UUID "%s"',
  237.                 $placeholder,
  238.                 $block->getId()->toString(),
  239.             );
  241.             $this->errorHandler->handleError($t, $message);
  242.         }
  244.         return '';
  245.     }
  247.     /**
  248.      * Renders the provided template, with a reduced set of variables from the provided
  249.      * parameters list. Variables included are only those which can be safely printed.
  250.      *
  251.      * @param array<string, mixed> $parameters
  252.      */
  253.     public function renderStringTemplate(string $string, array $parameters = []): string
  254.     {
  255.         try {
  256.             $parameters = iterator_to_array($this->getTemplateVariables($parameters));
  257.             $template = $this->simpleTwig->createTemplate($string);
  259.             return $this->simpleTwig->resolveTemplate($template)->render($parameters);
  260.         } catch (Throwable $t) {
  261.             return '';
  262.         }
  263.     }
  265.     /**
  266.      * Returns the correct view context based on provided Twig context and view context
  267.      * provided through function call.
  268.      *
  269.      * @param array<string, mixed> $context
  270.      */
  271.     private function getViewContext(array $context, ?string $viewContext = null): string
  272.     {
  273.         return $viewContext ?? $context['view_context'] ?? ViewInterface::CONTEXT_DEFAULT;
  274.     }
  276.     /**
  277.      * Returns all safely printable variables: scalars and objects with __toString method.
  278.      *
  279.      * If the context has an instance of ContextualizedTwigTemplate, its context is also
  280.      * included in the output. Any variables from the main context will override variables
  281.      * from ContextualizedTwigTemplate objects.
  282.      *
  283.      * @param array<string, mixed> $parameters
  284.      *
  285.      * @return \Generator<string, mixed>
  286.      */
  287.     private function getTemplateVariables(array $parameters): Generator
  288.     {
  289.         foreach ($parameters as $name => $value) {
  290.             if ($value instanceof ContextualizedTwigTemplate) {
  291.                 yield from $this->getTemplateVariables($value->getContext());
  292.             }
  293.         }
  295.         foreach ($parameters as $name => $value) {
  296.             if ($value instanceof Template || $value instanceof TemplateWrapper) {
  297.                 continue;
  298.             }
  300.             if (is_scalar($value) || (is_object($value) && method_exists($value, '__toString'))) {
  301.                 yield $name => $value;
  302.             }
  303.         }
  304.     }
  305. }