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

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\Image\Studio\FigureBuilder;
  20. use Contao\CoreBundle\Image\Studio\Studio;
  21. use Contao\CoreBundle\Monolog\ContaoContext as ContaoMonologContext;
  22. use Contao\CoreBundle\Security\ContaoCorePermissions;
  23. use Contao\CoreBundle\Util\LocaleUtil;
  24. use Contao\CoreBundle\Util\SimpleTokenParser;
  25. use Contao\Database\Result;
  26. use Contao\Image\PictureConfiguration;
  27. use Contao\Model\Collection;
  28. use Imagine\Image\BoxInterface;
  29. use Psr\Log\LogLevel;
  30. use Symfony\Cmf\Component\Routing\RouteObjectInterface;
  31. use Symfony\Component\Finder\Finder;
  32. use Symfony\Component\Finder\Glob;
  34. /**
  35.  * Abstract parent class for Controllers
  36.  *
  37.  * Some of the methods have been made static in Contao 3 and can be used in
  38.  * non-object context as well.
  39.  *
  40.  * Usage:
  41.  *
  42.  *     echo Controller::getTheme();
  43.  *
  44.  * Inside a controller:
  45.  *
  46.  *     public function generate()
  47.  *     {
  48.  *         return $this->getArticle(2);
  49.  *     }
  50.  *
  51.  * @author Leo Feyer <https://github.com/leofeyer>
  52.  */
  53. abstract class Controller extends System
  54. {
  55.     /**
  56.      * @var array
  57.      */
  58.     protected static $arrQueryCache = array();
  60.     /**
  61.      * Find a particular template file and return its path
  62.      *
  63.      * @param string $strTemplate The name of the template
  64.      *
  65.      * @return string The path to the template file
  66.      *
  67.      * @throws \RuntimeException If the template group folder is insecure
  68.      */
  69.     public static function getTemplate($strTemplate)
  70.     {
  71.         $strTemplate = basename($strTemplate);
  73.         // Check for a theme folder
  74.         if (\defined('TL_MODE') && TL_MODE == 'FE')
  75.         {
  76.             /** @var PageModel $objPage */
  77.             global $objPage;
  79.             if ($objPage->templateGroup)
  80.             {
  81.                 if (Validator::isInsecurePath($objPage->templateGroup))
  82.                 {
  83.                     throw new \RuntimeException('Invalid path ' . $objPage->templateGroup);
  84.                 }
  86.                 return TemplateLoader::getPath($strTemplate, 'html5', $objPage->templateGroup);
  87.             }
  88.         }
  90.         return TemplateLoader::getPath($strTemplate, 'html5');
  91.     }
  93.     /**
  94.      * Return all template files of a particular group as array
  95.      *
  96.      * @param string $strPrefix           The template name prefix (e.g. "ce_")
  97.      * @param array  $arrAdditionalMapper An additional mapper array
  98.      * @param string $strDefaultTemplate  An optional default template
  99.      *
  100.      * @return array An array of template names
  101.      */
  102.     public static function getTemplateGroup($strPrefix, array $arrAdditionalMapper=array(), $strDefaultTemplate='')
  103.     {
  104.         $arrTemplates = array();
  105.         $arrBundleTemplates = array();
  107.         $arrMapper = array_merge
  108.         (
  109.             $arrAdditionalMapper,
  110.             array
  111.             (
  112.                 'ce' => array_keys(array_merge(...array_values($GLOBALS['TL_CTE']))),
  113.                 'form' => array_keys($GLOBALS['TL_FFL']),
  114.                 'mod' => array_keys(array_merge(...array_values($GLOBALS['FE_MOD']))),
  115.             )
  116.         );
  118.         // Add templates that are not directly associated with a form field
  119.         $arrMapper['form'][] = 'row';
  120.         $arrMapper['form'][] = 'row_double';
  121.         $arrMapper['form'][] = 'xml';
  122.         $arrMapper['form'][] = 'wrapper';
  123.         $arrMapper['form'][] = 'message';
  124.         $arrMapper['form'][] = 'textfield'; // TODO: remove in Contao 5.0
  126.         // Add templates that are not directly associated with a module
  127.         $arrMapper['mod'][] = 'article';
  128.         $arrMapper['mod'][] = 'message';
  129.         $arrMapper['mod'][] = 'password'; // TODO: remove in Contao 5.0
  130.         $arrMapper['mod'][] = 'comment_form'; // TODO: remove in Contao 5.0
  131.         $arrMapper['mod'][] = 'newsletter'; // TODO: remove in Contao 5.0
  133.         // Get the default templates
  134.         foreach (TemplateLoader::getPrefixedFiles($strPrefix) as $strTemplate)
  135.         {
  136.             if ($strTemplate != $strPrefix)
  137.             {
  138.                 list($k, $strKey) = explode('_', $strTemplate, 2);
  140.                 if (isset($arrMapper[$k]) && \in_array($strKey, $arrMapper[$k]))
  141.                 {
  142.                     $arrBundleTemplates[] = $strTemplate;
  143.                     continue;
  144.                 }
  145.             }
  147.             $arrTemplates[$strTemplate][] = 'root';
  148.         }
  150.         $strGlobPrefix = $strPrefix;
  152.         // Backwards compatibility (see #725)
  153.         if (substr($strGlobPrefix, -1) == '_')
  154.         {
  155.             $strGlobPrefix = substr($strGlobPrefix, 0, -1) . '[_-]';
  156.         }
  158.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  159.         $arrCustomized = self::braceGlob($projectDir . '/templates/' . $strGlobPrefix . '*.html5');
  161.         // Add the customized templates
  162.         if (!empty($arrCustomized) && \is_array($arrCustomized))
  163.         {
  164.             $blnIsGroupPrefix = preg_match('/^[a-z]+_$/', $strPrefix);
  166.             foreach ($arrCustomized as $strFile)
  167.             {
  168.                 $strTemplate = basename($strFile, strrchr($strFile, '.'));
  170.                 if (strpos($strTemplate, '-') !== false)
  171.                 {
  172.                     trigger_deprecation('contao/core-bundle', '4.9', 'Using hyphens in the template name "' . $strTemplate . '.html5" has been deprecated and will no longer work in Contao 5.0. Use snake_case instead.');
  173.                 }
  175.                 // Ignore bundle templates, e.g. mod_article and mod_article_list
  176.                 if (\in_array($strTemplate, $arrBundleTemplates))
  177.                 {
  178.                     continue;
  179.                 }
  181.                 // Also ignore custom templates belonging to a different bundle template,
  182.                 // e.g. mod_article and mod_article_list_custom
  183.                 if (!$blnIsGroupPrefix)
  184.                 {
  185.                     foreach ($arrBundleTemplates as $strKey)
  186.                     {
  187.                         if (strpos($strTemplate, $strKey . '_') === 0)
  188.                         {
  189.                             continue 2;
  190.                         }
  191.                     }
  192.                 }
  194.                 $arrTemplates[$strTemplate][] = $GLOBALS['TL_LANG']['MSC']['global'];
  195.             }
  196.         }
  198.         $arrDefaultPlaces = array();
  200.         if ($strDefaultTemplate)
  201.         {
  202.             $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['default'];
  204.             if (file_exists($projectDir . '/templates/' . $strDefaultTemplate . '.html5'))
  205.             {
  206.                 $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['global'];
  207.             }
  208.         }
  210.         // Do not look for back end templates in theme folders (see #5379)
  211.         if ($strPrefix != 'be_' && $strPrefix != 'mail_')
  212.         {
  213.             // Try to select the themes (see #5210)
  214.             try
  215.             {
  216.                 $objTheme = ThemeModel::findAll(array('order'=>'name'));
  217.             }
  218.             catch (\Exception $e)
  219.             {
  220.                 $objTheme = null;
  221.             }
  223.             // Add the theme templates
  224.             if ($objTheme !== null)
  225.             {
  226.                 while ($objTheme->next())
  227.                 {
  228.                     if (!$objTheme->templates)
  229.                     {
  230.                         continue;
  231.                     }
  233.                     if ($strDefaultTemplate && file_exists($projectDir . '/' . $objTheme->templates . '/' . $strDefaultTemplate . '.html5'))
  234.                     {
  235.                         $arrDefaultPlaces[] = $objTheme->name;
  236.                     }
  238.                     $arrThemeTemplates = self::braceGlob($projectDir . '/' . $objTheme->templates . '/' . $strGlobPrefix . '*.html5');
  240.                     if (!empty($arrThemeTemplates) && \is_array($arrThemeTemplates))
  241.                     {
  242.                         foreach ($arrThemeTemplates as $strFile)
  243.                         {
  244.                             $strTemplate = basename($strFile, strrchr($strFile, '.'));
  245.                             $arrTemplates[$strTemplate][] = $objTheme->name;
  246.                         }
  247.                     }
  248.                 }
  249.             }
  250.         }
  252.         // Show the template sources (see #6875)
  253.         foreach ($arrTemplates as $k=>$v)
  254.         {
  255.             $v = array_filter($v, static function ($a)
  256.             {
  257.                 return $a != 'root';
  258.             });
  260.             if (empty($v))
  261.             {
  262.                 $arrTemplates[$k] = $k;
  263.             }
  264.             else
  265.             {
  266.                 $arrTemplates[$k] = $k . ' (' . implode(', ', $v) . ')';
  267.             }
  268.         }
  270.         // Sort the template names
  271.         ksort($arrTemplates);
  273.         if ($strDefaultTemplate)
  274.         {
  275.             if (!empty($arrDefaultPlaces))
  276.             {
  277.                 $strDefaultTemplate .= ' (' . implode(', ', $arrDefaultPlaces) . ')';
  278.             }
  280.             $arrTemplates = array('' => $strDefaultTemplate) + $arrTemplates;
  281.         }
  283.         return $arrTemplates;
  284.     }
  286.     /**
  287.      * Generate a front end module and return it as string
  288.      *
  289.      * @param mixed  $intId     A module ID or a Model object
  290.      * @param string $strColumn The name of the column
  291.      *
  292.      * @return string The module HTML markup
  293.      */
  294.     public static function getFrontendModule($intId, $strColumn='main')
  295.     {
  296.         if (!\is_object($intId) && !\strlen($intId))
  297.         {
  298.             return '';
  299.         }
  301.         /** @var PageModel $objPage */
  302.         global $objPage;
  304.         // Articles
  305.         if (!\is_object($intId) && $intId == 0)
  306.         {
  307.             // Show a particular article only
  308.             if ($objPage->type == 'regular' && Input::get('articles'))
  309.             {
  310.                 list($strSection, $strArticle) = explode(':', Input::get('articles'));
  312.                 if ($strArticle === null)
  313.                 {
  314.                     $strArticle = $strSection;
  315.                     $strSection = 'main';
  316.                 }
  318.                 if ($strSection == $strColumn)
  319.                 {
  320.                     $objArticle = ArticleModel::findPublishedByIdOrAliasAndPid($strArticle, $objPage->id);
  322.                     // Send a 404 header if there is no published article
  323.                     if (null === $objArticle)
  324.                     {
  325.                         throw new PageNotFoundException('Page not found: ' . Environment::get('uri'));
  326.                     }
  328.                     // Send a 403 header if the article cannot be accessed
  329.                     if (!static::isVisibleElement($objArticle))
  330.                     {
  331.                         throw new AccessDeniedException('Access denied: ' . Environment::get('uri'));
  332.                     }
  334.                     return static::getArticle($objArticle);
  335.                 }
  336.             }
  338.             // HOOK: add custom logic
  339.             if (isset($GLOBALS['TL_HOOKS']['getArticles']) && \is_array($GLOBALS['TL_HOOKS']['getArticles']))
  340.             {
  341.                 foreach ($GLOBALS['TL_HOOKS']['getArticles'] as $callback)
  342.                 {
  343.                     $return = static::importStatic($callback[0])->{$callback[1]}($objPage->id, $strColumn);
  345.                     if (\is_string($return))
  346.                     {
  347.                         return $return;
  348.                     }
  349.                 }
  350.             }
  352.             // Show all articles (no else block here, see #4740)
  353.             $objArticles = ArticleModel::findPublishedByPidAndColumn($objPage->id, $strColumn);
  355.             if ($objArticles === null)
  356.             {
  357.                 return '';
  358.             }
  360.             $return = '';
  361.             $blnMultiMode = ($objArticles->count() > 1);
  363.             while ($objArticles->next())
  364.             {
  365.                 $return .= static::getArticle($objArticles->current(), $blnMultiMode, false, $strColumn);
  366.             }
  368.             return $return;
  369.         }
  371.         // Other modules
  372.         if (\is_object($intId))
  373.         {
  374.             $objRow = $intId;
  375.         }
  376.         else
  377.         {
  378.             $objRow = ModuleModel::findByPk($intId);
  380.             if ($objRow === null)
  381.             {
  382.                 return '';
  383.             }
  384.         }
  386.         // Check the visibility (see #6311)
  387.         if (!static::isVisibleElement($objRow))
  388.         {
  389.             return '';
  390.         }
  392.         $strClass = Module::findClass($objRow->type);
  394.         // Return if the class does not exist
  395.         if (!class_exists($strClass))
  396.         {
  397.             static::log('Module class "' . $strClass . '" (module "' . $objRow->type . '") does not exist', __METHOD__, TL_ERROR);
  399.             return '';
  400.         }
  402.         $strStopWatchId = 'contao.frontend_module.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  404.         if (System::getContainer()->getParameter('kernel.debug'))
  405.         {
  406.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  407.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  408.         }
  410.         $objRow->typePrefix = 'mod_';
  412.         /** @var Module $objModule */
  413.         $objModule = new $strClass($objRow, $strColumn);
  414.         $strBuffer = $objModule->generate();
  416.         // HOOK: add custom logic
  417.         if (isset($GLOBALS['TL_HOOKS']['getFrontendModule']) && \is_array($GLOBALS['TL_HOOKS']['getFrontendModule']))
  418.         {
  419.             foreach ($GLOBALS['TL_HOOKS']['getFrontendModule'] as $callback)
  420.             {
  421.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objModule);
  422.             }
  423.         }
  425.         // Disable indexing if protected
  426.         if ($objModule->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  427.         {
  428.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  429.         }
  431.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  432.         {
  433.             $objStopwatch->stop($strStopWatchId);
  434.         }
  436.         return $strBuffer;
  437.     }
  439.     /**
  440.      * Generate an article and return it as string
  441.      *
  442.      * @param mixed   $varId          The article ID or a Model object
  443.      * @param boolean $blnMultiMode   If true, only teasers will be shown
  444.      * @param boolean $blnIsInsertTag If true, there will be no page relation
  445.      * @param string  $strColumn      The name of the column
  446.      *
  447.      * @return string|boolean The article HTML markup or false
  448.      */
  449.     public static function getArticle($varId, $blnMultiMode=false, $blnIsInsertTag=false, $strColumn='main')
  450.     {
  451.         /** @var PageModel $objPage */
  452.         global $objPage;
  454.         if (\is_object($varId))
  455.         {
  456.             $objRow = $varId;
  457.         }
  458.         else
  459.         {
  460.             if (!$varId)
  461.             {
  462.                 return '';
  463.             }
  465.             $objRow = ArticleModel::findByIdOrAliasAndPid($varId, (!$blnIsInsertTag ? $objPage->id : null));
  467.             if ($objRow === null)
  468.             {
  469.                 return false;
  470.             }
  471.         }
  473.         // Check the visibility (see #6311)
  474.         if (!static::isVisibleElement($objRow))
  475.         {
  476.             return '';
  477.         }
  479.         // Print the article as PDF
  480.         if (isset($_GET['pdf']) && Input::get('pdf') == $objRow->id)
  481.         {
  482.             // Deprecated since Contao 4.0, to be removed in Contao 5.0
  483.             if ($objRow->printable == 1)
  484.             {
  485.                 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.');
  487.                 $objArticle = new ModuleArticle($objRow);
  488.                 $objArticle->generatePdf();
  489.             }
  490.             elseif ($objRow->printable)
  491.             {
  492.                 $options = StringUtil::deserialize($objRow->printable);
  494.                 if (\is_array($options) && \in_array('pdf', $options))
  495.                 {
  496.                     $objArticle = new ModuleArticle($objRow);
  497.                     $objArticle->generatePdf();
  498.                 }
  499.             }
  500.         }
  502.         $objRow->headline = $objRow->title;
  503.         $objRow->multiMode = $blnMultiMode;
  505.         // HOOK: add custom logic
  506.         if (isset($GLOBALS['TL_HOOKS']['getArticle']) && \is_array($GLOBALS['TL_HOOKS']['getArticle']))
  507.         {
  508.             foreach ($GLOBALS['TL_HOOKS']['getArticle'] as $callback)
  509.             {
  510.                 static::importStatic($callback[0])->{$callback[1]}($objRow);
  511.             }
  512.         }
  514.         $strStopWatchId = 'contao.article (ID ' . $objRow->id . ')';
  516.         if (System::getContainer()->getParameter('kernel.debug'))
  517.         {
  518.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  519.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  520.         }
  522.         $objArticle = new ModuleArticle($objRow, $strColumn);
  523.         $strBuffer = $objArticle->generate($blnIsInsertTag);
  525.         // Disable indexing if protected
  526.         if ($objArticle->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  527.         {
  528.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  529.         }
  531.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  532.         {
  533.             $objStopwatch->stop($strStopWatchId);
  534.         }
  536.         return $strBuffer;
  537.     }
  539.     /**
  540.      * Generate a content element and return it as string
  541.      *
  542.      * @param mixed  $intId     A content element ID or a Model object
  543.      * @param string $strColumn The column the element is in
  544.      *
  545.      * @return string The content element HTML markup
  546.      */
  547.     public static function getContentElement($intId, $strColumn='main')
  548.     {
  549.         if (\is_object($intId))
  550.         {
  551.             $objRow = $intId;
  552.         }
  553.         else
  554.         {
  555.             if ($intId < 1 || !\strlen($intId))
  556.             {
  557.                 return '';
  558.             }
  560.             $objRow = ContentModel::findByPk($intId);
  562.             if ($objRow === null)
  563.             {
  564.                 return '';
  565.             }
  566.         }
  568.         // Check the visibility (see #6311)
  569.         if (!static::isVisibleElement($objRow))
  570.         {
  571.             return '';
  572.         }
  574.         $strClass = ContentElement::findClass($objRow->type);
  576.         // Return if the class does not exist
  577.         if (!class_exists($strClass))
  578.         {
  579.             static::log('Content element class "' . $strClass . '" (content element "' . $objRow->type . '") does not exist', __METHOD__, TL_ERROR);
  581.             return '';
  582.         }
  584.         $objRow->typePrefix = 'ce_';
  585.         $strStopWatchId = 'contao.content_element.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  587.         if ($objRow->type != 'module' && System::getContainer()->getParameter('kernel.debug'))
  588.         {
  589.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  590.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  591.         }
  593.         /** @var ContentElement $objElement */
  594.         $objElement = new $strClass($objRow, $strColumn);
  595.         $strBuffer = $objElement->generate();
  597.         // HOOK: add custom logic
  598.         if (isset($GLOBALS['TL_HOOKS']['getContentElement']) && \is_array($GLOBALS['TL_HOOKS']['getContentElement']))
  599.         {
  600.             foreach ($GLOBALS['TL_HOOKS']['getContentElement'] as $callback)
  601.             {
  602.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  603.             }
  604.         }
  606.         // Disable indexing if protected
  607.         if ($objElement->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  608.         {
  609.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  610.         }
  612.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  613.         {
  614.             $objStopwatch->stop($strStopWatchId);
  615.         }
  617.         return $strBuffer;
  618.     }
  620.     /**
  621.      * Generate a form and return it as string
  622.      *
  623.      * @param mixed   $varId     A form ID or a Model object
  624.      * @param string  $strColumn The column the form is in
  625.      * @param boolean $blnModule Render the form as module
  626.      *
  627.      * @return string The form HTML markup
  628.      */
  629.     public static function getForm($varId, $strColumn='main', $blnModule=false)
  630.     {
  631.         if (\is_object($varId))
  632.         {
  633.             $objRow = $varId;
  634.         }
  635.         else
  636.         {
  637.             if (!$varId)
  638.             {
  639.                 return '';
  640.             }
  642.             $objRow = FormModel::findByIdOrAlias($varId);
  644.             if ($objRow === null)
  645.             {
  646.                 return '';
  647.             }
  648.         }
  650.         $strClass = $blnModule ? Module::findClass('form') : ContentElement::findClass('form');
  652.         if (!class_exists($strClass))
  653.         {
  654.             static::log('Form class "' . $strClass . '" does not exist', __METHOD__, TL_ERROR);
  656.             return '';
  657.         }
  659.         $objRow->typePrefix = $blnModule ? 'mod_' : 'ce_';
  660.         $objRow->form = $objRow->id;
  662.         /** @var Form $objElement */
  663.         $objElement = new $strClass($objRow, $strColumn);
  664.         $strBuffer = $objElement->generate();
  666.         // HOOK: add custom logic
  667.         if (isset($GLOBALS['TL_HOOKS']['getForm']) && \is_array($GLOBALS['TL_HOOKS']['getForm']))
  668.         {
  669.             foreach ($GLOBALS['TL_HOOKS']['getForm'] as $callback)
  670.             {
  671.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  672.             }
  673.         }
  675.         return $strBuffer;
  676.     }
  678.     /**
  679.      * Return the languages for the TinyMCE spellchecker
  680.      *
  681.      * @return string The TinyMCE spellchecker language string
  682.      */
  683.     protected function getSpellcheckerString()
  684.     {
  685.         System::loadLanguageFile('languages');
  687.         $return = array();
  688.         $langs = Folder::scan(__DIR__ . '/../../languages');
  689.         array_unshift($langs, $GLOBALS['TL_LANGUAGE']);
  691.         foreach ($langs as $lang)
  692.         {
  693.             $lang = substr($lang, 0, 2);
  695.             if (isset($GLOBALS['TL_LANG']['LNG'][$lang]))
  696.             {
  697.                 $return[$lang] = $GLOBALS['TL_LANG']['LNG'][$lang] . '=' . $lang;
  698.             }
  699.         }
  701.         return '+' . implode(',', array_unique($return));
  702.     }
  704.     /**
  705.      * Calculate the page status icon name based on the page parameters
  706.      *
  707.      * @param PageModel|Result|\stdClass $objPage The page object
  708.      *
  709.      * @return string The status icon name
  710.      */
  711.     public static function getPageStatusIcon($objPage)
  712.     {
  713.         $sub = 0;
  714.         $type = \in_array($objPage->type, array('regular', 'root', 'forward', 'redirect', 'error_401', 'error_403', 'error_404'), true) ? $objPage->type : 'regular';
  715.         $image = $type . '.svg';
  717.         // Page not published or not active
  718.         if (!$objPage->published || ($objPage->start && $objPage->start > time()) || ($objPage->stop && $objPage->stop <= time()))
  719.         {
  720.             ++$sub;
  721.         }
  723.         // Page hidden from menu
  724.         if ($objPage->hide && !\in_array($type, array('root', 'error_401', 'error_403', 'error_404')))
  725.         {
  726.             $sub += 2;
  727.         }
  729.         // Page protected
  730.         if ($objPage->protected && !\in_array($type, array('root', 'error_401', 'error_403', 'error_404')))
  731.         {
  732.             $sub += 4;
  733.         }
  735.         // Get the image name
  736.         if ($sub > 0)
  737.         {
  738.             $image = $type . '_' . $sub . '.svg';
  739.         }
  741.         // HOOK: add custom logic
  742.         if (isset($GLOBALS['TL_HOOKS']['getPageStatusIcon']) && \is_array($GLOBALS['TL_HOOKS']['getPageStatusIcon']))
  743.         {
  744.             foreach ($GLOBALS['TL_HOOKS']['getPageStatusIcon'] as $callback)
  745.             {
  746.                 $image = static::importStatic($callback[0])->{$callback[1]}($objPage, $image);
  747.             }
  748.         }
  750.         return $image;
  751.     }
  753.     /**
  754.      * Check whether an element is visible in the front end
  755.      *
  756.      * @param Model|ContentModel|ModuleModel $objElement The element model
  757.      *
  758.      * @return boolean True if the element is visible
  759.      */
  760.     public static function isVisibleElement(Model $objElement)
  761.     {
  762.         $blnReturn = true;
  764.         // Only apply the restrictions in the front end
  765.         if (TL_MODE == 'FE')
  766.         {
  767.             $security = System::getContainer()->get('security.helper');
  769.             if ($objElement->protected)
  770.             {
  771.                 $groups = StringUtil::deserialize($objElement->groups, true);
  772.                 $blnReturn = $security->isGranted(ContaoCorePermissions::MEMBER_IN_GROUPS, $groups);
  773.             }
  774.             elseif ($objElement->guests)
  775.             {
  776.                 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.');
  777.                 $blnReturn = !$security->isGranted('ROLE_MEMBER'); // backwards compatibility
  778.             }
  779.         }
  781.         // HOOK: add custom logic
  782.         if (isset($GLOBALS['TL_HOOKS']['isVisibleElement']) && \is_array($GLOBALS['TL_HOOKS']['isVisibleElement']))
  783.         {
  784.             foreach ($GLOBALS['TL_HOOKS']['isVisibleElement'] as $callback)
  785.             {
  786.                 $blnReturn = static::importStatic($callback[0])->{$callback[1]}($objElement, $blnReturn);
  787.             }
  788.         }
  790.         return $blnReturn;
  791.     }
  793.     /**
  794.      * Replace insert tags with their values
  795.      *
  796.      * @param string  $strBuffer The text with the tags to be replaced
  797.      * @param boolean $blnCache  If false, non-cacheable tags will be replaced
  798.      *
  799.      * @return string The text with the replaced tags
  800.      */
  801.     public static function replaceInsertTags($strBuffer, $blnCache=true)
  802.     {
  803.         $objIt = new InsertTags();
  805.         return $objIt->replace($strBuffer, $blnCache);
  806.     }
  808.     /**
  809.      * Replace the dynamic script tags (see #4203)
  810.      *
  811.      * @param string $strBuffer The string with the tags to be replaced
  812.      *
  813.      * @return string The string with the replaced tags
  814.      */
  815.     public static function replaceDynamicScriptTags($strBuffer)
  816.     {
  817.         // HOOK: add custom logic
  818.         if (isset($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']) && \is_array($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']))
  819.         {
  820.             foreach ($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags'] as $callback)
  821.             {
  822.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($strBuffer);
  823.             }
  824.         }
  826.         $arrReplace = array();
  827.         $strScripts = '';
  829.         // Add the internal jQuery scripts
  830.         if (!empty($GLOBALS['TL_JQUERY']) && \is_array($GLOBALS['TL_JQUERY']))
  831.         {
  832.             foreach (array_unique($GLOBALS['TL_JQUERY']) as $script)
  833.             {
  834.                 $strScripts .= $script;
  835.             }
  836.         }
  838.         $arrReplace['[[TL_JQUERY]]'] = $strScripts;
  839.         $strScripts = '';
  841.         // Add the internal MooTools scripts
  842.         if (!empty($GLOBALS['TL_MOOTOOLS']) && \is_array($GLOBALS['TL_MOOTOOLS']))
  843.         {
  844.             foreach (array_unique($GLOBALS['TL_MOOTOOLS']) as $script)
  845.             {
  846.                 $strScripts .= $script;
  847.             }
  848.         }
  850.         $arrReplace['[[TL_MOOTOOLS]]'] = $strScripts;
  851.         $strScripts = '';
  853.         // Add the internal <body> tags
  854.         if (!empty($GLOBALS['TL_BODY']) && \is_array($GLOBALS['TL_BODY']))
  855.         {
  856.             foreach (array_unique($GLOBALS['TL_BODY']) as $script)
  857.             {
  858.                 $strScripts .= $script;
  859.             }
  860.         }
  862.         /** @var PageModel|null $objPage */
  863.         global $objPage;
  865.         $objLayout = ($objPage !== null) ? LayoutModel::findByPk($objPage->layoutId) : null;
  866.         $blnCombineScripts = ($objLayout === null) ? false : $objLayout->combineScripts;
  868.         $arrReplace['[[TL_BODY]]'] = $strScripts;
  869.         $strScripts = '';
  871.         $objCombiner = new Combiner();
  873.         // Add the CSS framework style sheets
  874.         if (!empty($GLOBALS['TL_FRAMEWORK_CSS']) && \is_array($GLOBALS['TL_FRAMEWORK_CSS']))
  875.         {
  876.             foreach (array_unique($GLOBALS['TL_FRAMEWORK_CSS']) as $stylesheet)
  877.             {
  878.                 $objCombiner->add($stylesheet);
  879.             }
  880.         }
  882.         // Add the internal style sheets
  883.         if (!empty($GLOBALS['TL_CSS']) && \is_array($GLOBALS['TL_CSS']))
  884.         {
  885.             foreach (array_unique($GLOBALS['TL_CSS']) as $stylesheet)
  886.             {
  887.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  889.                 if ($options->static)
  890.                 {
  891.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  892.                 }
  893.                 else
  894.                 {
  895.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  896.                 }
  897.             }
  898.         }
  900.         // Add the user style sheets
  901.         if (!empty($GLOBALS['TL_USER_CSS']) && \is_array($GLOBALS['TL_USER_CSS']))
  902.         {
  903.             foreach (array_unique($GLOBALS['TL_USER_CSS']) as $stylesheet)
  904.             {
  905.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  907.                 if ($options->static)
  908.                 {
  909.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  910.                 }
  911.                 else
  912.                 {
  913.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  914.                 }
  915.             }
  916.         }
  918.         // Create the aggregated style sheet
  919.         if ($objCombiner->hasEntries())
  920.         {
  921.             if ($blnCombineScripts)
  922.             {
  923.                 $strScripts .= Template::generateStyleTag($objCombiner->getCombinedFile(), 'all');
  924.             }
  925.             else
  926.             {
  927.                 foreach ($objCombiner->getFileUrls() as $strUrl)
  928.                 {
  929.                     $options = StringUtil::resolveFlaggedUrl($strUrl);
  930.                     $strScripts .= Template::generateStyleTag($strUrl, $options->media, $options->mtime);
  931.                 }
  932.             }
  933.         }
  935.         $arrReplace['[[TL_CSS]]'] = $strScripts;
  936.         $strScripts = '';
  938.         // Add the internal scripts
  939.         if (!empty($GLOBALS['TL_JAVASCRIPT']) && \is_array($GLOBALS['TL_JAVASCRIPT']))
  940.         {
  941.             $objCombiner = new Combiner();
  942.             $objCombinerAsync = new Combiner();
  944.             foreach (array_unique($GLOBALS['TL_JAVASCRIPT']) as $javascript)
  945.             {
  946.                 $options = StringUtil::resolveFlaggedUrl($javascript);
  948.                 if ($options->static)
  949.                 {
  950.                     $options->async ? $objCombinerAsync->add($javascript, $options->mtime) : $objCombiner->add($javascript, $options->mtime);
  951.                 }
  952.                 else
  953.                 {
  954.                     $strScripts .= Template::generateScriptTag(static::addAssetsUrlTo($javascript), $options->async, $options->mtime);
  955.                 }
  956.             }
  958.             // Create the aggregated script and add it before the non-static scripts (see #4890)
  959.             if ($objCombiner->hasEntries())
  960.             {
  961.                 if ($blnCombineScripts)
  962.                 {
  963.                     $strScripts = Template::generateScriptTag($objCombiner->getCombinedFile()) . $strScripts;
  964.                 }
  965.                 else
  966.                 {
  967.                     $arrReversed = array_reverse($objCombiner->getFileUrls());
  969.                     foreach ($arrReversed as $strUrl)
  970.                     {
  971.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  972.                         $strScripts = Template::generateScriptTag($strUrl, false, $options->mtime) . $strScripts;
  973.                     }
  974.                 }
  975.             }
  977.             if ($objCombinerAsync->hasEntries())
  978.             {
  979.                 if ($blnCombineScripts)
  980.                 {
  981.                     $strScripts = Template::generateScriptTag($objCombinerAsync->getCombinedFile(), true) . $strScripts;
  982.                 }
  983.                 else
  984.                 {
  985.                     $arrReversed = array_reverse($objCombinerAsync->getFileUrls());
  987.                     foreach ($arrReversed as $strUrl)
  988.                     {
  989.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  990.                         $strScripts = Template::generateScriptTag($strUrl, true, $options->mtime) . $strScripts;
  991.                     }
  992.                 }
  993.             }
  994.         }
  996.         // Add the internal <head> tags
  997.         if (!empty($GLOBALS['TL_HEAD']) && \is_array($GLOBALS['TL_HEAD']))
  998.         {
  999.             foreach (array_unique($GLOBALS['TL_HEAD']) as $head)
  1000.             {
  1001.                 $strScripts .= $head;
  1002.             }
  1003.         }
  1005.         $arrReplace['[[TL_HEAD]]'] = $strScripts;
  1007.         return str_replace(array_keys($arrReplace), $arrReplace, $strBuffer);
  1008.     }
  1010.     /**
  1011.      * Compile the margin format definition based on an array of values
  1012.      *
  1013.      * @param array  $arrValues An array of four values and a unit
  1014.      * @param string $strType   Either "margin" or "padding"
  1015.      *
  1016.      * @return string The CSS markup
  1017.      */
  1018.     public static function generateMargin($arrValues, $strType='margin')
  1019.     {
  1020.         // Initialize an empty array (see #5217)
  1021.         if (!\is_array($arrValues))
  1022.         {
  1023.             $arrValues = array('top'=>'', 'right'=>'', 'bottom'=>'', 'left'=>'', 'unit'=>'');
  1024.         }
  1026.         $top = $arrValues['top'];
  1027.         $right = $arrValues['right'];
  1028.         $bottom = $arrValues['bottom'];
  1029.         $left = $arrValues['left'];
  1031.         // Try to shorten the definition
  1032.         if ($top && $right  && $bottom  && $left)
  1033.         {
  1034.             if ($top == $right && $top == $bottom && $top == $left)
  1035.             {
  1036.                 return $strType . ':' . $top . $arrValues['unit'] . ';';
  1037.             }
  1039.             if ($top == $bottom && $right == $left)
  1040.             {
  1041.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1042.             }
  1044.             if ($top != $bottom && $right == $left)
  1045.             {
  1046.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ';';
  1047.             }
  1049.             return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1050.         }
  1052.         $return = array();
  1053.         $arrDir = compact('top', 'right', 'bottom', 'left');
  1055.         foreach ($arrDir as $k=>$v)
  1056.         {
  1057.             if ($v)
  1058.             {
  1059.                 $return[] = $strType . '-' . $k . ':' . $v . $arrValues['unit'] . ';';
  1060.             }
  1061.         }
  1063.         return implode('', $return);
  1064.     }
  1066.     /**
  1067.      * Add a request string to the current URL
  1068.      *
  1069.      * @param string  $strRequest The string to be added
  1070.      * @param boolean $blnAddRef  Add the referer ID
  1071.      * @param array   $arrUnset   An optional array of keys to unset
  1072.      *
  1073.      * @return string The new URL
  1074.      */
  1075.     public static function addToUrl($strRequest, $blnAddRef=true, $arrUnset=array())
  1076.     {
  1077.         $pairs = array();
  1078.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  1080.         if ($request->server->has('QUERY_STRING'))
  1081.         {
  1082.             $cacheKey = md5($request->server->get('QUERY_STRING'));
  1084.             if (!isset(static::$arrQueryCache[$cacheKey]))
  1085.             {
  1086.                 parse_str($request->server->get('QUERY_STRING'), $pairs);
  1087.                 ksort($pairs);
  1089.                 static::$arrQueryCache[$cacheKey] = $pairs;
  1090.             }
  1092.             $pairs = static::$arrQueryCache[$cacheKey];
  1093.         }
  1095.         // Remove the request token and referer ID
  1096.         unset($pairs['rt'], $pairs['ref']);
  1098.         foreach ($arrUnset as $key)
  1099.         {
  1100.             unset($pairs[$key]);
  1101.         }
  1103.         // Merge the request string to be added
  1104.         if ($strRequest)
  1105.         {
  1106.             parse_str(str_replace('&amp;', '&', $strRequest), $newPairs);
  1107.             $pairs = array_merge($pairs, $newPairs);
  1108.         }
  1110.         // Add the referer ID
  1111.         if ($request->query->has('ref') || ($strRequest && $blnAddRef))
  1112.         {
  1113.             $pairs['ref'] = $request->attributes->get('_contao_referer_id');
  1114.         }
  1116.         $uri = '';
  1118.         if (!empty($pairs))
  1119.         {
  1120.             $uri = '?' . http_build_query($pairs, '', '&amp;', PHP_QUERY_RFC3986);
  1121.         }
  1123.         return TL_SCRIPT . $uri;
  1124.     }
  1126.     /**
  1127.      * Reload the current page
  1128.      */
  1129.     public static function reload()
  1130.     {
  1131.         static::redirect(Environment::get('uri'));
  1132.     }
  1134.     /**
  1135.      * Redirect to another page
  1136.      *
  1137.      * @param string  $strLocation The target URL
  1138.      * @param integer $intStatus   The HTTP status code (defaults to 303)
  1139.      */
  1140.     public static function redirect($strLocation, $intStatus=303)
  1141.     {
  1142.         $strLocation = str_replace('&amp;', '&', $strLocation);
  1143.         $strLocation = static::replaceOldBePaths($strLocation);
  1145.         // Make the location an absolute URL
  1146.         if (!preg_match('@^https?://@i', $strLocation))
  1147.         {
  1148.             $strLocation = Environment::get('base') . ltrim($strLocation, '/');
  1149.         }
  1151.         // Ajax request
  1152.         if (Environment::get('isAjaxRequest'))
  1153.         {
  1154.             throw new AjaxRedirectResponseException($strLocation);
  1155.         }
  1157.         throw new RedirectResponseException($strLocation, $intStatus);
  1158.     }
  1160.     /**
  1161.      * Replace the old back end paths
  1162.      *
  1163.      * @param string $strContext The context
  1164.      *
  1165.      * @return string The modified context
  1166.      */
  1167.     protected static function replaceOldBePaths($strContext)
  1168.     {
  1169.         $router = System::getContainer()->get('router');
  1171.         $generate = static function ($route) use ($router)
  1172.         {
  1173.             return substr($router->generate($route), \strlen(Environment::get('path')) + 1);
  1174.         };
  1176.         $arrMapper = array
  1177.         (
  1178.             'contao/confirm.php'   => $generate('contao_backend_confirm'),
  1179.             'contao/file.php'      => $generate('contao_backend_file'),
  1180.             'contao/help.php'      => $generate('contao_backend_help'),
  1181.             'contao/index.php'     => $generate('contao_backend_login'),
  1182.             'contao/main.php'      => $generate('contao_backend'),
  1183.             'contao/page.php'      => $generate('contao_backend_page'),
  1184.             'contao/password.php'  => $generate('contao_backend_password'),
  1185.             'contao/popup.php'     => $generate('contao_backend_popup'),
  1186.             'contao/preview.php'   => $generate('contao_backend_preview'),
  1187.         );
  1189.         return str_replace(array_keys($arrMapper), $arrMapper, $strContext);
  1190.     }
  1192.     /**
  1193.      * Generate a front end URL
  1194.      *
  1195.      * @param array   $arrRow       An array of page parameters
  1196.      * @param string  $strParams    An optional string of URL parameters
  1197.      * @param string  $strForceLang Force a certain language
  1198.      * @param boolean $blnFixDomain Check the domain of the target page and append it if necessary
  1199.      *
  1200.      * @return string An URL that can be used in the front end
  1201.      *
  1202.      * @deprecated Deprecated since Contao 4.2, to be removed in Contao 5.0.
  1203.      *             Use PageModel::getFrontendUrl() instead.
  1204.      */
  1205.     public static function generateFrontendUrl(array $arrRow, $strParams=null, $strForceLang=null, $blnFixDomain=false)
  1206.     {
  1207.         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.');
  1209.         $page = new PageModel();
  1210.         $page->preventSaving(false);
  1211.         $page->setRow($arrRow);
  1213.         if (!isset($arrRow['rootId']))
  1214.         {
  1215.             $page->loadDetails();
  1217.             foreach (array('domain', 'rootLanguage', 'rootUseSSL') as $key)
  1218.             {
  1219.                 if (isset($arrRow[$key]))
  1220.                 {
  1221.                     $page->$key = $arrRow[$key];
  1222.                 }
  1223.                 else
  1224.                 {
  1225.                     $arrRow[$key] = $page->$key;
  1226.                 }
  1227.             }
  1228.         }
  1230.         // Set the language
  1231.         if ($strForceLang !== null)
  1232.         {
  1233.             $strForceLang = LocaleUtil::formatAsLocale($strForceLang);
  1235.             $page->language = $strForceLang;
  1236.             $page->rootLanguage = $strForceLang;
  1238.             if (System::getContainer()->getParameter('contao.legacy_routing'))
  1239.             {
  1240.                 $page->urlPrefix = System::getContainer()->getParameter('contao.prepend_locale') ? $strForceLang : '';
  1241.             }
  1242.         }
  1244.         // Add the domain if it differs from the current one (see #3765 and #6927)
  1245.         if ($blnFixDomain)
  1246.         {
  1247.             $page->domain = $arrRow['domain'];
  1248.             $page->rootUseSSL = (bool) $arrRow['rootUseSSL'];
  1249.         }
  1251.         $objRouter = System::getContainer()->get('router');
  1252.         $strUrl = $objRouter->generate(RouteObjectInterface::OBJECT_BASED_ROUTE_NAME, array(RouteObjectInterface::CONTENT_OBJECT => $page, 'parameters' => $strParams));
  1254.         // Remove path from absolute URLs
  1255.         if (0 === strncmp($strUrl, '/', 1) && 0 !== strncmp($strUrl, '//', 2))
  1256.         {
  1257.             $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  1258.         }
  1260.         // Decode sprintf placeholders
  1261.         if (strpos($strParams, '%') !== false)
  1262.         {
  1263.             $arrMatches = array();
  1264.             preg_match_all('/%([sducoxXbgGeEfF])/', $strParams, $arrMatches);
  1266.             foreach (array_unique($arrMatches[1]) as $v)
  1267.             {
  1268.                 $strUrl = str_replace('%25' . $v, '%' . $v, $strUrl);
  1269.             }
  1270.         }
  1272.         // HOOK: add custom logic
  1273.         if (isset($GLOBALS['TL_HOOKS']['generateFrontendUrl']) && \is_array($GLOBALS['TL_HOOKS']['generateFrontendUrl']))
  1274.         {
  1275.             foreach ($GLOBALS['TL_HOOKS']['generateFrontendUrl'] as $callback)
  1276.             {
  1277.                 $strUrl = static::importStatic($callback[0])->{$callback[1]}($arrRow, $strParams, $strUrl);
  1278.             }
  1279.         }
  1281.         return $strUrl;
  1282.     }
  1284.     /**
  1285.      * Convert relative URLs in href and src attributes to absolute URLs
  1286.      *
  1287.      * @param string  $strContent  The text with the URLs to be converted
  1288.      * @param string  $strBase     An optional base URL
  1289.      * @param boolean $blnHrefOnly If true, only href attributes will be converted
  1290.      *
  1291.      * @return string The text with the replaced URLs
  1292.      */
  1293.     public static function convertRelativeUrls($strContent, $strBase='', $blnHrefOnly=false)
  1294.     {
  1295.         if (!$strBase)
  1296.         {
  1297.             $strBase = Environment::get('base');
  1298.         }
  1300.         $search = $blnHrefOnly ? 'href' : 'href|src';
  1301.         $arrUrls = preg_split('/((' . $search . ')="([^"]+)")/i', $strContent, -1, PREG_SPLIT_DELIM_CAPTURE);
  1302.         $strContent = '';
  1304.         for ($i=0, $c=\count($arrUrls); $i<$c; $i+=4)
  1305.         {
  1306.             $strContent .= $arrUrls[$i];
  1308.             if (!isset($arrUrls[$i+2]))
  1309.             {
  1310.                 continue;
  1311.             }
  1313.             $strAttribute = $arrUrls[$i+2];
  1314.             $strUrl = $arrUrls[$i+3];
  1316.             if (!preg_match('@^(?:[a-z0-9]+:|#)@i', $strUrl))
  1317.             {
  1318.                 $strUrl = $strBase . (($strUrl != '/') ? $strUrl : '');
  1319.             }
  1321.             $strContent .= $strAttribute . '="' . $strUrl . '"';
  1322.         }
  1324.         return $strContent;
  1325.     }
  1327.     /**
  1328.      * Send a file to the browser so the "save as …" dialogue opens
  1329.      *
  1330.      * @param string  $strFile The file path
  1331.      * @param boolean $inline  Show the file in the browser instead of opening the download dialog
  1332.      *
  1333.      * @throws AccessDeniedException
  1334.      */
  1335.     public static function sendFileToBrowser($strFile, $inline=false)
  1336.     {
  1337.         // Make sure there are no attempts to hack the file system
  1338.         if (preg_match('@^\.+@', $strFile) || preg_match('@\.+/@', $strFile) || preg_match('@(://)+@', $strFile))
  1339.         {
  1340.             throw new PageNotFoundException('Invalid file name');
  1341.         }
  1343.         // Limit downloads to the files directory
  1344.         if (!preg_match('@^' . preg_quote(System::getContainer()->getParameter('contao.upload_path'), '@') . '@i', $strFile))
  1345.         {
  1346.             throw new PageNotFoundException('Invalid path');
  1347.         }
  1349.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1351.         // Check whether the file exists
  1352.         if (!file_exists($projectDir . '/' . $strFile))
  1353.         {
  1354.             throw new PageNotFoundException('File not found');
  1355.         }
  1357.         $objFile = new File($strFile);
  1358.         $arrAllowedTypes = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1360.         // Check whether the file type is allowed to be downloaded
  1361.         if (!\in_array($objFile->extension, $arrAllowedTypes))
  1362.         {
  1363.             throw new AccessDeniedException(sprintf('File type "%s" is not allowed', $objFile->extension));
  1364.         }
  1366.         // HOOK: post download callback
  1367.         if (isset($GLOBALS['TL_HOOKS']['postDownload']) && \is_array($GLOBALS['TL_HOOKS']['postDownload']))
  1368.         {
  1369.             foreach ($GLOBALS['TL_HOOKS']['postDownload'] as $callback)
  1370.             {
  1371.                 static::importStatic($callback[0])->{$callback[1]}($strFile);
  1372.             }
  1373.         }
  1375.         // Send the file (will stop the script execution)
  1376.         $objFile->sendToBrowser('', $inline);
  1377.     }
  1379.     /**
  1380.      * Load a set of DCA files
  1381.      *
  1382.      * @param string  $strTable   The table name
  1383.      * @param boolean $blnNoCache If true, the cache will be bypassed
  1384.      */
  1385.     public static function loadDataContainer($strTable, $blnNoCache=false)
  1386.     {
  1387.         $loader = new DcaLoader($strTable);
  1388.         $loader->load($blnNoCache);
  1389.     }
  1391.     /**
  1392.      * Redirect to a front end page
  1393.      *
  1394.      * @param integer $intPage    The page ID
  1395.      * @param string  $strArticle An optional article alias
  1396.      * @param boolean $blnReturn  If true, return the URL and don't redirect
  1397.      *
  1398.      * @return string The URL of the target page
  1399.      */
  1400.     protected function redirectToFrontendPage($intPage, $strArticle=null, $blnReturn=false)
  1401.     {
  1402.         if (($intPage = (int) $intPage) <= 0)
  1403.         {
  1404.             return '';
  1405.         }
  1407.         $objPage = PageModel::findWithDetails($intPage);
  1409.         if ($objPage === null)
  1410.         {
  1411.             return '';
  1412.         }
  1414.         $strParams = null;
  1416.         // Add the /article/ fragment (see #673)
  1417.         if ($strArticle !== null && ($objArticle = ArticleModel::findByAlias($strArticle)) !== null)
  1418.         {
  1419.             $strParams = '/articles/' . (($objArticle->inColumn != 'main') ? $objArticle->inColumn . ':' : '') . $strArticle;
  1420.         }
  1422.         $strUrl = $objPage->getPreviewUrl($strParams);
  1424.         if (!$blnReturn)
  1425.         {
  1426.             $this->redirect($strUrl);
  1427.         }
  1429.         return $strUrl;
  1430.     }
  1432.     /**
  1433.      * Get the parent records of an entry and return them as string which can
  1434.      * be used in a log message
  1435.      *
  1436.      * @param string  $strTable The table name
  1437.      * @param integer $intId    The record ID
  1438.      *
  1439.      * @return string A string that can be used in a log message
  1440.      */
  1441.     protected function getParentEntries($strTable, $intId)
  1442.     {
  1443.         // No parent table
  1444.         if (empty($GLOBALS['TL_DCA'][$strTable]['config']['ptable']))
  1445.         {
  1446.             return '';
  1447.         }
  1449.         $arrParent = array();
  1451.         do
  1452.         {
  1453.             // Get the pid
  1454.             $objParent = $this->Database->prepare("SELECT pid FROM " . $strTable . " WHERE id=?")
  1455.                                         ->limit(1)
  1456.                                         ->execute($intId);
  1458.             if ($objParent->numRows < 1)
  1459.             {
  1460.                 break;
  1461.             }
  1463.             // Store the parent table information
  1464.             $strTable = $GLOBALS['TL_DCA'][$strTable]['config']['ptable'];
  1465.             $intId = $objParent->pid;
  1467.             // Add the log entry
  1468.             $arrParent[] = $strTable . '.id=' . $intId;
  1470.             // Load the data container of the parent table
  1471.             $this->loadDataContainer($strTable);
  1472.         } while ($intId && isset($GLOBALS['TL_DCA'][$strTable]['config']['ptable']));
  1474.         if (empty($arrParent))
  1475.         {
  1476.             return '';
  1477.         }
  1479.         return ' (parent records: ' . implode(', ', $arrParent) . ')';
  1480.     }
  1482.     /**
  1483.      * Take an array of file paths and eliminate the nested ones
  1484.      *
  1485.      * @param array $arrPaths The array of file paths
  1486.      *
  1487.      * @return array The file paths array without the nested paths
  1488.      */
  1489.     protected function eliminateNestedPaths($arrPaths)
  1490.     {
  1491.         $arrPaths = array_filter($arrPaths);
  1493.         if (empty($arrPaths) || !\is_array($arrPaths))
  1494.         {
  1495.             return array();
  1496.         }
  1498.         $nested = array();
  1500.         foreach ($arrPaths as $path)
  1501.         {
  1502.             $nested[] = preg_grep('/^' . preg_quote($path, '/') . '\/.+/', $arrPaths);
  1503.         }
  1505.         if (!empty($nested))
  1506.         {
  1507.             $nested = array_merge(...$nested);
  1508.         }
  1510.         return array_values(array_diff($arrPaths, $nested));
  1511.     }
  1513.     /**
  1514.      * Take an array of pages and eliminate the nested ones
  1515.      *
  1516.      * @param array   $arrPages   The array of page IDs
  1517.      * @param string  $strTable   The table name
  1518.      * @param boolean $blnSorting True if the table has a sorting field
  1519.      *
  1520.      * @return array The page IDs array without the nested IDs
  1521.      */
  1522.     protected function eliminateNestedPages($arrPages, $strTable=null, $blnSorting=false)
  1523.     {
  1524.         if (empty($arrPages) || !\is_array($arrPages))
  1525.         {
  1526.             return array();
  1527.         }
  1529.         if (!$strTable)
  1530.         {
  1531.             $strTable = 'tl_page';
  1532.         }
  1534.         // Thanks to Andreas Schempp (see #2475 and #3423)
  1535.         $arrPages = array_intersect($arrPages, $this->Database->getChildRecords(0, $strTable, $blnSorting));
  1536.         $arrPages = array_values(array_diff($arrPages, $this->Database->getChildRecords($arrPages, $strTable, $blnSorting)));
  1538.         return $arrPages;
  1539.     }
  1541.     /**
  1542.      * Add an image to a template
  1543.      *
  1544.      * @param object          $template                The template object to add the image to
  1545.      * @param array           $rowData                 The element or module as array
  1546.      * @param integer|null    $maxWidth                An optional maximum width of the image
  1547.      * @param string|null     $lightboxGroupIdentifier An optional lightbox group identifier
  1548.      * @param FilesModel|null $filesModel              An optional files model
  1549.      *
  1550.      * @deprecated Deprecated since Contao 4.11, to be removed in Contao 5.0;
  1551.      *             use the Contao\CoreBundle\Image\Studio\FigureBuilder instead.
  1552.      */
  1553.     public static function addImageToTemplate($template, array $rowData, $maxWidth = null, $lightboxGroupIdentifier = null, FilesModel $filesModel = null): void
  1554.     {
  1555.         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.');
  1557.         // Helper: Create metadata from the specified row data
  1558.         $createMetadataOverwriteFromRowData = static function (bool $interpretAsContentModel) use ($rowData)
  1559.         {
  1560.             if ($interpretAsContentModel)
  1561.             {
  1562.                 // This will be null if "overwriteMeta" is not set
  1563.                 return (new ContentModel())->setRow($rowData)->getOverwriteMetadata();
  1564.             }
  1566.             // Manually create metadata that always contains certain properties (BC)
  1567.             return new Metadata(array(
  1568.                 Metadata::VALUE_ALT => $rowData['alt'] ?? '',
  1569.                 Metadata::VALUE_TITLE => $rowData['imageTitle'] ?? '',
  1570.                 Metadata::VALUE_URL => self::replaceInsertTags($rowData['imageUrl'] ?? ''),
  1571.                 'linkTitle' => (string) ($rowData['linkTitle'] ?? ''),
  1572.             ));
  1573.         };
  1575.         // Helper: Create fallback template data with (mostly) empty fields (used if resource acquisition fails)
  1576.         $createFallBackTemplateData = static function () use ($filesModel, $rowData)
  1577.         {
  1578.             $templateData = array(
  1579.                 'width' => null,
  1580.                 'height' => null,
  1581.                 'picture' => array(
  1582.                     'img' => array(
  1583.                         'src' => '',
  1584.                         'srcset' => '',
  1585.                     ),
  1586.                     'sources' => array(),
  1587.                     'alt' => '',
  1588.                     'title' => '',
  1589.                 ),
  1590.                 'singleSRC' => $rowData['singleSRC'],
  1591.                 'src' => '',
  1592.                 'linkTitle' => '',
  1593.                 'margin' => '',
  1594.                 'addImage' => true,
  1595.                 'addBefore' => true,
  1596.                 'fullsize' => false,
  1597.             );
  1599.             if (null !== $filesModel)
  1600.             {
  1601.                 // Set empty metadata
  1602.                 $templateData = array_replace_recursive(
  1603.                     $templateData,
  1604.                     array(
  1605.                         'alt' => '',
  1606.                         'caption' => '',
  1607.                         'imageTitle' => '',
  1608.                         'imageUrl' => '',
  1609.                     )
  1610.                 );
  1611.             }
  1613.             return $templateData;
  1614.         };
  1616.         // Helper: Get size and margins and handle legacy $maxWidth option
  1617.         $getSizeAndMargin = static function () use ($rowData, $maxWidth)
  1618.         {
  1619.             $size = $rowData['size'] ?? null;
  1620.             $margin = StringUtil::deserialize($rowData['imagemargin'] ?? null);
  1621.             $maxWidth = (int) ($maxWidth ?? Config::get('maxImageWidth'));
  1623.             if (0 === $maxWidth)
  1624.             {
  1625.                 return array($size, $margin);
  1626.             }
  1628.             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.');
  1630.             // Adjust margins if needed
  1631.             if ('px' === ($margin['unit'] ?? null))
  1632.             {
  1633.                 $horizontalMargin = (int) ($margin['left'] ?? 0) + (int) ($margin['right'] ?? 0);
  1635.                 if ($maxWidth - $horizontalMargin < 1)
  1636.                 {
  1637.                     $margin['left'] = '';
  1638.                     $margin['right'] = '';
  1639.                 }
  1640.                 else
  1641.                 {
  1642.                     $maxWidth -= $horizontalMargin;
  1643.                 }
  1644.             }
  1646.             // Normalize size
  1647.             if ($size instanceof PictureConfiguration)
  1648.             {
  1649.                 return array($size, $margin);
  1650.             }
  1652.             $size = StringUtil::deserialize($size);
  1654.             if (is_numeric($size))
  1655.             {
  1656.                 $size = array(0, 0, (int) $size);
  1657.             }
  1658.             else
  1659.             {
  1660.                 $size = (\is_array($size) ? $size : array()) + array(0, 0, 'crop');
  1661.                 $size[0] = (int) $size[0];
  1662.                 $size[1] = (int) $size[1];
  1663.             }
  1665.             // Adjust image size configuration if it exceeds the max width
  1666.             if ($size[0] > 0 && $size[1] > 0)
  1667.             {
  1668.                 list($width, $height) = $size;
  1669.             }
  1670.             else
  1671.             {
  1672.                 $container = System::getContainer();
  1674.                 /** @var BoxInterface $originalSize */
  1675.                 $originalSize = $container
  1676.                     ->get('contao.image.image_factory')
  1677.                     ->create($container->getParameter('kernel.project_dir') . '/' . $rowData['singleSRC'])
  1678.                     ->getDimensions()
  1679.                     ->getSize();
  1681.                 $width = $originalSize->getWidth();
  1682.                 $height = $originalSize->getHeight();
  1683.             }
  1685.             if ($width <= $maxWidth)
  1686.             {
  1687.                 return array($size, $margin);
  1688.             }
  1690.             $size[0] = $maxWidth;
  1691.             $size[1] = (int) floor($maxWidth * ($height / $width));
  1693.             return array($size, $margin);
  1694.         };
  1696.         /** @var FigureBuilder $figureBuilder */
  1697.         $figureBuilder = System::getContainer()->get(Studio::class)->createFigureBuilder();
  1699.         // Set image resource
  1700.         if (null !== $filesModel)
  1701.         {
  1702.             // Make sure model points to the same resource (BC)
  1703.             $filesModel = clone $filesModel;
  1704.             $filesModel->path = $rowData['singleSRC'];
  1706.             // Use source + metadata from files model (if not overwritten)
  1707.             $figureBuilder
  1708.                 ->fromFilesModel($filesModel)
  1709.                 ->setMetadata($createMetadataOverwriteFromRowData(true));
  1711.             $includeFullMetadata = true;
  1712.         }
  1713.         else
  1714.         {
  1715.             // Always ignore file metadata when building from path (BC)
  1716.             $figureBuilder
  1717.                 ->fromPath($rowData['singleSRC'], false)
  1718.                 ->setMetadata($createMetadataOverwriteFromRowData(false));
  1720.             $includeFullMetadata = false;
  1721.         }
  1723.         // Set size and lightbox configuration
  1724.         list($size, $margin) = $getSizeAndMargin();
  1726.         $lightboxSize = StringUtil::deserialize($rowData['lightboxSize'] ?? null) ?: null;
  1728.         $figure = $figureBuilder
  1729.             ->setSize($size)
  1730.             ->setLightboxGroupIdentifier($lightboxGroupIdentifier)
  1731.             ->setLightboxSize($lightboxSize)
  1732.             ->enableLightbox((bool) ($rowData['fullsize'] ?? false))
  1733.             ->buildIfResourceExists();
  1735.         if (null === $figure)
  1736.         {
  1737.             System::getContainer()
  1738.                 ->get('monolog.logger.contao')
  1739.                 ->log(
  1740.                     LogLevel::ERROR,
  1741.                     sprintf('Image "%s" could not be processed: %s', $rowData['singleSRC'], $figureBuilder->getLastException()->getMessage()),
  1742.                     array('contao' => new ContaoMonologContext(__METHOD__, 'ERROR'))
  1743.                 );
  1745.             // Fall back to apply a sparse data set instead of failing (BC)
  1746.             foreach ($createFallBackTemplateData() as $key => $value)
  1747.             {
  1748.                 $template->$key = $value;
  1749.             }
  1751.             return;
  1752.         }
  1754.         // Build result and apply it to the template
  1755.         $figure->applyLegacyTemplateData($template, $margin, $rowData['floating'] ?? null, $includeFullMetadata);
  1757.         // Fall back to manually specified link title or empty string if not set (backwards compatibility)
  1758.         $template->linkTitle = $template->linkTitle ?? StringUtil::specialchars($rowData['title'] ?? '');
  1759.     }
  1761.     /**
  1762.      * Add enclosures to a template
  1763.      *
  1764.      * @param object $objTemplate The template object to add the enclosures to
  1765.      * @param array  $arrItem     The element or module as array
  1766.      * @param string $strKey      The name of the enclosures field in $arrItem
  1767.      */
  1768.     public static function addEnclosuresToTemplate($objTemplate, $arrItem, $strKey='enclosure')
  1769.     {
  1770.         $arrEnclosures = StringUtil::deserialize($arrItem[$strKey]);
  1772.         if (empty($arrEnclosures) || !\is_array($arrEnclosures))
  1773.         {
  1774.             return;
  1775.         }
  1777.         $objFiles = FilesModel::findMultipleByUuids($arrEnclosures);
  1779.         if ($objFiles === null)
  1780.         {
  1781.             return;
  1782.         }
  1784.         $file = Input::get('file', true);
  1786.         // Send the file to the browser and do not send a 404 header (see #5178)
  1787.         if ($file)
  1788.         {
  1789.             while ($objFiles->next())
  1790.             {
  1791.                 if ($file == $objFiles->path)
  1792.                 {
  1793.                     static::sendFileToBrowser($file);
  1794.                 }
  1795.             }
  1797.             $objFiles->reset();
  1798.         }
  1800.         /** @var PageModel $objPage */
  1801.         global $objPage;
  1803.         $arrEnclosures = array();
  1804.         $allowedDownload = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1806.         // Add download links
  1807.         while ($objFiles->next())
  1808.         {
  1809.             if ($objFiles->type == 'file')
  1810.             {
  1811.                 $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1813.                 if (!\in_array($objFiles->extension, $allowedDownload) || !is_file($projectDir . '/' . $objFiles->path))
  1814.                 {
  1815.                     continue;
  1816.                 }
  1818.                 $objFile = new File($objFiles->path);
  1819.                 $strHref = Environment::get('request');
  1821.                 // Remove an existing file parameter (see #5683)
  1822.                 if (preg_match('/(&(amp;)?|\?)file=/', $strHref))
  1823.                 {
  1824.                     $strHref = preg_replace('/(&(amp;)?|\?)file=[^&]+/', '', $strHref);
  1825.                 }
  1827.                 $strHref .= ((strpos($strHref, '?') !== false) ? '&amp;' : '?') . 'file=' . System::urlEncode($objFiles->path);
  1829.                 $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->language);
  1831.                 if (empty($arrMeta) && $objPage->rootFallbackLanguage !== null)
  1832.                 {
  1833.                     $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->rootFallbackLanguage);
  1834.                 }
  1836.                 // Use the file name as title if none is given
  1837.                 if (empty($arrMeta['title']))
  1838.                 {
  1839.                     $arrMeta['title'] = StringUtil::specialchars($objFile->basename);
  1840.                 }
  1842.                 $arrEnclosures[] = array
  1843.                 (
  1844.                     'id'        => $objFiles->id,
  1845.                     'uuid'      => $objFiles->uuid,
  1846.                     'name'      => $objFile->basename,
  1847.                     'title'     => StringUtil::specialchars(sprintf($GLOBALS['TL_LANG']['MSC']['download'], $objFile->basename)),
  1848.                     'link'      => $arrMeta['title'],
  1849.                     'caption'   => $arrMeta['caption'] ?? null,
  1850.                     'href'      => $strHref,
  1851.                     'filesize'  => static::getReadableSize($objFile->filesize),
  1852.                     'icon'      => Image::getPath($objFile->icon),
  1853.                     'mime'      => $objFile->mime,
  1854.                     'meta'      => $arrMeta,
  1855.                     'extension' => $objFile->extension,
  1856.                     'path'      => $objFile->dirname,
  1857.                     'enclosure' => $objFiles->path // backwards compatibility
  1858.                 );
  1859.             }
  1860.         }
  1862.         // Order the enclosures
  1863.         if (!empty($arrItem['orderEnclosure']))
  1864.         {
  1865.             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.');
  1867.             $arrEnclosures = ArrayUtil::sortByOrderField($arrEnclosures, $arrItem['orderEnclosure']);
  1868.         }
  1870.         $objTemplate->enclosure = $arrEnclosures;
  1871.     }
  1873.     /**
  1874.      * Set the static URL constants
  1875.      */
  1876.     public static function setStaticUrls()
  1877.     {
  1878.         if (\defined('TL_FILES_URL'))
  1879.         {
  1880.             return;
  1881.         }
  1883.         if (\func_num_args() > 0)
  1884.         {
  1885.             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.');
  1887.             if (!isset($GLOBALS['objPage']))
  1888.             {
  1889.                 $GLOBALS['objPage'] = func_get_arg(0);
  1890.             }
  1891.         }
  1893.         \define('TL_ASSETS_URL', System::getContainer()->get('contao.assets.assets_context')->getStaticUrl());
  1894.         \define('TL_FILES_URL', System::getContainer()->get('contao.assets.files_context')->getStaticUrl());
  1896.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  1897.         \define('TL_SCRIPT_URL', TL_ASSETS_URL);
  1898.         \define('TL_PLUGINS_URL', TL_ASSETS_URL);
  1899.     }
  1901.     /**
  1902.      * Add a static URL to a script
  1903.      *
  1904.      * @param string             $script  The script path
  1905.      * @param ContaoContext|null $context
  1906.      *
  1907.      * @return string The script path with the static URL
  1908.      */
  1909.     public static function addStaticUrlTo($script, ContaoContext $context = null)
  1910.     {
  1911.         // Absolute URLs
  1912.         if (preg_match('@^https?://@', $script))
  1913.         {
  1914.             return $script;
  1915.         }
  1917.         if ($context === null)
  1918.         {
  1919.             $context = System::getContainer()->get('contao.assets.assets_context');
  1920.         }
  1922.         if ($strStaticUrl = $context->getStaticUrl())
  1923.         {
  1924.             return $strStaticUrl . $script;
  1925.         }
  1927.         return $script;
  1928.     }
  1930.     /**
  1931.      * Add the assets URL to a script
  1932.      *
  1933.      * @param string $script The script path
  1934.      *
  1935.      * @return string The script path with the assets URL
  1936.      */
  1937.     public static function addAssetsUrlTo($script)
  1938.     {
  1939.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.assets_context'));
  1940.     }
  1942.     /**
  1943.      * Add the files URL to a script
  1944.      *
  1945.      * @param string $script The script path
  1946.      *
  1947.      * @return string The script path with the files URL
  1948.      */
  1949.     public static function addFilesUrlTo($script)
  1950.     {
  1951.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.files_context'));
  1952.     }
  1954.     /**
  1955.      * Return the current theme as string
  1956.      *
  1957.      * @return string The name of the theme
  1958.      *
  1959.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1960.      *             Use Backend::getTheme() instead.
  1961.      */
  1962.     public static function getTheme()
  1963.     {
  1964.         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.');
  1966.         return Backend::getTheme();
  1967.     }
  1969.     /**
  1970.      * Return the back end themes as array
  1971.      *
  1972.      * @return array An array of available back end themes
  1973.      *
  1974.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1975.      *             Use Backend::getThemes() instead.
  1976.      */
  1977.     public static function getBackendThemes()
  1978.     {
  1979.         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.');
  1981.         return Backend::getThemes();
  1982.     }
  1984.     /**
  1985.      * Get the details of a page including inherited parameters
  1986.      *
  1987.      * @param mixed $intId A page ID or a Model object
  1988.      *
  1989.      * @return PageModel The page model or null
  1990.      *
  1991.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1992.      *             Use PageModel::findWithDetails() or PageModel->loadDetails() instead.
  1993.      */
  1994.     public static function getPageDetails($intId)
  1995.     {
  1996.         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.');
  1998.         if ($intId instanceof PageModel)
  1999.         {
  2000.             return $intId->loadDetails();
  2001.         }
  2003.         if ($intId instanceof Collection)
  2004.         {
  2005.             /** @var PageModel $objPage */
  2006.             $objPage = $intId->current();
  2008.             return $objPage->loadDetails();
  2009.         }
  2011.         if (\is_object($intId))
  2012.         {
  2013.             $strKey = __METHOD__ . '-' . $intId->id;
  2015.             // Try to load from cache
  2016.             if (Cache::has($strKey))
  2017.             {
  2018.                 return Cache::get($strKey);
  2019.             }
  2021.             // Create a model from the database result
  2022.             $objPage = new PageModel();
  2023.             $objPage->setRow($intId->row());
  2024.             $objPage->loadDetails();
  2026.             Cache::set($strKey, $objPage);
  2028.             return $objPage;
  2029.         }
  2031.         // Invalid ID
  2032.         if ($intId < 1 || !\strlen($intId))
  2033.         {
  2034.             return null;
  2035.         }
  2037.         $strKey = __METHOD__ . '-' . $intId;
  2039.         // Try to load from cache
  2040.         if (Cache::has($strKey))
  2041.         {
  2042.             return Cache::get($strKey);
  2043.         }
  2045.         $objPage = PageModel::findWithDetails($intId);
  2047.         Cache::set($strKey, $objPage);
  2049.         return $objPage;
  2050.     }
  2052.     /**
  2053.      * Remove old XML files from the share directory
  2054.      *
  2055.      * @param boolean $blnReturn If true, only return the finds and don't delete
  2056.      *
  2057.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2058.      *             Use Automator::purgeXmlFiles() instead.
  2059.      */
  2060.     protected function removeOldFeeds($blnReturn=false)
  2061.     {
  2062.         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.');
  2064.         $this->import(Automator::class, 'Automator');
  2065.         $this->Automator->purgeXmlFiles($blnReturn);
  2066.     }
  2068.     /**
  2069.      * Return true if a class exists (tries to autoload the class)
  2070.      *
  2071.      * @param string $strClass The class name
  2072.      *
  2073.      * @return boolean True if the class exists
  2074.      *
  2075.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2076.      *             Use the PHP function class_exists() instead.
  2077.      */
  2078.     protected function classFileExists($strClass)
  2079.     {
  2080.         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.');
  2082.         return class_exists($strClass);
  2083.     }
  2085.     /**
  2086.      * Restore basic entities
  2087.      *
  2088.      * @param string $strBuffer The string with the tags to be replaced
  2089.      *
  2090.      * @return string The string with the original entities
  2091.      *
  2092.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2093.      *             Use StringUtil::restoreBasicEntities() instead.
  2094.      */
  2095.     public static function restoreBasicEntities($strBuffer)
  2096.     {
  2097.         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.');
  2099.         return StringUtil::restoreBasicEntities($strBuffer);
  2100.     }
  2102.     /**
  2103.      * Resize an image and crop it if necessary
  2104.      *
  2105.      * @param string  $image  The image path
  2106.      * @param integer $width  The target width
  2107.      * @param integer $height The target height
  2108.      * @param string  $mode   An optional resize mode
  2109.      *
  2110.      * @return boolean True if the image has been resized correctly
  2111.      *
  2112.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2113.      *             Use Image::resize() instead.
  2114.      */
  2115.     protected function resizeImage($image, $width, $height, $mode='')
  2116.     {
  2117.         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.');
  2119.         return Image::resize($image, $width, $height, $mode);
  2120.     }
  2122.     /**
  2123.      * Resize an image and crop it if necessary
  2124.      *
  2125.      * @param string  $image  The image path
  2126.      * @param integer $width  The target width
  2127.      * @param integer $height The target height
  2128.      * @param string  $mode   An optional resize mode
  2129.      * @param string  $target An optional target to be replaced
  2130.      * @param boolean $force  Override existing target images
  2131.      *
  2132.      * @return string|null The image path or null
  2133.      *
  2134.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2135.      *             Use Image::get() instead.
  2136.      */
  2137.     protected function getImage($image, $width, $height, $mode='', $target=null, $force=false)
  2138.     {
  2139.         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.');
  2141.         return Image::get($image, $width, $height, $mode, $target, $force);
  2142.     }
  2144.     /**
  2145.      * Generate an image tag and return it as string
  2146.      *
  2147.      * @param string $src        The image path
  2148.      * @param string $alt        An optional alt attribute
  2149.      * @param string $attributes A string of other attributes
  2150.      *
  2151.      * @return string The image HTML tag
  2152.      *
  2153.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2154.      *             Use Image::getHtml() instead.
  2155.      */
  2156.     public static function generateImage($src, $alt='', $attributes='')
  2157.     {
  2158.         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.');
  2160.         return Image::getHtml($src, $alt, $attributes);
  2161.     }
  2163.     /**
  2164.      * Return the date picker string (see #3218)
  2165.      *
  2166.      * @return boolean
  2167.      *
  2168.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2169.      *             Specify "datepicker"=>true in your DCA file instead.
  2170.      */
  2171.     protected function getDatePickerString()
  2172.     {
  2173.         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.');
  2175.         return true;
  2176.     }
  2178.     /**
  2179.      * Return the installed back end languages as array
  2180.      *
  2181.      * @return array An array of available back end languages
  2182.      *
  2183.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2184.      *             Use the Contao\CoreBundle\Intl\Locales service instead.
  2185.      */
  2186.     protected function getBackendLanguages()
  2187.     {
  2188.         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.');
  2190.         return $this->getLanguages(true);
  2191.     }
  2193.     /**
  2194.      * Parse simple tokens that can be used to personalize newsletters
  2195.      *
  2196.      * @param string $strBuffer The text with the tokens to be replaced
  2197.      * @param array  $arrData   The replacement data as array
  2198.      *
  2199.      * @return string The text with the replaced tokens
  2200.      *
  2201.      * @deprecated Deprecated since Contao 4.10, to be removed in Contao 5.0;
  2202.      *             Use the SimpleTokenParser::class service instead.
  2203.      */
  2204.     protected function parseSimpleTokens($strBuffer, $arrData)
  2205.     {
  2206.         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 "SimpleTokenParser::class" service instead.');
  2208.         return System::getContainer()->get(SimpleTokenParser::class)->parse($strBuffer, $arrData);
  2209.     }
  2211.     /**
  2212.      * Convert a DCA file configuration to be used with widgets
  2213.      *
  2214.      * @param array  $arrData  The field configuration array
  2215.      * @param string $strName  The field name in the form
  2216.      * @param mixed  $varValue The field value
  2217.      * @param string $strField The field name in the database
  2218.      * @param string $strTable The table name
  2219.      *
  2220.      * @return array An array that can be passed to a widget
  2221.      *
  2222.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2223.      *             Use Widget::getAttributesFromDca() instead.
  2224.      */
  2225.     protected function prepareForWidget($arrData, $strName, $varValue=null, $strField='', $strTable='')
  2226.     {
  2227.         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.');
  2229.         return Widget::getAttributesFromDca($arrData, $strName, $varValue, $strField, $strTable);
  2230.     }
  2232.     /**
  2233.      * Return the IDs of all child records of a particular record (see #2475)
  2234.      *
  2235.      * @author Andreas Schempp
  2236.      *
  2237.      * @param mixed   $arrParentIds An array of parent IDs
  2238.      * @param string  $strTable     The table name
  2239.      * @param boolean $blnSorting   True if the table has a sorting field
  2240.      * @param array   $arrReturn    The array to be returned
  2241.      * @param string  $strWhere     Additional WHERE condition
  2242.      *
  2243.      * @return array An array of child record IDs
  2244.      *
  2245.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2246.      *             Use Database::getChildRecords() instead.
  2247.      */
  2248.     protected function getChildRecords($arrParentIds, $strTable, $blnSorting=false, $arrReturn=array(), $strWhere='')
  2249.     {
  2250.         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.');
  2252.         return $this->Database->getChildRecords($arrParentIds, $strTable, $blnSorting, $arrReturn, $strWhere);
  2253.     }
  2255.     /**
  2256.      * Return the IDs of all parent records of a particular record
  2257.      *
  2258.      * @param integer $intId    The ID of the record
  2259.      * @param string  $strTable The table name
  2260.      *
  2261.      * @return array An array of parent record IDs
  2262.      *
  2263.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2264.      *             Use Database::getParentRecords() instead.
  2265.      */
  2266.     protected function getParentRecords($intId, $strTable)
  2267.     {
  2268.         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.');
  2270.         return $this->Database->getParentRecords($intId, $strTable);
  2271.     }
  2273.     /**
  2274.      * Print an article as PDF and stream it to the browser
  2275.      *
  2276.      * @param ModuleModel $objArticle An article object
  2277.      *
  2278.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2279.      *             Use ModuleArticle->generatePdf() instead.
  2280.      */
  2281.     protected function printArticleAsPdf($objArticle)
  2282.     {
  2283.         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.');
  2285.         $objArticle = new ModuleArticle($objArticle);
  2286.         $objArticle->generatePdf();
  2287.     }
  2289.     /**
  2290.      * Return all page sections as array
  2291.      *
  2292.      * @return array An array of active page sections
  2293.      *
  2294.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2295.      *             See https://github.com/contao/core/issues/4693.
  2296.      */
  2297.     public static function getPageSections()
  2298.     {
  2299.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Controller::getPageSections()" has been deprecated and will no longer work in Contao 5.0.');
  2301.         return array('header', 'left', 'right', 'main', 'footer');
  2302.     }
  2304.     /**
  2305.      * Return a "selected" attribute if the option is selected
  2306.      *
  2307.      * @param string $strOption The option to check
  2308.      * @param mixed  $varValues One or more values to check against
  2309.      *
  2310.      * @return string The attribute or an empty string
  2311.      *
  2312.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2313.      *             Use Widget::optionSelected() instead.
  2314.      */
  2315.     public static function optionSelected($strOption, $varValues)
  2316.     {
  2317.         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.');
  2319.         return Widget::optionSelected($strOption, $varValues);
  2320.     }
  2322.     /**
  2323.      * Return a "checked" attribute if the option is checked
  2324.      *
  2325.      * @param string $strOption The option to check
  2326.      * @param mixed  $varValues One or more values to check against
  2327.      *
  2328.      * @return string The attribute or an empty string
  2329.      *
  2330.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2331.      *             Use Widget::optionChecked() instead.
  2332.      */
  2333.     public static function optionChecked($strOption, $varValues)
  2334.     {
  2335.         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.');
  2337.         return Widget::optionChecked($strOption, $varValues);
  2338.     }
  2340.     /**
  2341.      * Find a content element in the TL_CTE array and return the class name
  2342.      *
  2343.      * @param string $strName The content element name
  2344.      *
  2345.      * @return string The class name
  2346.      *
  2347.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2348.      *             Use ContentElement::findClass() instead.
  2349.      */
  2350.     public static function findContentElement($strName)
  2351.     {
  2352.         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.');
  2354.         return ContentElement::findClass($strName);
  2355.     }
  2357.     /**
  2358.      * Find a front end module in the FE_MOD array and return the class name
  2359.      *
  2360.      * @param string $strName The front end module name
  2361.      *
  2362.      * @return string The class name
  2363.      *
  2364.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2365.      *             Use Module::findClass() instead.
  2366.      */
  2367.     public static function findFrontendModule($strName)
  2368.     {
  2369.         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.');
  2371.         return Module::findClass($strName);
  2372.     }
  2374.     /**
  2375.      * Create an initial version of a record
  2376.      *
  2377.      * @param string  $strTable The table name
  2378.      * @param integer $intId    The ID of the element to be versioned
  2379.      *
  2380.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2381.      *             Use Versions->initialize() instead.
  2382.      */
  2383.     protected function createInitialVersion($strTable, $intId)
  2384.     {
  2385.         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.');
  2387.         $objVersions = new Versions($strTable, $intId);
  2388.         $objVersions->initialize();
  2389.     }
  2391.     /**
  2392.      * Create a new version of a record
  2393.      *
  2394.      * @param string  $strTable The table name
  2395.      * @param integer $intId    The ID of the element to be versioned
  2396.      *
  2397.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2398.      *             Use Versions->create() instead.
  2399.      */
  2400.     protected function createNewVersion($strTable, $intId)
  2401.     {
  2402.         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.');
  2404.         $objVersions = new Versions($strTable, $intId);
  2405.         $objVersions->create();
  2406.     }
  2408.     /**
  2409.      * Return the files matching a GLOB pattern
  2410.      *
  2411.      * @param string $pattern
  2412.      *
  2413.      * @return array|false
  2414.      */
  2415.     protected static function braceGlob($pattern)
  2416.     {
  2417.         // Use glob() if possible
  2418.         if (false === strpos($pattern, '/**/') && (\defined('GLOB_BRACE') || false === strpos($pattern, '{')))
  2419.         {
  2420.             return glob($pattern, \defined('GLOB_BRACE') ? GLOB_BRACE : 0);
  2421.         }
  2423.         $finder = new Finder();
  2424.         $regex = Glob::toRegex($pattern);
  2426.         // All files in the given template folder
  2427.         $filesIterator = $finder
  2428.             ->files()
  2429.             ->followLinks()
  2430.             ->sortByName()
  2431.             ->in(\dirname($pattern))
  2432.         ;
  2434.         // Match the actual regex and filter the files
  2435.         $filesIterator = $filesIterator->filter(static function (\SplFileInfo $info) use ($regex)
  2436.         {
  2437.             $path = $info->getPathname();
  2439.             return preg_match($regex, $path) && $info->isFile();
  2440.         });
  2442.         $files = iterator_to_array($filesIterator);
  2444.         return array_keys($files);
  2445.     }
  2446. }
  2448. class_alias(Controller::class, 'Controller');