vendor/sulu/sulu/src/Sulu/Bundle/WebsiteBundle/Controller/WebsiteController.php line 39

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Bundle\WebsiteBundle\Controller;
  14. use Sulu\Bundle\HttpCacheBundle\CacheLifetime\CacheLifetimeEnhancerInterface;
  15. use Sulu\Bundle\PreviewBundle\Preview\Preview;
  16. use Sulu\Bundle\WebsiteBundle\Resolver\ParameterResolverInterface;
  17. use Sulu\Component\Content\Compat\StructureInterface;
  18. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\HttpKernel\Exception\HttpException;
  24. /**
  25.  * Basic class to render Website from phpcr content.
  26.  */
  27. abstract class WebsiteController extends AbstractController
  28. {
  29.     /**
  30.      * Returns a rendered structure.
  31.      *
  32.      * @param StructureInterface $structure The structure, which has been loaded for rendering
  33.      * @param array $attributes Additional attributes, which will be passed to twig
  34.      * @param bool $preview Defines if the site is rendered in preview mode
  35.      * @param bool $partial Defines if only the content block of the template should be rendered
  36.      *
  37.      * @return Response
  38.      */
  39.     protected function renderStructure(
  40.         StructureInterface $structure,
  41.         $attributes = [],
  42.         $preview = false,
  43.         $partial = false
  44.     ) {
  45.         /** @var Request $request */
  46.         $request = $this->getRequest();
  48.         // extract format twig file
  49.         if (!$preview) {
  50.             $requestFormat = $request->getRequestFormat();
  51.         } else {
  52.             $requestFormat = 'html';
  53.         }
  55.         $viewTemplate = $structure->getView() . '.' . $requestFormat . '.twig';
  57.         if (!$this->container->get('twig')->getLoader()->exists($viewTemplate)) {
  58.             throw new HttpException(
  59.                 406,
  60.                 \sprintf('Page does not exist in "%s" format.', $requestFormat)
  61.             );
  62.         }
  64.         // get attributes to render template
  65.         $data = $this->getAttributes($attributes, $structure, $preview);
  67.         // if partial render only content block else full page
  68.         if ($partial) {
  69.             $content = $this->renderBlock(
  70.                 $viewTemplate,
  71.                 'content',
  72.                 $data
  73.             );
  74.         } elseif ($preview) {
  75.             $content = $this->renderPreview(
  76.                 $viewTemplate,
  77.                 $data
  78.             );
  79.         } else {
  80.             $content = $this->renderView(
  81.                 $viewTemplate,
  82.                 $data
  83.             );
  84.         }
  86.         $response = new Response($content);
  88.         // we need to set the content type ourselves here
  89.         // else symfony will use the accept header of the client and the page could be cached with false content-type
  90.         // see following symfony issue: https://github.com/symfony/symfony/issues/35694
  91.         $mimeType = $request->getMimeType($requestFormat);
  93.         if ($mimeType) {
  94.             $response->headers->set('Content-Type', $mimeType);
  95.         }
  97.         if (!$preview && $this->getCacheTimeLifeEnhancer()) {
  98.             $this->getCacheTimeLifeEnhancer()->enhance($response, $structure);
  99.         }
  101.         return $response;
  102.     }
  104.     /**
  105.      * Generates attributes.
  106.      *
  107.      * @param mixed[] $attributes
  108.      * @param bool $preview
  109.      *
  110.      * @return mixed[]
  111.      */
  112.     protected function getAttributes($attributes, StructureInterface $structure = null, $preview = false)
  113.     {
  114.         return $this->container->get('sulu_website.resolver.parameter')->resolve(
  115.             $attributes,
  116.             $this->container->get('sulu_core.webspace.request_analyzer'),
  117.             $structure,
  118.             $preview
  119.         );
  120.     }
  122.     /**
  123.      * Returns rendered part of template specified by block.
  124.      */
  125.     protected function renderBlock($template, $block, $attributes = [])
  126.     {
  127.         $twig = $this->container->get('twig');
  128.         $attributes = $twig->mergeGlobals($attributes);
  130.         $template = $twig->load($template);
  132.         $level = \ob_get_level();
  133.         \ob_start();
  135.         try {
  136.             $rendered = $template->renderBlock($block, $attributes);
  137.             \ob_end_clean();
  139.             return $rendered;
  140.         } catch (\Exception $e) {
  141.             while (\ob_get_level() > $level) {
  142.                 \ob_end_clean();
  143.             }
  145.             throw $e;
  146.         }
  147.     }
  149.     protected function renderPreview(string $view, array $parameters = []): string
  150.     {
  151.         $parameters['previewParentTemplate'] = $view;
  152.         $parameters['previewContentReplacer'] = Preview::CONTENT_REPLACER;
  154.         return parent::renderView('@SuluWebsite/Preview/preview.html.twig', $parameters);
  155.     }
  157.     /**
  158.      * Returns the current request from the request stack.
  159.      *
  160.      * @return Request
  161.      *
  162.      * @deprecated will be remove with 2.0
  163.      */
  164.     public function getRequest()
  165.     {
  166.         return $this->container->get('request_stack')->getCurrentRequest();
  167.     }
  169.     protected function getCacheTimeLifeEnhancer(): ?CacheLifetimeEnhancerInterface
  170.     {
  171.         if (!$this->container->has('sulu_http_cache.cache_lifetime.enhancer')) {
  172.             return null;
  173.         }
  175.         /** @var CacheLifetimeEnhancerInterface $cacheLifetimeEnhancer */
  176.         $cacheLifetimeEnhancer = $this->container->get('sulu_http_cache.cache_lifetime.enhancer');
  178.         return $cacheLifetimeEnhancer;
  179.     }
  181.     public static function getSubscribedServices(): array
  182.     {
  183.         $subscribedServices = parent::getSubscribedServices();
  184.         $subscribedServices['sulu_website.resolver.parameter'] = ParameterResolverInterface::class;
  185.         $subscribedServices['sulu_core.webspace.request_analyzer'] = RequestAnalyzerInterface::class;
  186.         $subscribedServices['sulu_http_cache.cache_lifetime.enhancer'] = '?' . CacheLifetimeEnhancerInterface::class;
  188.         return $subscribedServices;
  189.     }
  190. }