vendor/contao/core-bundle/src/Resources/contao/library/Contao/Controller.php line 393

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Contao\CoreBundle\Asset\ContaoContext;
  14. use Contao\CoreBundle\Exception\AccessDeniedException;
  15. use Contao\CoreBundle\Exception\AjaxRedirectResponseException;
  16. use Contao\CoreBundle\Exception\PageNotFoundException;
  17. use Contao\CoreBundle\Exception\RedirectResponseException;
  18. use Contao\CoreBundle\File\Metadata;
  19. use Contao\CoreBundle\Framework\ContaoFramework;
  20. use Contao\CoreBundle\Routing\Page\PageRoute;
  21. use Contao\CoreBundle\Security\ContaoCorePermissions;
  22. use Contao\CoreBundle\Twig\Inheritance\TemplateHierarchyInterface;
  23. use Contao\CoreBundle\Util\LocaleUtil;
  24. use Contao\Database\Result;
  25. use Contao\Image\PictureConfiguration;
  26. use Contao\Model\Collection;
  27. use Imagine\Image\BoxInterface;
  28. use Symfony\Cmf\Component\Routing\RouteObjectInterface;
  29. use Symfony\Component\Finder\Finder;
  30. use Symfony\Component\Finder\Glob;
  32. /**
  33.  * Abstract parent class for Controllers
  34.  *
  35.  * Some of the methods have been made static in Contao 3 and can be used in
  36.  * non-object context as well.
  37.  *
  38.  * Usage:
  39.  *
  40.  *     echo Controller::getTheme();
  41.  *
  42.  * Inside a controller:
  43.  *
  44.  *     public function generate()
  45.  *     {
  46.  *         return $this->getArticle(2);
  47.  *     }
  48.  */
  49. abstract class Controller extends System
  50. {
  51.     /**
  52.      * @var Template
  53.      *
  54.      * @todo: Add in Contao 5.0
  55.      */
  56.     //protected $Template;
  58.     /**
  59.      * @var array
  60.      */
  61.     protected static $arrQueryCache = array();
  63.     /**
  64.      * @var array
  65.      */
  66.     private static $arrOldBePathCache = array();
  68.     /**
  69.      * Find a particular template file and return its path
  70.      *
  71.      * @param string $strTemplate The name of the template
  72.      *
  73.      * @return string The path to the template file
  74.      *
  75.      * @throws \RuntimeException If the template group folder is insecure
  76.      */
  77.     public static function getTemplate($strTemplate)
  78.     {
  79.         $strTemplate = basename($strTemplate);
  80.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  82.         // Check for a theme folder
  83.         if ($request && System::getContainer()->get('contao.routing.scope_matcher')->isFrontendRequest($request))
  84.         {
  85.             /** @var PageModel|null $objPage */
  86.             global $objPage;
  88.             if ($objPage->templateGroup ?? null)
  89.             {
  90.                 if (Validator::isInsecurePath($objPage->templateGroup))
  91.                 {
  92.                     throw new \RuntimeException('Invalid path ' . $objPage->templateGroup);
  93.                 }
  95.                 return TemplateLoader::getPath($strTemplate, 'html5', $objPage->templateGroup);
  96.             }
  97.         }
  99.         return TemplateLoader::getPath($strTemplate, 'html5');
  100.     }
  102.     /**
  103.      * Return all template files of a particular group as array
  104.      *
  105.      * @param string $strPrefix           The template name prefix (e.g. "ce_")
  106.      * @param array  $arrAdditionalMapper An additional mapper array
  107.      * @param string $strDefaultTemplate  An optional default template
  108.      *
  109.      * @return array An array of template names
  110.      */
  111.     public static function getTemplateGroup($strPrefix, array $arrAdditionalMapper=array(), $strDefaultTemplate='')
  112.     {
  113.         if (str_contains($strPrefix, '/') || str_contains($strDefaultTemplate, '/'))
  114.         {
  115.             throw new \InvalidArgumentException(sprintf('Using %s() with modern fragment templates is not supported. Use the "contao.twig.finder_factory" service instead.', __METHOD__));
  116.         }
  118.         $arrTemplates = array();
  119.         $arrBundleTemplates = array();
  121.         $arrMapper = array_merge
  122.         (
  123.             $arrAdditionalMapper,
  124.             array
  125.             (
  126.                 'ce' => array_keys(array_merge(...array_values($GLOBALS['TL_CTE']))),
  127.                 'form' => array_keys($GLOBALS['TL_FFL']),
  128.                 'mod' => array_keys(array_merge(...array_values($GLOBALS['FE_MOD']))),
  129.             )
  130.         );
  132.         // Add templates that are not directly associated with a form field
  133.         $arrMapper['form'][] = 'row';
  134.         $arrMapper['form'][] = 'row_double';
  135.         $arrMapper['form'][] = 'xml';
  136.         $arrMapper['form'][] = 'wrapper';
  137.         $arrMapper['form'][] = 'message';
  138.         $arrMapper['form'][] = 'textfield'; // TODO: remove in Contao 5.0
  140.         // Add templates that are not directly associated with a module
  141.         $arrMapper['mod'][] = 'article';
  142.         $arrMapper['mod'][] = 'message';
  143.         $arrMapper['mod'][] = 'password'; // TODO: remove in Contao 5.0
  144.         $arrMapper['mod'][] = 'comment_form'; // TODO: remove in Contao 5.0
  145.         $arrMapper['mod'][] = 'newsletter'; // TODO: remove in Contao 5.0
  147.         /** @var TemplateHierarchyInterface $templateHierarchy */
  148.         $templateHierarchy = System::getContainer()->get('contao.twig.filesystem_loader');
  149.         $identifierPattern = sprintf('/^%s%s/', preg_quote($strPrefix, '/'), substr($strPrefix, -1) !== '_' ? '($|_)' : '');
  151.         $prefixedFiles = array_merge(
  152.             array_filter(
  153.                 array_keys($templateHierarchy->getInheritanceChains()),
  154.                 static fn (string $identifier): bool => 1 === preg_match($identifierPattern, $identifier),
  155.             ),
  156.             // Merge with the templates from the TemplateLoader for backwards
  157.             // compatibility in case someone has added templates manually
  158.             TemplateLoader::getPrefixedFiles($strPrefix),
  159.         );
  161.         foreach ($prefixedFiles as $strTemplate)
  162.         {
  163.             if ($strTemplate != $strPrefix)
  164.             {
  165.                 list($k, $strKey) = explode('_', $strTemplate, 2);
  167.                 if (isset($arrMapper[$k]) && \in_array($strKey, $arrMapper[$k]))
  168.                 {
  169.                     $arrBundleTemplates[] = $strTemplate;
  170.                     continue;
  171.                 }
  172.             }
  174.             $arrTemplates[$strTemplate][] = 'root';
  175.         }
  177.         $strGlobPrefix = $strPrefix;
  179.         // Backwards compatibility (see #725)
  180.         if (substr($strGlobPrefix, -1) == '_')
  181.         {
  182.             $strGlobPrefix = substr($strGlobPrefix, 0, -1) . '[_-]';
  183.         }
  185.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  186.         $arrCustomized = self::braceGlob($projectDir . '/templates/' . $strGlobPrefix . '*.html5');
  188.         // Add the customized templates
  189.         if (!empty($arrCustomized) && \is_array($arrCustomized))
  190.         {
  191.             $blnIsGroupPrefix = preg_match('/^[a-z]+_$/', $strPrefix);
  193.             foreach ($arrCustomized as $strFile)
  194.             {
  195.                 $strTemplate = basename($strFile, strrchr($strFile, '.'));
  196.                 $legacyPrefix = substr($strPrefix, 0, -1) . '-';
  198.                 if (str_starts_with($strTemplate, $legacyPrefix))
  199.                 {
  200.                     trigger_deprecation('contao/core-bundle', '4.9', 'The template "' . $strTemplate . '.html5" uses a deprecated name that will no longer work in Contao 5.0. Name it "' . str_replace($legacyPrefix, $strPrefix, $strTemplate) . '.html5" instead.');
  201.                 }
  203.                 // Ignore bundle templates, e.g. mod_article and mod_article_list
  204.                 if (\in_array($strTemplate, $arrBundleTemplates))
  205.                 {
  206.                     continue;
  207.                 }
  209.                 // Also ignore custom templates belonging to a different bundle template,
  210.                 // e.g. mod_article and mod_article_list_custom
  211.                 if (!$blnIsGroupPrefix)
  212.                 {
  213.                     foreach ($arrBundleTemplates as $strKey)
  214.                     {
  215.                         if (strpos($strTemplate, $strKey . '_') === 0)
  216.                         {
  217.                             continue 2;
  218.                         }
  219.                     }
  220.                 }
  222.                 $arrTemplates[$strTemplate][] = $GLOBALS['TL_LANG']['MSC']['global'] ?? 'global';
  223.             }
  224.         }
  226.         $arrDefaultPlaces = array();
  228.         if ($strDefaultTemplate)
  229.         {
  230.             $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['default'];
  232.             if (file_exists($projectDir . '/templates/' . $strDefaultTemplate . '.html5'))
  233.             {
  234.                 $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['global'];
  235.             }
  236.         }
  238.         // Do not look for back end templates in theme folders (see #5379)
  239.         if ($strPrefix != 'be_' && $strPrefix != 'mail_')
  240.         {
  241.             // Try to select the themes (see #5210)
  242.             try
  243.             {
  244.                 $objTheme = ThemeModel::findAll(array('order'=>'name'));
  245.             }
  246.             catch (\Throwable $e)
  247.             {
  248.                 $objTheme = null;
  249.             }
  251.             // Add the theme templates
  252.             if ($objTheme !== null)
  253.             {
  254.                 while ($objTheme->next())
  255.                 {
  256.                     if (!$objTheme->templates)
  257.                     {
  258.                         continue;
  259.                     }
  261.                     if ($strDefaultTemplate && file_exists($projectDir . '/' . $objTheme->templates . '/' . $strDefaultTemplate . '.html5'))
  262.                     {
  263.                         $arrDefaultPlaces[] = $objTheme->name;
  264.                     }
  266.                     $arrThemeTemplates = self::braceGlob($projectDir . '/' . $objTheme->templates . '/' . $strGlobPrefix . '*.html5');
  268.                     if (!empty($arrThemeTemplates) && \is_array($arrThemeTemplates))
  269.                     {
  270.                         foreach ($arrThemeTemplates as $strFile)
  271.                         {
  272.                             $strTemplate = basename($strFile, strrchr($strFile, '.'));
  273.                             $arrTemplates[$strTemplate][] = $objTheme->name;
  274.                         }
  275.                     }
  276.                 }
  277.             }
  278.         }
  280.         // Show the template sources (see #6875)
  281.         foreach ($arrTemplates as $k=>$v)
  282.         {
  283.             $v = array_filter($v, static function ($a)
  284.             {
  285.                 return $a != 'root';
  286.             });
  288.             if (empty($v))
  289.             {
  290.                 $arrTemplates[$k] = $k;
  291.             }
  292.             else
  293.             {
  294.                 $arrTemplates[$k] = $k . ' (' . implode(', ', $v) . ')';
  295.             }
  296.         }
  298.         // Sort the template names
  299.         ksort($arrTemplates);
  301.         if ($strDefaultTemplate)
  302.         {
  303.             if (!empty($arrDefaultPlaces))
  304.             {
  305.                 $strDefaultTemplate .= ' (' . implode(', ', $arrDefaultPlaces) . ')';
  306.             }
  308.             $arrTemplates = array('' => $strDefaultTemplate) + $arrTemplates;
  309.         }
  311.         return $arrTemplates;
  312.     }
  314.     /**
  315.      * Generate a front end module and return it as string
  316.      *
  317.      * @param mixed  $intId     A module ID or a Model object
  318.      * @param string $strColumn The name of the column
  319.      *
  320.      * @return string The module HTML markup
  321.      */
  322.     public static function getFrontendModule($intId, $strColumn='main')
  323.     {
  324.         if (!\is_object($intId) && !\strlen($intId))
  325.         {
  326.             return '';
  327.         }
  329.         /** @var PageModel $objPage */
  330.         global $objPage;
  332.         // Articles
  333.         if (!\is_object($intId) && $intId == 0)
  334.         {
  335.             // Show a particular article only
  336.             if ($objPage->type == 'regular' && Input::get('articles'))
  337.             {
  338.                 list($strSection, $strArticle) = explode(':', Input::get('articles')) + array(null, null);
  340.                 if ($strArticle === null)
  341.                 {
  342.                     $strArticle = $strSection;
  343.                     $strSection = 'main';
  344.                 }
  346.                 if ($strSection == $strColumn)
  347.                 {
  348.                     $objArticle = ArticleModel::findPublishedByIdOrAliasAndPid($strArticle, $objPage->id);
  350.                     // Send a 404 header if there is no published article
  351.                     if (null === $objArticle)
  352.                     {
  353.                         throw new PageNotFoundException('Page not found: ' . Environment::get('uri'));
  354.                     }
  356.                     // Send a 403 header if the article cannot be accessed
  357.                     if (!static::isVisibleElement($objArticle))
  358.                     {
  359.                         throw new AccessDeniedException('Access denied: ' . Environment::get('uri'));
  360.                     }
  362.                     return static::getArticle($objArticle);
  363.                 }
  364.             }
  366.             // HOOK: add custom logic
  367.             if (isset($GLOBALS['TL_HOOKS']['getArticles']) && \is_array($GLOBALS['TL_HOOKS']['getArticles']))
  368.             {
  369.                 foreach ($GLOBALS['TL_HOOKS']['getArticles'] as $callback)
  370.                 {
  371.                     $return = static::importStatic($callback[0])->{$callback[1]}($objPage->id, $strColumn);
  373.                     if (\is_string($return))
  374.                     {
  375.                         return $return;
  376.                     }
  377.                 }
  378.             }
  380.             // Show all articles (no else block here, see #4740)
  381.             $objArticles = ArticleModel::findPublishedByPidAndColumn($objPage->id, $strColumn);
  383.             if ($objArticles === null)
  384.             {
  385.                 return '';
  386.             }
  388.             $return = '';
  389.             $blnMultiMode = ($objArticles->count() > 1);
  391.             while ($objArticles->next())
  392.             {
  393.                 $return .= static::getArticle($objArticles->current(), $blnMultiMode, false, $strColumn);
  394.             }
  396.             return $return;
  397.         }
  399.         // Other modules
  400.         if (\is_object($intId))
  401.         {
  402.             $objRow = $intId;
  403.         }
  404.         else
  405.         {
  406.             $objRow = ModuleModel::findByPk($intId);
  408.             if ($objRow === null)
  409.             {
  410.                 return '';
  411.             }
  412.         }
  414.         // Check the visibility (see #6311)
  415.         if (!static::isVisibleElement($objRow))
  416.         {
  417.             return '';
  418.         }
  420.         $strClass = Module::findClass($objRow->type);
  422.         // Return if the class does not exist
  423.         if (!class_exists($strClass))
  424.         {
  425.             System::getContainer()->get('monolog.logger.contao.error')->error('Module class "' . $strClass . '" (module "' . $objRow->type . '") does not exist');
  427.             return '';
  428.         }
  430.         $strStopWatchId = 'contao.frontend_module.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  432.         if (System::getContainer()->getParameter('kernel.debug') && System::getContainer()->has('debug.stopwatch'))
  433.         {
  434.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  435.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  436.         }
  438.         $objRow->typePrefix = 'mod_';
  440.         /** @var Module $objModule */
  441.         $objModule = new $strClass($objRow, $strColumn);
  442.         $strBuffer = $objModule->generate();
  444.         // HOOK: add custom logic
  445.         if (isset($GLOBALS['TL_HOOKS']['getFrontendModule']) && \is_array($GLOBALS['TL_HOOKS']['getFrontendModule']))
  446.         {
  447.             foreach ($GLOBALS['TL_HOOKS']['getFrontendModule'] as $callback)
  448.             {
  449.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objModule);
  450.             }
  451.         }
  453.         // Disable indexing if protected
  454.         if ($objModule->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  455.         {
  456.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  457.         }
  459.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  460.         {
  461.             $objStopwatch->stop($strStopWatchId);
  462.         }
  464.         return $strBuffer;
  465.     }
  467.     /**
  468.      * Generate an article and return it as string
  469.      *
  470.      * @param mixed   $varId          The article ID or a Model object
  471.      * @param boolean $blnMultiMode   If true, only teasers will be shown
  472.      * @param boolean $blnIsInsertTag If true, there will be no page relation
  473.      * @param string  $strColumn      The name of the column
  474.      *
  475.      * @return string|boolean The article HTML markup or false
  476.      */
  477.     public static function getArticle($varId, $blnMultiMode=false, $blnIsInsertTag=false, $strColumn='main')
  478.     {
  479.         /** @var PageModel $objPage */
  480.         global $objPage;
  482.         if (\is_object($varId))
  483.         {
  484.             $objRow = $varId;
  485.         }
  486.         else
  487.         {
  488.             if (!$varId)
  489.             {
  490.                 return '';
  491.             }
  493.             $objRow = ArticleModel::findByIdOrAliasAndPid($varId, (!$blnIsInsertTag ? $objPage->id : null));
  495.             if ($objRow === null)
  496.             {
  497.                 return false;
  498.             }
  499.         }
  501.         // Check the visibility (see #6311)
  502.         if (!static::isVisibleElement($objRow))
  503.         {
  504.             return '';
  505.         }
  507.         // Print the article as PDF
  508.         if (isset($_GET['pdf']) && Input::get('pdf') == $objRow->id)
  509.         {
  510.             // Deprecated since Contao 4.0, to be removed in Contao 5.0
  511.             if ($objRow->printable == 1)
  512.             {
  513.                 trigger_deprecation('contao/core-bundle', '4.0', 'Setting tl_article.printable to "1" has been deprecated and will no longer work in Contao 5.0.');
  515.                 $objArticle = new ModuleArticle($objRow);
  516.                 $objArticle->generatePdf();
  517.             }
  518.             elseif ($objRow->printable)
  519.             {
  520.                 $options = StringUtil::deserialize($objRow->printable);
  522.                 if (\is_array($options) && \in_array('pdf', $options))
  523.                 {
  524.                     $objArticle = new ModuleArticle($objRow);
  525.                     $objArticle->generatePdf();
  526.                 }
  527.             }
  528.         }
  530.         $objRow->headline = $objRow->title;
  531.         $objRow->multiMode = $blnMultiMode;
  533.         // HOOK: add custom logic
  534.         if (isset($GLOBALS['TL_HOOKS']['getArticle']) && \is_array($GLOBALS['TL_HOOKS']['getArticle']))
  535.         {
  536.             foreach ($GLOBALS['TL_HOOKS']['getArticle'] as $callback)
  537.             {
  538.                 static::importStatic($callback[0])->{$callback[1]}($objRow);
  539.             }
  540.         }
  542.         $strStopWatchId = 'contao.article (ID ' . $objRow->id . ')';
  544.         if (System::getContainer()->getParameter('kernel.debug') && System::getContainer()->has('debug.stopwatch'))
  545.         {
  546.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  547.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  548.         }
  550.         $objArticle = new ModuleArticle($objRow, $strColumn);
  551.         $strBuffer = $objArticle->generate($blnIsInsertTag);
  553.         // Disable indexing if protected
  554.         if ($objArticle->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  555.         {
  556.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  557.         }
  559.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  560.         {
  561.             $objStopwatch->stop($strStopWatchId);
  562.         }
  564.         return $strBuffer;
  565.     }
  567.     /**
  568.      * Generate a content element and return it as string
  569.      *
  570.      * @param mixed  $intId     A content element ID or a Model object
  571.      * @param string $strColumn The column the element is in
  572.      *
  573.      * @return string The content element HTML markup
  574.      */
  575.     public static function getContentElement($intId, $strColumn='main')
  576.     {
  577.         if (\is_object($intId))
  578.         {
  579.             $objRow = $intId;
  580.         }
  581.         else
  582.         {
  583.             if ($intId < 1 || !\strlen($intId))
  584.             {
  585.                 return '';
  586.             }
  588.             $objRow = ContentModel::findByPk($intId);
  590.             if ($objRow === null)
  591.             {
  592.                 return '';
  593.             }
  594.         }
  596.         // Check the visibility (see #6311)
  597.         if (!static::isVisibleElement($objRow))
  598.         {
  599.             return '';
  600.         }
  602.         $strClass = ContentElement::findClass($objRow->type);
  604.         // Return if the class does not exist
  605.         if (!class_exists($strClass))
  606.         {
  607.             System::getContainer()->get('monolog.logger.contao.error')->error('Content element class "' . $strClass . '" (content element "' . $objRow->type . '") does not exist');
  609.             return '';
  610.         }
  612.         $objRow->typePrefix = 'ce_';
  613.         $strStopWatchId = 'contao.content_element.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  615.         if ($objRow->type != 'module' && System::getContainer()->getParameter('kernel.debug') && System::getContainer()->has('debug.stopwatch'))
  616.         {
  617.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  618.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  619.         }
  621.         /** @var ContentElement $objElement */
  622.         $objElement = new $strClass($objRow, $strColumn);
  623.         $strBuffer = $objElement->generate();
  625.         // HOOK: add custom logic
  626.         if (isset($GLOBALS['TL_HOOKS']['getContentElement']) && \is_array($GLOBALS['TL_HOOKS']['getContentElement']))
  627.         {
  628.             foreach ($GLOBALS['TL_HOOKS']['getContentElement'] as $callback)
  629.             {
  630.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  631.             }
  632.         }
  634.         // Disable indexing if protected
  635.         if ($objElement->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  636.         {
  637.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  638.         }
  640.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  641.         {
  642.             $objStopwatch->stop($strStopWatchId);
  643.         }
  645.         return $strBuffer;
  646.     }
  648.     /**
  649.      * Generate a form and return it as string
  650.      *
  651.      * @param mixed   $varId     A form ID or a Model object
  652.      * @param string  $strColumn The column the form is in
  653.      * @param boolean $blnModule Render the form as module
  654.      *
  655.      * @return string The form HTML markup
  656.      */
  657.     public static function getForm($varId, $strColumn='main', $blnModule=false)
  658.     {
  659.         if (\is_object($varId))
  660.         {
  661.             $objRow = $varId;
  662.         }
  663.         else
  664.         {
  665.             if (!$varId)
  666.             {
  667.                 return '';
  668.             }
  670.             $objRow = FormModel::findByIdOrAlias($varId);
  672.             if ($objRow === null)
  673.             {
  674.                 return '';
  675.             }
  676.         }
  678.         $strClass = $blnModule ? Module::findClass('form') : ContentElement::findClass('form');
  680.         if (!class_exists($strClass))
  681.         {
  682.             System::getContainer()->get('monolog.logger.contao.error')->error('Form class "' . $strClass . '" does not exist');
  684.             return '';
  685.         }
  687.         $objRow->typePrefix = $blnModule ? 'mod_' : 'ce_';
  688.         $objRow->form = $objRow->id;
  690.         /** @var Form $objElement */
  691.         $objElement = new $strClass($objRow, $strColumn);
  692.         $strBuffer = $objElement->generate();
  694.         // HOOK: add custom logic
  695.         if (isset($GLOBALS['TL_HOOKS']['getForm']) && \is_array($GLOBALS['TL_HOOKS']['getForm']))
  696.         {
  697.             foreach ($GLOBALS['TL_HOOKS']['getForm'] as $callback)
  698.             {
  699.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  700.             }
  701.         }
  703.         return $strBuffer;
  704.     }
  706.     /**
  707.      * Return the languages for the TinyMCE spellchecker
  708.      *
  709.      * @return string The TinyMCE spellchecker language string
  710.      *
  711.      * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  712.      */
  713.     protected function getSpellcheckerString()
  714.     {
  715.         trigger_deprecation('contao/core-bundle', '4.13', 'Using "%s()" has been deprecated and will no longer work in Contao 5.0.', __METHOD__);
  717.         System::loadLanguageFile('languages');
  719.         $return = array();
  720.         $langs = Folder::scan(__DIR__ . '/../../languages');
  721.         array_unshift($langs, $GLOBALS['TL_LANGUAGE']);
  723.         foreach ($langs as $lang)
  724.         {
  725.             $lang = substr($lang, 0, 2);
  727.             if (isset($GLOBALS['TL_LANG']['LNG'][$lang]))
  728.             {
  729.                 $return[$lang] = $GLOBALS['TL_LANG']['LNG'][$lang] . '=' . $lang;
  730.             }
  731.         }
  733.         return '+' . implode(',', array_unique($return));
  734.     }
  736.     /**
  737.      * Calculate the page status icon name based on the page parameters
  738.      *
  739.      * @param PageModel|Result|\stdClass $objPage The page object
  740.      *
  741.      * @return string The status icon name
  742.      */
  743.     public static function getPageStatusIcon($objPage)
  744.     {
  745.         $sub = 0;
  746.         $type = \in_array($objPage->type, array('regular', 'root', 'forward', 'redirect', 'error_401', 'error_403', 'error_404', 'error_503'), true) ? $objPage->type : 'regular';
  747.         $image = $type . '.svg';
  749.         // Page not published or not active
  750.         if (!$objPage->published || ($objPage->start && $objPage->start > time()) || ($objPage->stop && $objPage->stop <= time()))
  751.         {
  752.             ++$sub;
  753.         }
  755.         // Page hidden from menu
  756.         if ($objPage->hide && !\in_array($type, array('root', 'error_401', 'error_403', 'error_404', 'error_503')))
  757.         {
  758.             $sub += 2;
  759.         }
  761.         // Page protected
  762.         if ($objPage->protected && !\in_array($type, array('root', 'error_401', 'error_403', 'error_404', 'error_503')))
  763.         {
  764.             $sub += 4;
  765.         }
  767.         // Change icon if root page is published and in maintenance mode
  768.         if ($sub == 0 && $objPage->type == 'root' && $objPage->maintenanceMode)
  769.         {
  770.             $sub = 2;
  771.         }
  773.         // Get the image name
  774.         if ($sub > 0)
  775.         {
  776.             $image = $type . '_' . $sub . '.svg';
  777.         }
  779.         // HOOK: add custom logic
  780.         if (isset($GLOBALS['TL_HOOKS']['getPageStatusIcon']) && \is_array($GLOBALS['TL_HOOKS']['getPageStatusIcon']))
  781.         {
  782.             foreach ($GLOBALS['TL_HOOKS']['getPageStatusIcon'] as $callback)
  783.             {
  784.                 $image = static::importStatic($callback[0])->{$callback[1]}($objPage, $image);
  785.             }
  786.         }
  788.         return $image;
  789.     }
  791.     /**
  792.      * Check whether an element is visible in the front end
  793.      *
  794.      * @param Model|ContentModel|ModuleModel $objElement The element model
  795.      *
  796.      * @return boolean True if the element is visible
  797.      */
  798.     public static function isVisibleElement(Model $objElement)
  799.     {
  800.         $blnReturn = true;
  802.         // Only apply the restrictions in the front end
  803.         if (TL_MODE == 'FE')
  804.         {
  805.             $security = System::getContainer()->get('security.helper');
  807.             if ($objElement->protected)
  808.             {
  809.                 $groups = StringUtil::deserialize($objElement->groups, true);
  810.                 $blnReturn = $security->isGranted(ContaoCorePermissions::MEMBER_IN_GROUPS, $groups);
  811.             }
  812.             elseif ($objElement->guests)
  813.             {
  814.                 trigger_deprecation('contao/core-bundle', '4.12', 'Using the "show to guests only" feature has been deprecated an will no longer work in Contao 5.0. Use the "protect page" function instead.');
  815.                 $blnReturn = !$security->isGranted('ROLE_MEMBER'); // backwards compatibility
  816.             }
  817.         }
  819.         // HOOK: add custom logic
  820.         if (isset($GLOBALS['TL_HOOKS']['isVisibleElement']) && \is_array($GLOBALS['TL_HOOKS']['isVisibleElement']))
  821.         {
  822.             foreach ($GLOBALS['TL_HOOKS']['isVisibleElement'] as $callback)
  823.             {
  824.                 $blnReturn = static::importStatic($callback[0])->{$callback[1]}($objElement, $blnReturn);
  825.             }
  826.         }
  828.         return $blnReturn;
  829.     }
  831.     /**
  832.      * Replace insert tags with their values
  833.      *
  834.      * @param string  $strBuffer The text with the tags to be replaced
  835.      * @param boolean $blnCache  If false, non-cacheable tags will be replaced
  836.      *
  837.      * @return string The text with the replaced tags
  838.      *
  839.      * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  840.      *             Use the InsertTagParser service instead.
  841.      */
  842.     public static function replaceInsertTags($strBuffer, $blnCache=true)
  843.     {
  844.         trigger_deprecation('contao/core-bundle', '4.13', 'Using "%s()" has been deprecated and will no longer work in Contao 5.0. Use the InsertTagParser service instead.', __METHOD__);
  846.         $parser = System::getContainer()->get('contao.insert_tag.parser');
  848.         if ($blnCache)
  849.         {
  850.             return $parser->replace((string) $strBuffer);
  851.         }
  853.         return $parser->replaceInline((string) $strBuffer);
  854.     }
  856.     /**
  857.      * Replace the dynamic script tags (see #4203)
  858.      *
  859.      * @param string $strBuffer The string with the tags to be replaced
  860.      *
  861.      * @return string The string with the replaced tags
  862.      */
  863.     public static function replaceDynamicScriptTags($strBuffer)
  864.     {
  865.         // HOOK: add custom logic
  866.         if (isset($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']) && \is_array($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']))
  867.         {
  868.             foreach ($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags'] as $callback)
  869.             {
  870.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($strBuffer);
  871.             }
  872.         }
  874.         $arrReplace = array();
  875.         $strScripts = '';
  877.         // Add the internal jQuery scripts
  878.         if (!empty($GLOBALS['TL_JQUERY']) && \is_array($GLOBALS['TL_JQUERY']))
  879.         {
  880.             $strScripts .= implode('', array_unique($GLOBALS['TL_JQUERY']));
  881.         }
  883.         $nonce = ContaoFramework::getNonce();
  885.         $arrReplace["[[TL_JQUERY_$nonce]]"] = $strScripts;
  886.         $strScripts = '';
  888.         // Add the internal MooTools scripts
  889.         if (!empty($GLOBALS['TL_MOOTOOLS']) && \is_array($GLOBALS['TL_MOOTOOLS']))
  890.         {
  891.             $strScripts .= implode('', array_unique($GLOBALS['TL_MOOTOOLS']));
  892.         }
  894.         $arrReplace["[[TL_MOOTOOLS_$nonce]]"] = $strScripts;
  895.         $strScripts = '';
  897.         // Add the internal <body> tags
  898.         if (!empty($GLOBALS['TL_BODY']) && \is_array($GLOBALS['TL_BODY']))
  899.         {
  900.             $strScripts .= implode('', array_unique($GLOBALS['TL_BODY']));
  901.         }
  903.         /** @var PageModel|null $objPage */
  904.         global $objPage;
  906.         $objLayout = ($objPage !== null) ? LayoutModel::findByPk($objPage->layoutId) : null;
  907.         $blnCombineScripts = $objLayout !== null && $objLayout->combineScripts;
  909.         $arrReplace["[[TL_BODY_$nonce]]"] = $strScripts;
  910.         $strScripts = '';
  912.         $objCombiner = new Combiner();
  914.         // Add the CSS framework style sheets
  915.         if (!empty($GLOBALS['TL_FRAMEWORK_CSS']) && \is_array($GLOBALS['TL_FRAMEWORK_CSS']))
  916.         {
  917.             foreach (array_unique($GLOBALS['TL_FRAMEWORK_CSS']) as $stylesheet)
  918.             {
  919.                 $objCombiner->add($stylesheet);
  920.             }
  921.         }
  923.         // Add the internal style sheets
  924.         if (!empty($GLOBALS['TL_CSS']) && \is_array($GLOBALS['TL_CSS']))
  925.         {
  926.             foreach (array_unique($GLOBALS['TL_CSS']) as $stylesheet)
  927.             {
  928.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  930.                 if ($options->static)
  931.                 {
  932.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  933.                 }
  934.                 else
  935.                 {
  936.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  937.                 }
  938.             }
  939.         }
  941.         // Add the user style sheets
  942.         if (!empty($GLOBALS['TL_USER_CSS']) && \is_array($GLOBALS['TL_USER_CSS']))
  943.         {
  944.             foreach (array_unique($GLOBALS['TL_USER_CSS']) as $stylesheet)
  945.             {
  946.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  948.                 if ($options->static)
  949.                 {
  950.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  951.                 }
  952.                 else
  953.                 {
  954.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  955.                 }
  956.             }
  957.         }
  959.         // Create the aggregated style sheet
  960.         if ($objCombiner->hasEntries())
  961.         {
  962.             if ($blnCombineScripts)
  963.             {
  964.                 $strScripts .= Template::generateStyleTag($objCombiner->getCombinedFile(), 'all');
  965.             }
  966.             else
  967.             {
  968.                 foreach ($objCombiner->getFileUrls() as $strUrl)
  969.                 {
  970.                     $options = StringUtil::resolveFlaggedUrl($strUrl);
  971.                     $strScripts .= Template::generateStyleTag($strUrl, $options->media, $options->mtime);
  972.                 }
  973.             }
  974.         }
  976.         $arrReplace["[[TL_CSS_$nonce]]"] = $strScripts;
  977.         $strScripts = '';
  979.         // Add the internal scripts
  980.         if (!empty($GLOBALS['TL_JAVASCRIPT']) && \is_array($GLOBALS['TL_JAVASCRIPT']))
  981.         {
  982.             $objCombiner = new Combiner();
  983.             $objCombinerAsync = new Combiner();
  985.             foreach (array_unique($GLOBALS['TL_JAVASCRIPT']) as $javascript)
  986.             {
  987.                 $options = StringUtil::resolveFlaggedUrl($javascript);
  989.                 if ($options->static)
  990.                 {
  991.                     $options->async ? $objCombinerAsync->add($javascript, $options->mtime) : $objCombiner->add($javascript, $options->mtime);
  992.                 }
  993.                 else
  994.                 {
  995.                     $strScripts .= Template::generateScriptTag(static::addAssetsUrlTo($javascript), $options->async, $options->mtime);
  996.                 }
  997.             }
  999.             // Create the aggregated script and add it before the non-static scripts (see #4890)
  1000.             if ($objCombiner->hasEntries())
  1001.             {
  1002.                 if ($blnCombineScripts)
  1003.                 {
  1004.                     $strScripts = Template::generateScriptTag($objCombiner->getCombinedFile()) . $strScripts;
  1005.                 }
  1006.                 else
  1007.                 {
  1008.                     $arrReversed = array_reverse($objCombiner->getFileUrls());
  1010.                     foreach ($arrReversed as $strUrl)
  1011.                     {
  1012.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  1013.                         $strScripts = Template::generateScriptTag($strUrl, false, $options->mtime) . $strScripts;
  1014.                     }
  1015.                 }
  1016.             }
  1018.             if ($objCombinerAsync->hasEntries())
  1019.             {
  1020.                 if ($blnCombineScripts)
  1021.                 {
  1022.                     $strScripts = Template::generateScriptTag($objCombinerAsync->getCombinedFile(), true) . $strScripts;
  1023.                 }
  1024.                 else
  1025.                 {
  1026.                     $arrReversed = array_reverse($objCombinerAsync->getFileUrls());
  1028.                     foreach ($arrReversed as $strUrl)
  1029.                     {
  1030.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  1031.                         $strScripts = Template::generateScriptTag($strUrl, true, $options->mtime) . $strScripts;
  1032.                     }
  1033.                 }
  1034.             }
  1035.         }
  1037.         // Add the internal <head> tags
  1038.         if (!empty($GLOBALS['TL_HEAD']) && \is_array($GLOBALS['TL_HEAD']))
  1039.         {
  1040.             foreach (array_unique($GLOBALS['TL_HEAD']) as $head)
  1041.             {
  1042.                 $strScripts .= $head;
  1043.             }
  1044.         }
  1046.         $arrReplace["[[TL_HEAD_$nonce]]"] = $strScripts;
  1048.         return str_replace(array_keys($arrReplace), $arrReplace, $strBuffer);
  1049.     }
  1051.     /**
  1052.      * Compile the margin format definition based on an array of values
  1053.      *
  1054.      * @param array  $arrValues An array of four values and a unit
  1055.      * @param string $strType   Either "margin" or "padding"
  1056.      *
  1057.      * @return string The CSS markup
  1058.      *
  1059.      * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  1060.      */
  1061.     public static function generateMargin($arrValues, $strType='margin')
  1062.     {
  1063.         trigger_deprecation('contao/core-bundle', '4.13', 'Using Contao\Controller::generateMargin is deprecated since Contao 4.13 and will be removed in Contao 5.');
  1065.         // Initialize an empty array (see #5217)
  1066.         if (!\is_array($arrValues))
  1067.         {
  1068.             $arrValues = array('top'=>'', 'right'=>'', 'bottom'=>'', 'left'=>'', 'unit'=>'');
  1069.         }
  1071.         $top = $arrValues['top'];
  1072.         $right = $arrValues['right'];
  1073.         $bottom = $arrValues['bottom'];
  1074.         $left = $arrValues['left'];
  1076.         // Try to shorten the definition
  1077.         if ($top && $right && $bottom && $left)
  1078.         {
  1079.             if ($top == $right && $top == $bottom && $top == $left)
  1080.             {
  1081.                 return $strType . ':' . $top . $arrValues['unit'] . ';';
  1082.             }
  1084.             if ($top == $bottom && $right == $left)
  1085.             {
  1086.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1087.             }
  1089.             if ($top != $bottom && $right == $left)
  1090.             {
  1091.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ';';
  1092.             }
  1094.             return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1095.         }
  1097.         $return = array();
  1098.         $arrDir = compact('top', 'right', 'bottom', 'left');
  1100.         foreach ($arrDir as $k=>$v)
  1101.         {
  1102.             if ($v)
  1103.             {
  1104.                 $return[] = $strType . '-' . $k . ':' . $v . $arrValues['unit'] . ';';
  1105.             }
  1106.         }
  1108.         return implode('', $return);
  1109.     }
  1111.     /**
  1112.      * Add a request string to the current URL
  1113.      *
  1114.      * @param string  $strRequest The string to be added
  1115.      * @param boolean $blnAddRef  Add the referer ID
  1116.      * @param array   $arrUnset   An optional array of keys to unset
  1117.      *
  1118.      * @return string The new URL
  1119.      */
  1120.     public static function addToUrl($strRequest, $blnAddRef=true, $arrUnset=array())
  1121.     {
  1122.         $pairs = array();
  1123.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  1125.         if ($request->server->has('QUERY_STRING'))
  1126.         {
  1127.             $cacheKey = md5($request->server->get('QUERY_STRING'));
  1129.             if (!isset(static::$arrQueryCache[$cacheKey]))
  1130.             {
  1131.                 parse_str($request->server->get('QUERY_STRING'), $pairs);
  1132.                 ksort($pairs);
  1134.                 static::$arrQueryCache[$cacheKey] = $pairs;
  1135.             }
  1137.             $pairs = static::$arrQueryCache[$cacheKey];
  1138.         }
  1140.         // Remove the request token and referer ID
  1141.         unset($pairs['rt'], $pairs['ref'], $pairs['revise']);
  1143.         foreach ($arrUnset as $key)
  1144.         {
  1145.             unset($pairs[$key]);
  1146.         }
  1148.         // Merge the request string to be added
  1149.         if ($strRequest)
  1150.         {
  1151.             parse_str(str_replace('&amp;', '&', $strRequest), $newPairs);
  1152.             $pairs = array_merge($pairs, $newPairs);
  1153.         }
  1155.         // Add the referer ID
  1156.         if ($request->query->has('ref') || ($strRequest && $blnAddRef))
  1157.         {
  1158.             $pairs['ref'] = $request->attributes->get('_contao_referer_id');
  1159.         }
  1161.         $uri = '';
  1163.         if (!empty($pairs))
  1164.         {
  1165.             $uri = '?' . http_build_query($pairs, '', '&amp;', PHP_QUERY_RFC3986);
  1166.         }
  1168.         return TL_SCRIPT . $uri;
  1169.     }
  1171.     /**
  1172.      * Reload the current page
  1173.      *
  1174.      * @return never
  1175.      */
  1176.     public static function reload()
  1177.     {
  1178.         static::redirect(Environment::get('uri'));
  1179.     }
  1181.     /**
  1182.      * Redirect to another page
  1183.      *
  1184.      * @param string  $strLocation The target URL
  1185.      * @param integer $intStatus   The HTTP status code (defaults to 303)
  1186.      *
  1187.      * @return never
  1188.      */
  1189.     public static function redirect($strLocation, $intStatus=303)
  1190.     {
  1191.         $strLocation = str_replace('&amp;', '&', $strLocation);
  1192.         $strLocation = static::replaceOldBePaths($strLocation);
  1194.         // Make the location an absolute URL
  1195.         if (!preg_match('@^https?://@i', $strLocation))
  1196.         {
  1197.             $strLocation = Environment::get('base') . ltrim($strLocation, '/');
  1198.         }
  1200.         // Ajax request
  1201.         if (Environment::get('isAjaxRequest'))
  1202.         {
  1203.             throw new AjaxRedirectResponseException($strLocation);
  1204.         }
  1206.         throw new RedirectResponseException($strLocation, $intStatus);
  1207.     }
  1209.     /**
  1210.      * Replace the old back end paths
  1211.      *
  1212.      * @param string $strContext The context
  1213.      *
  1214.      * @return string The modified context
  1215.      */
  1216.     protected static function replaceOldBePaths($strContext)
  1217.     {
  1218.         $arrCache = &self::$arrOldBePathCache;
  1220.         $arrMapper = array
  1221.         (
  1222.             'contao/confirm.php'   => 'contao_backend_confirm',
  1223.             'contao/file.php'      => 'contao_backend_file',
  1224.             'contao/help.php'      => 'contao_backend_help',
  1225.             'contao/index.php'     => 'contao_backend_login',
  1226.             'contao/main.php'      => 'contao_backend',
  1227.             'contao/page.php'      => 'contao_backend_page',
  1228.             'contao/password.php'  => 'contao_backend_password',
  1229.             'contao/popup.php'     => 'contao_backend_popup',
  1230.             'contao/preview.php'   => 'contao_backend_preview',
  1231.         );
  1233.         $replace = static function ($matches) use ($arrMapper, &$arrCache)
  1234.         {
  1235.             $key = $matches[0];
  1237.             if (!isset($arrCache[$key]))
  1238.             {
  1239.                 trigger_deprecation('contao/core-bundle', '4.0', 'Using old backend paths has been deprecated in Contao 4.0 and will be removed in Contao 5. Use the backend routes instead.');
  1241.                 $router = System::getContainer()->get('router');
  1242.                 $arrCache[$key] = substr($router->generate($arrMapper[$key]), \strlen(Environment::get('path')) + 1);
  1243.             }
  1245.             return $arrCache[$key];
  1246.         };
  1248.         $regex = '(' . implode('|', array_map('preg_quote', array_keys($arrMapper))) . ')';
  1250.         return preg_replace_callback($regex, $replace, $strContext);
  1251.     }
  1253.     /**
  1254.      * Generate a front end URL
  1255.      *
  1256.      * @param array   $arrRow       An array of page parameters
  1257.      * @param string  $strParams    An optional string of URL parameters
  1258.      * @param string  $strForceLang Force a certain language
  1259.      * @param boolean $blnFixDomain Check the domain of the target page and append it if necessary
  1260.      *
  1261.      * @return string A URL that can be used in the front end
  1262.      *
  1263.      * @deprecated Deprecated since Contao 4.2, to be removed in Contao 5.0.
  1264.      *             Use PageModel::getFrontendUrl() instead.
  1265.      */
  1266.     public static function generateFrontendUrl(array $arrRow, $strParams=null, $strForceLang=null, $blnFixDomain=false)
  1267.     {
  1268.         trigger_deprecation('contao/core-bundle', '4.2', 'Using "Contao\Controller::generateFrontendUrl()" has been deprecated and will no longer work in Contao 5.0. Use PageModel::getFrontendUrl() instead.');
  1270.         $page = new PageModel();
  1271.         $page->preventSaving(false);
  1272.         $page->setRow($arrRow);
  1274.         if (!isset($arrRow['rootId']))
  1275.         {
  1276.             $page->loadDetails();
  1278.             foreach (array('domain', 'rootLanguage', 'rootUseSSL') as $key)
  1279.             {
  1280.                 if (isset($arrRow[$key]))
  1281.                 {
  1282.                     $page->$key = $arrRow[$key];
  1283.                 }
  1284.                 else
  1285.                 {
  1286.                     $arrRow[$key] = $page->$key;
  1287.                 }
  1288.             }
  1289.         }
  1291.         // Set the language
  1292.         if ($strForceLang !== null)
  1293.         {
  1294.             $strForceLang = LocaleUtil::formatAsLocale($strForceLang);
  1296.             $page->language = $strForceLang;
  1297.             $page->rootLanguage = $strForceLang;
  1299.             if (System::getContainer()->getParameter('contao.legacy_routing'))
  1300.             {
  1301.                 $page->urlPrefix = System::getContainer()->getParameter('contao.prepend_locale') ? $strForceLang : '';
  1302.             }
  1303.         }
  1305.         // Add the domain if it differs from the current one (see #3765 and #6927)
  1306.         if ($blnFixDomain)
  1307.         {
  1308.             $page->domain = $arrRow['domain'];
  1309.             $page->rootUseSSL = (bool) $arrRow['rootUseSSL'];
  1310.         }
  1312.         $objRouter = System::getContainer()->get('router');
  1313.         $strUrl = $objRouter->generate(PageRoute::PAGE_BASED_ROUTE_NAME, array(RouteObjectInterface::CONTENT_OBJECT => $page, 'parameters' => $strParams));
  1315.         // Remove path from absolute URLs
  1316.         if (0 === strncmp($strUrl, '/', 1) && 0 !== strncmp($strUrl, '//', 2))
  1317.         {
  1318.             $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  1319.         }
  1321.         // Decode sprintf placeholders
  1322.         if (strpos($strParams, '%') !== false)
  1323.         {
  1324.             $arrMatches = array();
  1325.             preg_match_all('/%([sducoxXbgGeEfF])/', $strParams, $arrMatches);
  1327.             foreach (array_unique($arrMatches[1]) as $v)
  1328.             {
  1329.                 $strUrl = str_replace('%25' . $v, '%' . $v, $strUrl);
  1330.             }
  1331.         }
  1333.         // HOOK: add custom logic
  1334.         if (isset($GLOBALS['TL_HOOKS']['generateFrontendUrl']) && \is_array($GLOBALS['TL_HOOKS']['generateFrontendUrl']))
  1335.         {
  1336.             foreach ($GLOBALS['TL_HOOKS']['generateFrontendUrl'] as $callback)
  1337.             {
  1338.                 $strUrl = static::importStatic($callback[0])->{$callback[1]}($arrRow, $strParams, $strUrl);
  1339.             }
  1340.         }
  1342.         return $strUrl;
  1343.     }
  1345.     /**
  1346.      * Convert relative URLs in href and src attributes to absolute URLs
  1347.      *
  1348.      * @param string  $strContent  The text with the URLs to be converted
  1349.      * @param string  $strBase     An optional base URL
  1350.      * @param boolean $blnHrefOnly If true, only href attributes will be converted
  1351.      *
  1352.      * @return string The text with the replaced URLs
  1353.      */
  1354.     public static function convertRelativeUrls($strContent, $strBase='', $blnHrefOnly=false)
  1355.     {
  1356.         if (!$strBase)
  1357.         {
  1358.             $strBase = Environment::get('base');
  1359.         }
  1361.         $search = $blnHrefOnly ? 'href' : 'href|src';
  1362.         $arrUrls = preg_split('/((' . $search . ')="([^"]+)")/i', $strContent, -1, PREG_SPLIT_DELIM_CAPTURE);
  1363.         $strContent = '';
  1365.         for ($i=0, $c=\count($arrUrls); $i<$c; $i+=4)
  1366.         {
  1367.             $strContent .= $arrUrls[$i];
  1369.             if (!isset($arrUrls[$i+2]))
  1370.             {
  1371.                 continue;
  1372.             }
  1374.             $strAttribute = $arrUrls[$i+2];
  1375.             $strUrl = $arrUrls[$i+3];
  1377.             if (!preg_match('@^(?:[a-z0-9]+:|#)@i', $strUrl))
  1378.             {
  1379.                 $strUrl = $strBase . (($strUrl != '/') ? $strUrl : '');
  1380.             }
  1382.             $strContent .= $strAttribute . '="' . $strUrl . '"';
  1383.         }
  1385.         return $strContent;
  1386.     }
  1388.     /**
  1389.      * Send a file to the browser so the "save as …" dialogue opens
  1390.      *
  1391.      * @param string  $strFile The file path
  1392.      * @param boolean $inline  Show the file in the browser instead of opening the download dialog
  1393.      *
  1394.      * @throws AccessDeniedException
  1395.      */
  1396.     public static function sendFileToBrowser($strFile, $inline=false)
  1397.     {
  1398.         // Make sure there are no attempts to hack the file system
  1399.         if (preg_match('@^\.+@', $strFile) || preg_match('@\.+/@', $strFile) || preg_match('@(://)+@', $strFile))
  1400.         {
  1401.             throw new PageNotFoundException('Invalid file name');
  1402.         }
  1404.         // Limit downloads to the files directory
  1405.         if (!preg_match('@^' . preg_quote(System::getContainer()->getParameter('contao.upload_path'), '@') . '@i', $strFile))
  1406.         {
  1407.             throw new PageNotFoundException('Invalid path');
  1408.         }
  1410.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1412.         // Check whether the file exists
  1413.         if (!file_exists($projectDir . '/' . $strFile))
  1414.         {
  1415.             throw new PageNotFoundException('File not found');
  1416.         }
  1418.         $objFile = new File($strFile);
  1419.         $arrAllowedTypes = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1421.         // Check whether the file type is allowed to be downloaded
  1422.         if (!\in_array($objFile->extension, $arrAllowedTypes))
  1423.         {
  1424.             throw new AccessDeniedException(sprintf('File type "%s" is not allowed', $objFile->extension));
  1425.         }
  1427.         // HOOK: post download callback
  1428.         if (isset($GLOBALS['TL_HOOKS']['postDownload']) && \is_array($GLOBALS['TL_HOOKS']['postDownload']))
  1429.         {
  1430.             foreach ($GLOBALS['TL_HOOKS']['postDownload'] as $callback)
  1431.             {
  1432.                 static::importStatic($callback[0])->{$callback[1]}($strFile);
  1433.             }
  1434.         }
  1436.         // Send the file (will stop the script execution)
  1437.         $objFile->sendToBrowser('', $inline);
  1438.     }
  1440.     /**
  1441.      * Load a set of DCA files
  1442.      *
  1443.      * @param string  $strTable   The table name
  1444.      * @param boolean $blnNoCache If true, the cache will be bypassed
  1445.      */
  1446.     public static function loadDataContainer($strTable, $blnNoCache=false)
  1447.     {
  1448.         if (\func_num_args() > 1)
  1449.         {
  1450.             trigger_deprecation('contao/core-bundle', '4.13', 'Calling "%s" with the $blnNoCache parameter has been deprecated and will no longer work in Contao 5.0.', __METHOD__);
  1451.         }
  1453.         $loader = new DcaLoader($strTable);
  1454.         $loader->load(...($blnNoCache ? array(true) : array()));
  1455.     }
  1457.     /**
  1458.      * Do not name this "reset" because it might result in conflicts with child classes
  1459.      * @see https://github.com/contao/contao/issues/4257
  1460.      *
  1461.      * @internal
  1462.      */
  1463.     public static function resetControllerCache()
  1464.     {
  1465.         self::$arrQueryCache = array();
  1466.         self::$arrOldBePathCache = array();
  1467.     }
  1469.     /**
  1470.      * Redirect to a front end page
  1471.      *
  1472.      * @param integer $intPage    The page ID
  1473.      * @param string  $strArticle An optional article alias
  1474.      * @param boolean $blnReturn  If true, return the URL and don't redirect
  1475.      *
  1476.      * @return string The URL of the target page
  1477.      */
  1478.     protected function redirectToFrontendPage($intPage, $strArticle=null, $blnReturn=false)
  1479.     {
  1480.         if (($intPage = (int) $intPage) <= 0)
  1481.         {
  1482.             return '';
  1483.         }
  1485.         $objPage = PageModel::findWithDetails($intPage);
  1487.         if ($objPage === null)
  1488.         {
  1489.             return '';
  1490.         }
  1492.         $strParams = null;
  1494.         // Add the /article/ fragment (see #673)
  1495.         if ($strArticle !== null && ($objArticle = ArticleModel::findByAlias($strArticle)) !== null)
  1496.         {
  1497.             $strParams = '/articles/' . (($objArticle->inColumn != 'main') ? $objArticle->inColumn . ':' : '') . $strArticle;
  1498.         }
  1500.         $strUrl = $objPage->getPreviewUrl($strParams);
  1502.         if (!$blnReturn)
  1503.         {
  1504.             $this->redirect($strUrl);
  1505.         }
  1507.         return $strUrl;
  1508.     }
  1510.     /**
  1511.      * Get the parent records of an entry and return them as string which can
  1512.      * be used in a log message
  1513.      *
  1514.      * @param string  $strTable The table name
  1515.      * @param integer $intId    The record ID
  1516.      *
  1517.      * @return string A string that can be used in a log message
  1518.      */
  1519.     protected function getParentEntries($strTable, $intId)
  1520.     {
  1521.         // No parent table
  1522.         if (empty($GLOBALS['TL_DCA'][$strTable]['config']['ptable']))
  1523.         {
  1524.             return '';
  1525.         }
  1527.         $arrParent = array();
  1529.         do
  1530.         {
  1531.             // Get the pid
  1532.             $objParent = $this->Database->prepare("SELECT pid FROM " . $strTable . " WHERE id=?")
  1533.                                         ->limit(1)
  1534.                                         ->execute($intId);
  1536.             if ($objParent->numRows < 1)
  1537.             {
  1538.                 break;
  1539.             }
  1541.             // Store the parent table information
  1542.             $strTable = $GLOBALS['TL_DCA'][$strTable]['config']['ptable'];
  1543.             $intId = $objParent->pid;
  1545.             // Add the log entry
  1546.             $arrParent[] = $strTable . '.id=' . $intId;
  1548.             // Load the data container of the parent table
  1549.             $this->loadDataContainer($strTable);
  1550.         }
  1551.         while ($intId && !empty($GLOBALS['TL_DCA'][$strTable]['config']['ptable']));
  1553.         if (empty($arrParent))
  1554.         {
  1555.             return '';
  1556.         }
  1558.         return ' (parent records: ' . implode(', ', $arrParent) . ')';
  1559.     }
  1561.     /**
  1562.      * Take an array of file paths and eliminate the nested ones
  1563.      *
  1564.      * @param array $arrPaths The array of file paths
  1565.      *
  1566.      * @return array The file paths array without the nested paths
  1567.      */
  1568.     protected function eliminateNestedPaths($arrPaths)
  1569.     {
  1570.         $arrPaths = array_filter($arrPaths);
  1572.         if (empty($arrPaths) || !\is_array($arrPaths))
  1573.         {
  1574.             return array();
  1575.         }
  1577.         $nested = array();
  1579.         foreach ($arrPaths as $path)
  1580.         {
  1581.             $nested[] = preg_grep('/^' . preg_quote($path, '/') . '\/.+/', $arrPaths);
  1582.         }
  1584.         if (!empty($nested))
  1585.         {
  1586.             $nested = array_merge(...$nested);
  1587.         }
  1589.         return array_values(array_diff($arrPaths, $nested));
  1590.     }
  1592.     /**
  1593.      * Take an array of pages and eliminate the nested ones
  1594.      *
  1595.      * @param array   $arrPages   The array of page IDs
  1596.      * @param string  $strTable   The table name
  1597.      * @param boolean $blnSorting True if the table has a sorting field
  1598.      *
  1599.      * @return array The page IDs array without the nested IDs
  1600.      */
  1601.     protected function eliminateNestedPages($arrPages, $strTable=null, $blnSorting=false)
  1602.     {
  1603.         if (empty($arrPages) || !\is_array($arrPages))
  1604.         {
  1605.             return array();
  1606.         }
  1608.         if (!$strTable)
  1609.         {
  1610.             $strTable = 'tl_page';
  1611.         }
  1613.         // Thanks to Andreas Schempp (see #2475 and #3423)
  1614.         $arrPages = array_filter(array_map('intval', $arrPages));
  1615.         $arrPages = array_values(array_diff($arrPages, $this->Database->getChildRecords($arrPages, $strTable, $blnSorting)));
  1617.         return $arrPages;
  1618.     }
  1620.     /**
  1621.      * Add an image to a template
  1622.      *
  1623.      * @param object          $template                The template object to add the image to
  1624.      * @param array           $rowData                 The element or module as array
  1625.      * @param integer|null    $maxWidth                An optional maximum width of the image
  1626.      * @param string|null     $lightboxGroupIdentifier An optional lightbox group identifier
  1627.      * @param FilesModel|null $filesModel              An optional files model
  1628.      *
  1629.      * @deprecated Deprecated since Contao 4.11, to be removed in Contao 5.0;
  1630.      *             use the Contao\CoreBundle\Image\Studio\FigureBuilder instead.
  1631.      */
  1632.     public static function addImageToTemplate($template, array $rowData, $maxWidth = null, $lightboxGroupIdentifier = null, ?FilesModel $filesModel = null): void
  1633.     {
  1634.         trigger_deprecation('contao/core-bundle', '4.11', 'Using Controller::addImageToTemplate() is deprecated and will no longer work in Contao 5.0. Use the "Contao\CoreBundle\Image\Studio\FigureBuilder" class instead.');
  1636.         // Helper: Create metadata from the specified row data
  1637.         $createMetadataOverwriteFromRowData = static function (bool $interpretAsContentModel) use ($rowData)
  1638.         {
  1639.             if ($interpretAsContentModel)
  1640.             {
  1641.                 // This will be null if "overwriteMeta" is not set
  1642.                 return (new ContentModel())->setRow($rowData)->getOverwriteMetadata();
  1643.             }
  1645.             // Manually create metadata that always contains certain properties (BC)
  1646.             return new Metadata(array(
  1647.                 Metadata::VALUE_ALT => $rowData['alt'] ?? '',
  1648.                 Metadata::VALUE_TITLE => $rowData['imageTitle'] ?? '',
  1649.                 Metadata::VALUE_URL => System::getContainer()->get('contao.insert_tag.parser')->replaceInline($rowData['imageUrl'] ?? ''),
  1650.                 'linkTitle' => (string) ($rowData['linkTitle'] ?? ''),
  1651.             ));
  1652.         };
  1654.         // Helper: Create fallback template data with (mostly) empty fields (used if resource acquisition fails)
  1655.         $createFallBackTemplateData = static function () use ($filesModel, $rowData)
  1656.         {
  1657.             $templateData = array(
  1658.                 'width' => null,
  1659.                 'height' => null,
  1660.                 'picture' => array(
  1661.                     'img' => array(
  1662.                         'src' => '',
  1663.                         'srcset' => '',
  1664.                     ),
  1665.                     'sources' => array(),
  1666.                     'alt' => '',
  1667.                     'title' => '',
  1668.                 ),
  1669.                 'singleSRC' => $rowData['singleSRC'],
  1670.                 'src' => '',
  1671.                 'linkTitle' => '',
  1672.                 'margin' => '',
  1673.                 'addImage' => true,
  1674.                 'addBefore' => true,
  1675.                 'fullsize' => false,
  1676.             );
  1678.             if (null !== $filesModel)
  1679.             {
  1680.                 // Set empty metadata
  1681.                 $templateData = array_replace_recursive(
  1682.                     $templateData,
  1683.                     array(
  1684.                         'alt' => '',
  1685.                         'caption' => '',
  1686.                         'imageTitle' => '',
  1687.                         'imageUrl' => '',
  1688.                     )
  1689.                 );
  1690.             }
  1692.             return $templateData;
  1693.         };
  1695.         // Helper: Get size and margins and handle legacy $maxWidth option
  1696.         $getSizeAndMargin = static function () use ($rowData, $maxWidth)
  1697.         {
  1698.             $size = $rowData['size'] ?? null;
  1699.             $margin = StringUtil::deserialize($rowData['imagemargin'] ?? null);
  1700.             $maxWidth = (int) ($maxWidth ?? Config::get('maxImageWidth'));
  1702.             if (0 === $maxWidth)
  1703.             {
  1704.                 return array($size, $margin);
  1705.             }
  1707.             trigger_deprecation('contao/core-bundle', '4.10', 'Using a maximum front end width has been deprecated and will no longer work in Contao 5.0. Remove the "maxImageWidth" configuration and use responsive images instead.');
  1709.             // Adjust margins if needed
  1710.             if ('px' === ($margin['unit'] ?? null))
  1711.             {
  1712.                 $horizontalMargin = (int) ($margin['left'] ?? 0) + (int) ($margin['right'] ?? 0);
  1714.                 if ($maxWidth - $horizontalMargin < 1)
  1715.                 {
  1716.                     $margin['left'] = '';
  1717.                     $margin['right'] = '';
  1718.                 }
  1719.                 else
  1720.                 {
  1721.                     $maxWidth -= $horizontalMargin;
  1722.                 }
  1723.             }
  1725.             // Normalize size
  1726.             if ($size instanceof PictureConfiguration)
  1727.             {
  1728.                 return array($size, $margin);
  1729.             }
  1731.             $size = StringUtil::deserialize($size);
  1733.             if (is_numeric($size))
  1734.             {
  1735.                 $size = array(0, 0, (int) $size);
  1736.             }
  1737.             else
  1738.             {
  1739.                 $size = (\is_array($size) ? $size : array()) + array(0, 0, 'crop');
  1740.                 $size[0] = (int) $size[0];
  1741.                 $size[1] = (int) $size[1];
  1742.             }
  1744.             // Adjust image size configuration if it exceeds the max width
  1745.             if ($size[0] > 0 && $size[1] > 0)
  1746.             {
  1747.                 list($width, $height) = $size;
  1748.             }
  1749.             else
  1750.             {
  1751.                 $container = System::getContainer();
  1753.                 /** @var BoxInterface $originalSize */
  1754.                 $originalSize = $container
  1755.                     ->get('contao.image.factory')
  1756.                     ->create($container->getParameter('kernel.project_dir') . '/' . $rowData['singleSRC'])
  1757.                     ->getDimensions()
  1758.                     ->getSize();
  1760.                 $width = $originalSize->getWidth();
  1761.                 $height = $originalSize->getHeight();
  1762.             }
  1764.             if ($width <= $maxWidth)
  1765.             {
  1766.                 return array($size, $margin);
  1767.             }
  1769.             $size[0] = $maxWidth;
  1770.             $size[1] = (int) floor($maxWidth * ($height / $width));
  1772.             return array($size, $margin);
  1773.         };
  1775.         $figureBuilder = System::getContainer()->get('contao.image.studio')->createFigureBuilder();
  1777.         // Set image resource
  1778.         if (null !== $filesModel)
  1779.         {
  1780.             // Make sure model points to the same resource (BC)
  1781.             $filesModel = clone $filesModel;
  1782.             $filesModel->path = $rowData['singleSRC'];
  1784.             // Use source + metadata from files model (if not overwritten)
  1785.             $figureBuilder
  1786.                 ->fromFilesModel($filesModel)
  1787.                 ->setMetadata($createMetadataOverwriteFromRowData(true));
  1789.             $includeFullMetadata = true;
  1790.         }
  1791.         else
  1792.         {
  1793.             // Always ignore file metadata when building from path (BC)
  1794.             $figureBuilder
  1795.                 ->fromPath($rowData['singleSRC'], false)
  1796.                 ->setMetadata($createMetadataOverwriteFromRowData(false));
  1798.             $includeFullMetadata = false;
  1799.         }
  1801.         // Set size and lightbox configuration
  1802.         list($size, $margin) = $getSizeAndMargin();
  1804.         $lightboxSize = StringUtil::deserialize($rowData['lightboxSize'] ?? null) ?: null;
  1806.         $figure = $figureBuilder
  1807.             ->setSize($size)
  1808.             ->setLightboxGroupIdentifier($lightboxGroupIdentifier)
  1809.             ->setLightboxSize($lightboxSize)
  1810.             ->enableLightbox((bool) ($rowData['fullsize'] ?? false))
  1811.             ->buildIfResourceExists();
  1813.         if (null === $figure)
  1814.         {
  1815.             System::getContainer()->get('monolog.logger.contao.error')->error('Image "' . $rowData['singleSRC'] . '" could not be processed: ' . $figureBuilder->getLastException()->getMessage());
  1817.             // Fall back to apply a sparse data set instead of failing (BC)
  1818.             foreach ($createFallBackTemplateData() as $key => $value)
  1819.             {
  1820.                 $template->$key = $value;
  1821.             }
  1823.             return;
  1824.         }
  1826.         // Build result and apply it to the template
  1827.         $figure->applyLegacyTemplateData($template, $margin, $rowData['floating'] ?? null, $includeFullMetadata);
  1829.         // Fall back to manually specified link title or empty string if not set (backwards compatibility)
  1830.         $template->linkTitle ??= StringUtil::specialchars($rowData['title'] ?? '');
  1831.     }
  1833.     /**
  1834.      * Add enclosures to a template
  1835.      *
  1836.      * @param object $objTemplate The template object to add the enclosures to
  1837.      * @param array  $arrItem     The element or module as array
  1838.      * @param string $strKey      The name of the enclosures field in $arrItem
  1839.      */
  1840.     public static function addEnclosuresToTemplate($objTemplate, $arrItem, $strKey='enclosure')
  1841.     {
  1842.         $arrEnclosures = StringUtil::deserialize($arrItem[$strKey]);
  1844.         if (empty($arrEnclosures) || !\is_array($arrEnclosures))
  1845.         {
  1846.             return;
  1847.         }
  1849.         $objFiles = FilesModel::findMultipleByUuids($arrEnclosures);
  1851.         if ($objFiles === null)
  1852.         {
  1853.             return;
  1854.         }
  1856.         $file = Input::get('file', true);
  1858.         // Send the file to the browser and do not send a 404 header (see #5178)
  1859.         if ($file)
  1860.         {
  1861.             while ($objFiles->next())
  1862.             {
  1863.                 if ($file == $objFiles->path)
  1864.                 {
  1865.                     static::sendFileToBrowser($file);
  1866.                 }
  1867.             }
  1869.             $objFiles->reset();
  1870.         }
  1872.         /** @var PageModel $objPage */
  1873.         global $objPage;
  1875.         $arrEnclosures = array();
  1876.         $allowedDownload = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1877.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1879.         // Add download links
  1880.         while ($objFiles->next())
  1881.         {
  1882.             if ($objFiles->type == 'file')
  1883.             {
  1884.                 if (!\in_array($objFiles->extension, $allowedDownload) || !is_file($projectDir . '/' . $objFiles->path))
  1885.                 {
  1886.                     continue;
  1887.                 }
  1889.                 $objFile = new File($objFiles->path);
  1890.                 $strHref = Environment::get('request');
  1892.                 // Remove an existing file parameter (see #5683)
  1893.                 if (preg_match('/(&(amp;)?|\?)file=/', $strHref))
  1894.                 {
  1895.                     $strHref = preg_replace('/(&(amp;)?|\?)file=[^&]+/', '', $strHref);
  1896.                 }
  1898.                 $strHref .= ((strpos($strHref, '?') !== false) ? '&amp;' : '?') . 'file=' . System::urlEncode($objFiles->path);
  1900.                 $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->language);
  1902.                 if (empty($arrMeta) && $objPage->rootFallbackLanguage !== null)
  1903.                 {
  1904.                     $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->rootFallbackLanguage);
  1905.                 }
  1907.                 // Use the file name as title if none is given
  1908.                 if (empty($arrMeta['title']))
  1909.                 {
  1910.                     $arrMeta['title'] = StringUtil::specialchars($objFile->basename);
  1911.                 }
  1913.                 $arrEnclosures[] = array
  1914.                 (
  1915.                     'id'        => $objFiles->id,
  1916.                     'uuid'      => $objFiles->uuid,
  1917.                     'name'      => $objFile->basename,
  1918.                     'title'     => StringUtil::specialchars(sprintf($GLOBALS['TL_LANG']['MSC']['download'], $objFile->basename)),
  1919.                     'link'      => $arrMeta['title'],
  1920.                     'caption'   => $arrMeta['caption'] ?? null,
  1921.                     'href'      => $strHref,
  1922.                     'filesize'  => static::getReadableSize($objFile->filesize),
  1923.                     'icon'      => Image::getPath($objFile->icon),
  1924.                     'mime'      => $objFile->mime,
  1925.                     'meta'      => $arrMeta,
  1926.                     'extension' => $objFile->extension,
  1927.                     'path'      => $objFile->dirname,
  1928.                     'enclosure' => $objFiles->path // backwards compatibility
  1929.                 );
  1930.             }
  1931.         }
  1933.         // Order the enclosures
  1934.         if (!empty($arrItem['orderEnclosure']))
  1935.         {
  1936.             trigger_deprecation('contao/core-bundle', '4.10', 'Using "orderEnclosure" has been deprecated and will no longer work in Contao 5.0. Use a file tree with "isSortable" instead.');
  1938.             $arrEnclosures = ArrayUtil::sortByOrderField($arrEnclosures, $arrItem['orderEnclosure']);
  1939.         }
  1941.         $objTemplate->enclosure = $arrEnclosures;
  1942.     }
  1944.     /**
  1945.      * Set the static URL constants
  1946.      *
  1947.      * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  1948.      */
  1949.     public static function setStaticUrls()
  1950.     {
  1951.         if (\defined('TL_FILES_URL'))
  1952.         {
  1953.             return;
  1954.         }
  1956.         if (\func_num_args() > 0)
  1957.         {
  1958.             trigger_deprecation('contao/core-bundle', '4.9', 'Using "Contao\Controller::setStaticUrls()" has been deprecated and will no longer work in Contao 5.0. Use the asset contexts instead.');
  1960.             if (!isset($GLOBALS['objPage']))
  1961.             {
  1962.                 $GLOBALS['objPage'] = func_get_arg(0);
  1963.             }
  1964.         }
  1966.         \define('TL_ASSETS_URL', System::getContainer()->get('contao.assets.assets_context')->getStaticUrl());
  1967.         \define('TL_FILES_URL', System::getContainer()->get('contao.assets.files_context')->getStaticUrl());
  1969.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  1970.         \define('TL_SCRIPT_URL', TL_ASSETS_URL);
  1971.         \define('TL_PLUGINS_URL', TL_ASSETS_URL);
  1972.     }
  1974.     /**
  1975.      * Add a static URL to a script
  1976.      *
  1977.      * @param string             $script  The script path
  1978.      * @param ContaoContext|null $context
  1979.      *
  1980.      * @return string The script path with the static URL
  1981.      */
  1982.     public static function addStaticUrlTo($script, ?ContaoContext $context = null)
  1983.     {
  1984.         // Absolute URLs
  1985.         if (preg_match('@^https?://@', $script))
  1986.         {
  1987.             return $script;
  1988.         }
  1990.         if ($context === null)
  1991.         {
  1992.             $context = System::getContainer()->get('contao.assets.assets_context');
  1993.         }
  1995.         if ($strStaticUrl = $context->getStaticUrl())
  1996.         {
  1997.             return $strStaticUrl . $script;
  1998.         }
  2000.         return $script;
  2001.     }
  2003.     /**
  2004.      * Add the assets URL to a script
  2005.      *
  2006.      * @param string $script The script path
  2007.      *
  2008.      * @return string The script path with the assets URL
  2009.      */
  2010.     public static function addAssetsUrlTo($script)
  2011.     {
  2012.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.assets_context'));
  2013.     }
  2015.     /**
  2016.      * Add the files URL to a script
  2017.      *
  2018.      * @param string $script The script path
  2019.      *
  2020.      * @return string The script path with the files URL
  2021.      */
  2022.     public static function addFilesUrlTo($script)
  2023.     {
  2024.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.files_context'));
  2025.     }
  2027.     /**
  2028.      * Return the current theme as string
  2029.      *
  2030.      * @return string The name of the theme
  2031.      *
  2032.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2033.      *             Use Backend::getTheme() instead.
  2034.      */
  2035.     public static function getTheme()
  2036.     {
  2037.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getTheme()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Backend::getTheme()" instead.');
  2039.         return Backend::getTheme();
  2040.     }
  2042.     /**
  2043.      * Return the back end themes as array
  2044.      *
  2045.      * @return array An array of available back end themes
  2046.      *
  2047.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2048.      *             Use Backend::getThemes() instead.
  2049.      */
  2050.     public static function getBackendThemes()
  2051.     {
  2052.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getBackendThemes()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Backend::getThemes()" instead.');
  2054.         return Backend::getThemes();
  2055.     }
  2057.     /**
  2058.      * Get the details of a page including inherited parameters
  2059.      *
  2060.      * @param mixed $intId A page ID or a Model object
  2061.      *
  2062.      * @return PageModel The page model or null
  2063.      *
  2064.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2065.      *             Use PageModel::findWithDetails() or PageModel->loadDetails() instead.
  2066.      */
  2067.     public static function getPageDetails($intId)
  2068.     {
  2069.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getPageDetails()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\PageModel::findWithDetails()" or "Contao\PageModel->loadDetails()" instead.');
  2071.         if ($intId instanceof PageModel)
  2072.         {
  2073.             return $intId->loadDetails();
  2074.         }
  2076.         if ($intId instanceof Collection)
  2077.         {
  2078.             /** @var PageModel $objPage */
  2079.             $objPage = $intId->current();
  2081.             return $objPage->loadDetails();
  2082.         }
  2084.         if (\is_object($intId))
  2085.         {
  2086.             $strKey = __METHOD__ . '-' . $intId->id;
  2088.             // Try to load from cache
  2089.             if (Cache::has($strKey))
  2090.             {
  2091.                 return Cache::get($strKey);
  2092.             }
  2094.             // Create a model from the database result
  2095.             $objPage = new PageModel();
  2096.             $objPage->setRow($intId->row());
  2097.             $objPage->loadDetails();
  2099.             Cache::set($strKey, $objPage);
  2101.             return $objPage;
  2102.         }
  2104.         // Invalid ID
  2105.         if ($intId < 1 || !\strlen($intId))
  2106.         {
  2107.             return null;
  2108.         }
  2110.         $strKey = __METHOD__ . '-' . $intId;
  2112.         // Try to load from cache
  2113.         if (Cache::has($strKey))
  2114.         {
  2115.             return Cache::get($strKey);
  2116.         }
  2118.         $objPage = PageModel::findWithDetails($intId);
  2120.         Cache::set($strKey, $objPage);
  2122.         return $objPage;
  2123.     }
  2125.     /**
  2126.      * Remove old XML files from the share directory
  2127.      *
  2128.      * @param boolean $blnReturn If true, only return the finds and don't delete
  2129.      *
  2130.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2131.      *             Use Automator::purgeXmlFiles() instead.
  2132.      */
  2133.     protected function removeOldFeeds($blnReturn=false)
  2134.     {
  2135.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::removeOldFeeds()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Automator::purgeXmlFiles()" instead.');
  2137.         $this->import(Automator::class, 'Automator');
  2138.         $this->Automator->purgeXmlFiles($blnReturn);
  2139.     }
  2141.     /**
  2142.      * Return true if a class exists (tries to autoload the class)
  2143.      *
  2144.      * @param string $strClass The class name
  2145.      *
  2146.      * @return boolean True if the class exists
  2147.      *
  2148.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2149.      *             Use the PHP function class_exists() instead.
  2150.      */
  2151.     protected function classFileExists($strClass)
  2152.     {
  2153.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::classFileExists()" has been deprecated and will no longer work in Contao 5.0. Use the PHP function "class_exists()" instead.');
  2155.         return class_exists($strClass);
  2156.     }
  2158.     /**
  2159.      * Restore basic entities
  2160.      *
  2161.      * @param string $strBuffer The string with the tags to be replaced
  2162.      *
  2163.      * @return string The string with the original entities
  2164.      *
  2165.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2166.      *             Use StringUtil::restoreBasicEntities() instead.
  2167.      */
  2168.     public static function restoreBasicEntities($strBuffer)
  2169.     {
  2170.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::restoreBasicEntities()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\StringUtil::restoreBasicEntities()" instead.');
  2172.         return StringUtil::restoreBasicEntities($strBuffer);
  2173.     }
  2175.     /**
  2176.      * Resize an image and crop it if necessary
  2177.      *
  2178.      * @param string  $image  The image path
  2179.      * @param integer $width  The target width
  2180.      * @param integer $height The target height
  2181.      * @param string  $mode   An optional resize mode
  2182.      *
  2183.      * @return boolean True if the image has been resized correctly
  2184.      *
  2185.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2186.      *             Use Image::resize() instead.
  2187.      */
  2188.     protected function resizeImage($image, $width, $height, $mode='')
  2189.     {
  2190.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::resizeImage()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Image::resize()" instead.');
  2192.         return Image::resize($image, $width, $height, $mode);
  2193.     }
  2195.     /**
  2196.      * Resize an image and crop it if necessary
  2197.      *
  2198.      * @param string  $image  The image path
  2199.      * @param integer $width  The target width
  2200.      * @param integer $height The target height
  2201.      * @param string  $mode   An optional resize mode
  2202.      * @param string  $target An optional target to be replaced
  2203.      * @param boolean $force  Override existing target images
  2204.      *
  2205.      * @return string|null The image path or null
  2206.      *
  2207.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2208.      *             Use Image::get() instead.
  2209.      */
  2210.     protected function getImage($image, $width, $height, $mode='', $target=null, $force=false)
  2211.     {
  2212.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getImage()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Image::get()" instead.');
  2214.         return Image::get($image, $width, $height, $mode, $target, $force);
  2215.     }
  2217.     /**
  2218.      * Generate an image tag and return it as string
  2219.      *
  2220.      * @param string $src        The image path
  2221.      * @param string $alt        An optional alt attribute
  2222.      * @param string $attributes A string of other attributes
  2223.      *
  2224.      * @return string The image HTML tag
  2225.      *
  2226.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2227.      *             Use Image::getHtml() instead.
  2228.      */
  2229.     public static function generateImage($src, $alt='', $attributes='')
  2230.     {
  2231.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::generateImage()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Image::getHtml()" instead.');
  2233.         return Image::getHtml($src, $alt, $attributes);
  2234.     }
  2236.     /**
  2237.      * Return the date picker string (see #3218)
  2238.      *
  2239.      * @return boolean
  2240.      *
  2241.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2242.      *             Specify "datepicker"=>true in your DCA file instead.
  2243.      */
  2244.     protected function getDatePickerString()
  2245.     {
  2246.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getDatePickerString()" has been deprecated and will no longer work in Contao 5.0. Specify "\'datepicker\' => true" in your DCA file instead.');
  2248.         return true;
  2249.     }
  2251.     /**
  2252.      * Return the installed back end languages as array
  2253.      *
  2254.      * @return array An array of available back end languages
  2255.      *
  2256.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2257.      *             Use the Contao\CoreBundle\Intl\Locales service instead.
  2258.      */
  2259.     protected function getBackendLanguages()
  2260.     {
  2261.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getBackendLanguages()" has been deprecated and will no longer work in Contao 5.0. Use the Contao\CoreBundle\Intl\Locales service instead.');
  2263.         return $this->getLanguages(true);
  2264.     }
  2266.     /**
  2267.      * Parse simple tokens that can be used to personalize newsletters
  2268.      *
  2269.      * @param string $strBuffer The text with the tokens to be replaced
  2270.      * @param array  $arrData   The replacement data as array
  2271.      *
  2272.      * @return string The text with the replaced tokens
  2273.      *
  2274.      * @deprecated Deprecated since Contao 4.10, to be removed in Contao 5.0;
  2275.      *             Use the contao.string.simple_token_parser service instead.
  2276.      */
  2277.     protected function parseSimpleTokens($strBuffer, $arrData)
  2278.     {
  2279.         trigger_deprecation('contao/core-bundle', '4.10', 'Using "Contao\Controller::parseSimpleTokens()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.string.simple_token_parser" service instead.');
  2281.         return System::getContainer()->get('contao.string.simple_token_parser')->parse($strBuffer, $arrData);
  2282.     }
  2284.     /**
  2285.      * Convert a DCA file configuration to be used with widgets
  2286.      *
  2287.      * @param array  $arrData  The field configuration array
  2288.      * @param string $strName  The field name in the form
  2289.      * @param mixed  $varValue The field value
  2290.      * @param string $strField The field name in the database
  2291.      * @param string $strTable The table name
  2292.      *
  2293.      * @return array An array that can be passed to a widget
  2294.      *
  2295.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2296.      *             Use Widget::getAttributesFromDca() instead.
  2297.      */
  2298.     protected function prepareForWidget($arrData, $strName, $varValue=null, $strField='', $strTable='')
  2299.     {
  2300.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::prepareForWidget()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Widget::getAttributesFromDca()" instead.');
  2302.         return Widget::getAttributesFromDca($arrData, $strName, $varValue, $strField, $strTable);
  2303.     }
  2305.     /**
  2306.      * Return the IDs of all child records of a particular record (see #2475)
  2307.      *
  2308.      * @param mixed   $arrParentIds An array of parent IDs
  2309.      * @param string  $strTable     The table name
  2310.      * @param boolean $blnSorting   True if the table has a sorting field
  2311.      * @param array   $arrReturn    The array to be returned
  2312.      * @param string  $strWhere     Additional WHERE condition
  2313.      *
  2314.      * @return array An array of child record IDs
  2315.      *
  2316.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2317.      *             Use Database::getChildRecords() instead.
  2318.      */
  2319.     protected function getChildRecords($arrParentIds, $strTable, $blnSorting=false, $arrReturn=array(), $strWhere='')
  2320.     {
  2321.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getChildRecords()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Database::getChildRecords()" instead.');
  2323.         return $this->Database->getChildRecords($arrParentIds, $strTable, $blnSorting, $arrReturn, $strWhere);
  2324.     }
  2326.     /**
  2327.      * Return the IDs of all parent records of a particular record
  2328.      *
  2329.      * @param integer $intId    The ID of the record
  2330.      * @param string  $strTable The table name
  2331.      *
  2332.      * @return array An array of parent record IDs
  2333.      *
  2334.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2335.      *             Use Database::getParentRecords() instead.
  2336.      */
  2337.     protected function getParentRecords($intId, $strTable)
  2338.     {
  2339.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getParentRecords()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Database::getParentRecords()" instead.');
  2341.         return $this->Database->getParentRecords($intId, $strTable);
  2342.     }
  2344.     /**
  2345.      * Print an article as PDF and stream it to the browser
  2346.      *
  2347.      * @param ModuleModel $objArticle An article object
  2348.      *
  2349.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2350.      *             Use ModuleArticle->generatePdf() instead.
  2351.      */
  2352.     protected function printArticleAsPdf($objArticle)
  2353.     {
  2354.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::printArticleAsPdf()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\ModuleArticle->generatePdf()" instead.');
  2356.         $objArticle = new ModuleArticle($objArticle);
  2357.         $objArticle->generatePdf();
  2358.     }
  2360.     /**
  2361.      * Return all page sections as array
  2362.      *
  2363.      * @return array An array of active page sections
  2364.      *
  2365.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2366.      *             See https://github.com/contao/core/issues/4693.
  2367.      */
  2368.     public static function getPageSections()
  2369.     {
  2370.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getPageSections()" has been deprecated and will no longer work in Contao 5.0.');
  2372.         return array('header', 'left', 'right', 'main', 'footer');
  2373.     }
  2375.     /**
  2376.      * Return a "selected" attribute if the option is selected
  2377.      *
  2378.      * @param string $strOption The option to check
  2379.      * @param mixed  $varValues One or more values to check against
  2380.      *
  2381.      * @return string The attribute or an empty string
  2382.      *
  2383.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2384.      *             Use Widget::optionSelected() instead.
  2385.      */
  2386.     public static function optionSelected($strOption, $varValues)
  2387.     {
  2388.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::optionSelected()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Widget::optionSelected()" instead.');
  2390.         return Widget::optionSelected($strOption, $varValues);
  2391.     }
  2393.     /**
  2394.      * Return a "checked" attribute if the option is checked
  2395.      *
  2396.      * @param string $strOption The option to check
  2397.      * @param mixed  $varValues One or more values to check against
  2398.      *
  2399.      * @return string The attribute or an empty string
  2400.      *
  2401.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2402.      *             Use Widget::optionChecked() instead.
  2403.      */
  2404.     public static function optionChecked($strOption, $varValues)
  2405.     {
  2406.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::optionChecked()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Widget::optionChecked()" instead.');
  2408.         return Widget::optionChecked($strOption, $varValues);
  2409.     }
  2411.     /**
  2412.      * Find a content element in the TL_CTE array and return the class name
  2413.      *
  2414.      * @param string $strName The content element name
  2415.      *
  2416.      * @return string The class name
  2417.      *
  2418.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2419.      *             Use ContentElement::findClass() instead.
  2420.      */
  2421.     public static function findContentElement($strName)
  2422.     {
  2423.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::findContentElement()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\ContentElement::findClass()" instead.');
  2425.         return ContentElement::findClass($strName);
  2426.     }
  2428.     /**
  2429.      * Find a front end module in the FE_MOD array and return the class name
  2430.      *
  2431.      * @param string $strName The front end module name
  2432.      *
  2433.      * @return string The class name
  2434.      *
  2435.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2436.      *             Use Module::findClass() instead.
  2437.      */
  2438.     public static function findFrontendModule($strName)
  2439.     {
  2440.         trigger_deprecation('contao/core-bundle', '4.0', 'Using Contao\Controller::findFrontendModule() has been deprecated and will no longer work in Contao 5.0. Use Contao\Module::findClass() instead.');
  2442.         return Module::findClass($strName);
  2443.     }
  2445.     /**
  2446.      * Create an initial version of a record
  2447.      *
  2448.      * @param string  $strTable The table name
  2449.      * @param integer $intId    The ID of the element to be versioned
  2450.      *
  2451.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2452.      *             Use Versions->initialize() instead.
  2453.      */
  2454.     protected function createInitialVersion($strTable, $intId)
  2455.     {
  2456.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::createInitialVersion()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Versions->initialize()" instead.');
  2458.         $objVersions = new Versions($strTable, $intId);
  2459.         $objVersions->initialize();
  2460.     }
  2462.     /**
  2463.      * Create a new version of a record
  2464.      *
  2465.      * @param string  $strTable The table name
  2466.      * @param integer $intId    The ID of the element to be versioned
  2467.      *
  2468.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2469.      *             Use Versions->create() instead.
  2470.      */
  2471.     protected function createNewVersion($strTable, $intId)
  2472.     {
  2473.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::createNewVersion()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Versions->create()" instead.');
  2475.         $objVersions = new Versions($strTable, $intId);
  2476.         $objVersions->create();
  2477.     }
  2479.     /**
  2480.      * Return the files matching a GLOB pattern
  2481.      *
  2482.      * @param string $pattern
  2483.      *
  2484.      * @return array|false
  2485.      */
  2486.     protected static function braceGlob($pattern)
  2487.     {
  2488.         // Use glob() if possible
  2489.         if (false === strpos($pattern, '/**/') && (\defined('GLOB_BRACE') || false === strpos($pattern, '{')))
  2490.         {
  2491.             return glob($pattern, \defined('GLOB_BRACE') ? GLOB_BRACE : 0);
  2492.         }
  2494.         $finder = new Finder();
  2495.         $regex = Glob::toRegex($pattern);
  2497.         // All files in the given template folder
  2498.         $filesIterator = $finder
  2499.             ->files()
  2500.             ->followLinks()
  2501.             ->sortByName()
  2502.             ->in(\dirname($pattern))
  2503.         ;
  2505.         // Match the actual regex and filter the files
  2506.         $filesIterator = $filesIterator->filter(static function (\SplFileInfo $info) use ($regex)
  2507.         {
  2508.             $path = $info->getPathname();
  2510.             return preg_match($regex, $path) && $info->isFile();
  2511.         });
  2513.         $files = iterator_to_array($filesIterator);
  2515.         return array_keys($files);
  2516.     }
  2517. }
  2519. class_alias(Controller::class, 'Controller');