vendor/netzmacht/contao-toolkit/src/Controller/AbstractFragmentController.php line 110

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Netzmacht\Contao\Toolkit\Controller;
  7. use Contao\CoreBundle\Fragment\FragmentOptionsAwareInterface;
  8. use Contao\Model;
  9. use Contao\StringUtil;
  10. use Netzmacht\Contao\Toolkit\Response\ResponseTagger;
  11. use Netzmacht\Contao\Toolkit\Routing\RequestScopeMatcher;
  12. use Netzmacht\Contao\Toolkit\View\Template\TemplateRenderer;
  13. use Symfony\Component\DependencyInjection\Container;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\HttpFoundation\Response;
  17. use function array_pad;
  18. use function array_unshift;
  19. use function implode;
  20. use function is_array;
  21. use function ltrim;
  22. use function sprintf;
  23. use function strpos;
  24. use function strrchr;
  25. use function substr;
  26. use function trim;
  28. /**
  29.  * This class a the base class for the base fragment controller provided by the Toolkit.
  30.  *
  31.  * @template TModel of Model
  32.  */
  33. abstract class AbstractFragmentController implements FragmentOptionsAwareInterface
  34. {
  35.     /**
  36.      * Template renderer.
  37.      *
  38.      * @var TemplateRenderer
  39.      */
  40.     private $templateRenderer;
  42.     /**
  43.      * Request scope matcher.
  44.      *
  45.      * @var RequestScopeMatcher
  46.      */
  47.     protected $scopeMatcher;
  49.     /**
  50.      * The http request response tagger.
  51.      *
  52.      * @var ResponseTagger
  53.      */
  54.     private $responseTagger;
  56.     /**
  57.      * Fragment options.
  58.      *
  59.      * @var array<string,mixed>
  60.      */
  61.     protected $options = [];
  63.     /**
  64.      * @param TemplateRenderer    $templateRenderer The template renderer.
  65.      * @param RequestScopeMatcher $scopeMatcher     The scope matcher.
  66.      * @param ResponseTagger      $responseTagger   The http request response tagger.
  67.      */
  68.     public function __construct(
  69.         TemplateRenderer $templateRenderer,
  70.         RequestScopeMatcher $scopeMatcher,
  71.         ResponseTagger $responseTagger
  72.     ) {
  73.         $this->templateRenderer = $templateRenderer;
  74.         $this->scopeMatcher     = $scopeMatcher;
  75.         $this->responseTagger   = $responseTagger;
  76.     }
  78.     /**
  79.      * Set the fragment options.
  80.      *
  81.      * @param array<string,mixed> $options The fragment options.
  82.      *
  83.      * @psalm-suppress MoreSpecificImplementedParamType
  84.      */
  85.     public function setFragmentOptions(array $options): void
  86.     {
  87.         $this->options = $options;
  88.     }
  90.     /**
  91.      * Generate the response for a fragment.
  92.      *
  93.      * This method executed the preGenerate() and postGenerate() method which might also return a response and intercept
  94.      * the default rendering.
  95.      *
  96.      * @param Request           $request The given request.
  97.      * @param Model             $model   The related model providing the configuration.
  98.      * @param string            $section The section in which the fragment is rendered.
  99.      * @param list<string>|null $classes Additional classes.
  100.      * @psalm-param TModel $model
  101.      */
  102.     protected function generate(Request $request, Model $model, string $section, ?array $classes = null): Response
  103.     {
  104.         $response = $this->preGenerate($request, $model, $section, $classes);
  105.         if ($response !== null) {
  106.             return $response;
  107.         }
  109.         $data     = $this->prepareDefaultTemplateData($model, $section, $classes);
  110.         $data     = $this->prepareTemplateData($data, $request, $model);
  111.         $buffer   = $this->render($this->getTemplateName($model), $data);
  112.         $response = $this->postGenerate($buffer, $data, $request, $model);
  114.         if ($response !== null) {
  115.             return $response;
  116.         }
  118.         $this->tagResponse(sprintf('contao.db.%s.%s', $model::getTable(), $model->id));
  120.         return new Response($buffer);
  121.     }
  123.     /**
  124.      * Prepare the default template data.
  125.      *
  126.      * @param Model             $model   The related model providing the configuration.
  127.      * @param string            $section The section in which the fragment is rendered.
  128.      * @param list<string>|null $classes Additional classes.
  129.      * @psalm-param TModel $model
  130.      *
  131.      * @return array<string,mixed>
  132.      */
  133.     private function prepareDefaultTemplateData(Model $model, string $section, ?array $classes = null): array
  134.     {
  135.         $data    = $model->row();
  136.         $cssID   = array_pad(StringUtil::deserialize($data['cssID'], true), 2, '');
  137.         $classes = $classes ?: [];
  139.         if ($cssID[1] !== '') {
  140.             array_unshift($classes, $cssID[1]);
  141.         }
  143.         $data['inColumn'] = $section;
  144.         $data['cssID']    = $cssID[0] !== '' ? ' id="' . $cssID[0] . '"' : '';
  145.         $data['class']    = trim($this->getTemplateName($model) . ' ' . implode(' ', $classes));
  147.         $headline = StringUtil::deserialize($data['headline']);
  148.         if (is_array($headline)) {
  149.             $data['headline'] = $headline['value'];
  150.             $data['hl']       = $headline['unit'];
  151.         } else {
  152.             $data['headline'] = $headline;
  153.             $data['hl']       = 'h1';
  154.         }
  156.         return $data;
  157.     }
  159.     /**
  160.      * Prepare the template data.
  161.      *
  162.      * The method has to extend the existing data and return the modified one as return value.
  163.      *
  164.      * @param array<string,mixed> $data    The parsed template data.
  165.      * @param Request             $request The current request.
  166.      * @param Model               $model   The model containing the configuration.
  167.      * @psalm-param TModel $model
  168.      *
  169.      * @return array<string,mixed>
  170.      *
  171.      * @SuppressWarnings(PHPMD.UnusedFormalParameter)
  172.      */
  173.     protected function prepareTemplateData(array $data, Request $request, Model $model): array
  174.     {
  175.         return $data;
  176.     }
  178.     /**
  179.      * Pre generate is called first before any logic is called in the generate method.
  180.      *
  181.      * Use it to intercept the default behaviour.
  182.      *
  183.      * @param Request           $request The given request.
  184.      * @param Model             $model   The related model providing the configuration.
  185.      * @param string            $section The section in which the fragment is rendered.
  186.      * @param list<string>|null $classes Additional classes.
  187.      * @psalm-param TModel $model
  188.      *
  189.      * @SuppressWarnings(PHPMD.UnusedFormalParameter)
  190.      */
  191.     protected function preGenerate(Request $request, Model $model, string $section, ?array $classes = null): ?Response
  192.     {
  193.         return null;
  194.     }
  196.     /**
  197.      * Post generate is called after the default rendering is done.
  198.      *
  199.      * Return a custom response if you want to modify the output.
  200.      *
  201.      * @param string              $buffer  The generated output.
  202.      * @param array<string,mixed> $data    The parsed data.
  203.      * @param Request             $request The given request.
  204.      * @param Model               $model   The related model providing the configuration.
  205.      * @psalm-param TModel $model
  206.      *
  207.      * @SuppressWarnings(PHPMD.UnusedFormalParameter)
  208.      */
  209.     protected function postGenerate(string $buffer, array $data, Request $request, Model $model): ?Response
  210.     {
  211.         return null;
  212.     }
  214.     /**
  215.      * Render a template and return the result as string.
  216.      *
  217.      * @param string              $templateName The template name.
  218.      * @param array<string,mixed> $data         The template data.
  219.      */
  220.     protected function render(string $templateName, array $data): string
  221.     {
  222.         if (
  223.             substr($templateName, -5) !== '.twig'
  224.             && strpos($templateName, 'toolkit:') !== 0
  225.             && strpos($templateName, 'fe:') !== 0
  226.             && strpos($templateName, 'be:') !== 0
  227.         ) {
  228.             $templateName = 'fe:' . $templateName;
  229.         }
  231.         return $this->templateRenderer->render($templateName, $data);
  232.     }
  234.     /**
  235.      * Render a template and return the result as response.
  236.      *
  237.      * @param string              $templateName The template name.
  238.      * @param array<string,mixed> $data         The template data.
  239.      */
  240.     protected function renderResponse(string $templateName, array $data): Response
  241.     {
  242.         return new Response($this->render($templateName, $data));
  243.     }
  245.     /**
  246.      * Get the template name from the fragment options and or the provided model.
  247.      *
  248.      * @param Model $model The model containing the fragment configuration.
  249.      * @psalm-param TModel $model
  250.      */
  251.     protected function getTemplateName(Model $model): string
  252.     {
  253.         if ($model->customTpl && ! $this->scopeMatcher->isBackendRequest()) {
  254.             return $model->customTpl;
  255.         }
  257.         if (isset($this->options['template'])) {
  258.             return $this->options['template'];
  259.         }
  261.         return $this->getFallbackTemplateName($model);
  262.     }
  264.     /**
  265.      * Get the type of the fragment.
  266.      */
  267.     protected function getType(): string
  268.     {
  269.         if (isset($this->options['type'])) {
  270.             return $this->options['type'];
  271.         }
  273.         $className = ltrim(strrchr(static::class, '\\'), '\\');
  275.         if (substr($className, -10) === 'Controller') {
  276.             $className = substr($className, 0, -10);
  277.         }
  279.         return Container::underscore($className);
  280.     }
  282.     /**
  283.      * Check if the request is a backend request.
  284.      *
  285.      * @param Request $request The current request.
  286.      */
  287.     protected function isBackendRequest(Request $request): bool
  288.     {
  289.         return $this->scopeMatcher->isBackendRequest($request);
  290.     }
  292.     /**
  293.      * Get the fallback template name.
  294.      *
  295.      * @param Model $model The model containing the fragment configuration.
  296.      * @psalm-param TModel $model
  297.      */
  298.     abstract protected function getFallbackTemplateName(Model $model): string;
  300.     /**
  301.      * Tag the current response.
  302.      *
  303.      * @param string ...$tags The list of tags.
  304.      */
  305.     protected function tagResponse(string ...$tags): void
  306.     {
  307.         $this->responseTagger->addTags($tags);
  308.     }
  309. }