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

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\Database\Result;
  19. use Contao\Image\PictureConfiguration;
  20. use Contao\Model\Collection;
  21. use Symfony\Component\Finder\Finder;
  22. use Symfony\Component\Finder\Glob;
  24. /**
  25.  * Abstract parent class for Controllers
  26.  *
  27.  * Some of the methods have been made static in Contao 3 and can be used in
  28.  * non-object context as well.
  29.  *
  30.  * Usage:
  31.  *
  32.  *     echo Controller::getTheme();
  33.  *
  34.  * Inside a controller:
  35.  *
  36.  *     public function generate()
  37.  *     {
  38.  *         return $this->getArticle(2);
  39.  *     }
  40.  *
  41.  * @author Leo Feyer <https://github.com/leofeyer>
  42.  */
  43. abstract class Controller extends System
  44. {
  45.     /**
  46.      * @var Template
  47.      *
  48.      * @todo: Add in Contao 5.0
  49.      */
  50.     //protected $Template;
  52.     /**
  53.      * @var array
  54.      */
  55.     protected static $arrQueryCache = array();
  57.     /**
  58.      * @var array
  59.      */
  60.     private static $arrOldBePathCache = array();
  62.     /**
  63.      * Find a particular template file and return its path
  64.      *
  65.      * @param string $strTemplate The name of the template
  66.      *
  67.      * @return string The path to the template file
  68.      *
  69.      * @throws \RuntimeException If the template group folder is insecure
  70.      */
  71.     public static function getTemplate($strTemplate)
  72.     {
  73.         $strTemplate = basename($strTemplate);
  75.         // Check for a theme folder
  76.         if (\defined('TL_MODE') && TL_MODE == 'FE')
  77.         {
  78.             /** @var PageModel $objPage */
  79.             global $objPage;
  81.             if ($objPage->templateGroup)
  82.             {
  83.                 if (Validator::isInsecurePath($objPage->templateGroup))
  84.                 {
  85.                     throw new \RuntimeException('Invalid path ' . $objPage->templateGroup);
  86.                 }
  88.                 return TemplateLoader::getPath($strTemplate, 'html5', $objPage->templateGroup);
  89.             }
  90.         }
  92.         return TemplateLoader::getPath($strTemplate, 'html5');
  93.     }
  95.     /**
  96.      * Return all template files of a particular group as array
  97.      *
  98.      * @param string $strPrefix           The template name prefix (e.g. "ce_")
  99.      * @param array  $arrAdditionalMapper An additional mapper array
  100.      * @param string $strDefaultTemplate  An optional default template
  101.      *
  102.      * @return array An array of template names
  103.      */
  104.     public static function getTemplateGroup($strPrefix, array $arrAdditionalMapper=array(), $strDefaultTemplate='')
  105.     {
  106.         $arrTemplates = array();
  107.         $arrBundleTemplates = array();
  109.         $arrMapper = array_merge
  110.         (
  111.             $arrAdditionalMapper,
  112.             array
  113.             (
  114.                 'ce' => array_keys(array_merge(...array_values($GLOBALS['TL_CTE']))),
  115.                 'form' => array_keys($GLOBALS['TL_FFL']),
  116.                 'mod' => array_keys(array_merge(...array_values($GLOBALS['FE_MOD']))),
  117.             )
  118.         );
  120.         // Add templates that are not directly associated with a form field
  121.         $arrMapper['form'][] = 'row';
  122.         $arrMapper['form'][] = 'row_double';
  123.         $arrMapper['form'][] = 'xml';
  124.         $arrMapper['form'][] = 'wrapper';
  125.         $arrMapper['form'][] = 'message';
  126.         $arrMapper['form'][] = 'textfield'; // TODO: remove in Contao 5.0
  128.         // Add templates that are not directly associated with a module
  129.         $arrMapper['mod'][] = 'article';
  130.         $arrMapper['mod'][] = 'message';
  131.         $arrMapper['mod'][] = 'password'; // TODO: remove in Contao 5.0
  132.         $arrMapper['mod'][] = 'comment_form'; // TODO: remove in Contao 5.0
  133.         $arrMapper['mod'][] = 'newsletter'; // TODO: remove in Contao 5.0
  135.         // Get the default templates
  136.         foreach (TemplateLoader::getPrefixedFiles($strPrefix) as $strTemplate)
  137.         {
  138.             if ($strTemplate != $strPrefix)
  139.             {
  140.                 list($k, $strKey) = explode('_', $strTemplate, 2);
  142.                 if (isset($arrMapper[$k]) && \in_array($strKey, $arrMapper[$k]))
  143.                 {
  144.                     $arrBundleTemplates[] = $strTemplate;
  145.                     continue;
  146.                 }
  147.             }
  149.             $arrTemplates[$strTemplate][] = 'root';
  150.         }
  152.         $strGlobPrefix = $strPrefix;
  154.         // Backwards compatibility (see #725)
  155.         if (substr($strGlobPrefix, -1) == '_')
  156.         {
  157.             $strGlobPrefix = substr($strGlobPrefix, 0, -1) . '[_-]';
  158.         }
  160.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  161.         $arrCustomized = self::braceGlob($projectDir . '/templates/' . $strGlobPrefix . '*.html5');
  163.         // Add the customized templates
  164.         if (!empty($arrCustomized) && \is_array($arrCustomized))
  165.         {
  166.             $blnIsGroupPrefix = preg_match('/^[a-z]+_$/', $strPrefix);
  168.             foreach ($arrCustomized as $strFile)
  169.             {
  170.                 $strTemplate = basename($strFile, strrchr($strFile, '.'));
  172.                 if (strpos($strTemplate, '-') !== false)
  173.                 {
  174.                     @trigger_error('Using hyphens in the template name "' . $strTemplate . '.html5" has been deprecated and will no longer work in Contao 5.0. Use snake_case instead.', E_USER_DEPRECATED);
  175.                 }
  177.                 // Ignore bundle templates, e.g. mod_article and mod_article_list
  178.                 if (\in_array($strTemplate, $arrBundleTemplates))
  179.                 {
  180.                     continue;
  181.                 }
  183.                 // Also ignore custom templates belonging to a different bundle template,
  184.                 // e.g. mod_article and mod_article_list_custom
  185.                 if (!$blnIsGroupPrefix)
  186.                 {
  187.                     foreach ($arrBundleTemplates as $strKey)
  188.                     {
  189.                         if (strpos($strTemplate, $strKey . '_') === 0)
  190.                         {
  191.                             continue 2;
  192.                         }
  193.                     }
  194.                 }
  196.                 $arrTemplates[$strTemplate][] = $GLOBALS['TL_LANG']['MSC']['global'];
  197.             }
  198.         }
  200.         $arrDefaultPlaces = array();
  202.         if ($strDefaultTemplate)
  203.         {
  204.             $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['default'];
  206.             if (file_exists($projectDir . '/templates/' . $strDefaultTemplate . '.html5'))
  207.             {
  208.                 $arrDefaultPlaces[] = $GLOBALS['TL_LANG']['MSC']['global'];
  209.             }
  210.         }
  212.         // Do not look for back end templates in theme folders (see #5379)
  213.         if ($strPrefix != 'be_' && $strPrefix != 'mail_')
  214.         {
  215.             // Try to select the themes (see #5210)
  216.             try
  217.             {
  218.                 $objTheme = ThemeModel::findAll(array('order'=>'name'));
  219.             }
  220.             catch (\Exception $e)
  221.             {
  222.                 $objTheme = null;
  223.             }
  225.             // Add the theme templates
  226.             if ($objTheme !== null)
  227.             {
  228.                 while ($objTheme->next())
  229.                 {
  230.                     if (!$objTheme->templates)
  231.                     {
  232.                         continue;
  233.                     }
  235.                     if ($strDefaultTemplate && file_exists($projectDir . '/' . $objTheme->templates . '/' . $strDefaultTemplate . '.html5'))
  236.                     {
  237.                         $arrDefaultPlaces[] = $objTheme->name;
  238.                     }
  240.                     $arrThemeTemplates = self::braceGlob($projectDir . '/' . $objTheme->templates . '/' . $strGlobPrefix . '*.html5');
  242.                     if (!empty($arrThemeTemplates) && \is_array($arrThemeTemplates))
  243.                     {
  244.                         foreach ($arrThemeTemplates as $strFile)
  245.                         {
  246.                             $strTemplate = basename($strFile, strrchr($strFile, '.'));
  247.                             $arrTemplates[$strTemplate][] = $objTheme->name;
  248.                         }
  249.                     }
  250.                 }
  251.             }
  252.         }
  254.         // Show the template sources (see #6875)
  255.         foreach ($arrTemplates as $k=>$v)
  256.         {
  257.             $v = array_filter($v, static function ($a)
  258.             {
  259.                 return $a != 'root';
  260.             });
  262.             if (empty($v))
  263.             {
  264.                 $arrTemplates[$k] = $k;
  265.             }
  266.             else
  267.             {
  268.                 $arrTemplates[$k] = $k . ' (' . implode(', ', $v) . ')';
  269.             }
  270.         }
  272.         // Sort the template names
  273.         ksort($arrTemplates);
  275.         if ($strDefaultTemplate)
  276.         {
  277.             if (!empty($arrDefaultPlaces))
  278.             {
  279.                 $strDefaultTemplate .= ' (' . implode(', ', $arrDefaultPlaces) . ')';
  280.             }
  282.             $arrTemplates = array('' => $strDefaultTemplate) + $arrTemplates;
  283.         }
  285.         return $arrTemplates;
  286.     }
  288.     /**
  289.      * Generate a front end module and return it as string
  290.      *
  291.      * @param mixed  $intId     A module ID or a Model object
  292.      * @param string $strColumn The name of the column
  293.      *
  294.      * @return string The module HTML markup
  295.      */
  296.     public static function getFrontendModule($intId, $strColumn='main')
  297.     {
  298.         if (!\is_object($intId) && !\strlen($intId))
  299.         {
  300.             return '';
  301.         }
  303.         /** @var PageModel $objPage */
  304.         global $objPage;
  306.         // Articles
  307.         if (!\is_object($intId) && $intId == 0)
  308.         {
  309.             // Show a particular article only
  310.             if ($objPage->type == 'regular' && Input::get('articles'))
  311.             {
  312.                 list($strSection, $strArticle) = explode(':', Input::get('articles'));
  314.                 if ($strArticle === null)
  315.                 {
  316.                     $strArticle = $strSection;
  317.                     $strSection = 'main';
  318.                 }
  320.                 if ($strSection == $strColumn)
  321.                 {
  322.                     $objArticle = ArticleModel::findPublishedByIdOrAliasAndPid($strArticle, $objPage->id);
  324.                     // Send a 404 header if there is no published article
  325.                     if (null === $objArticle)
  326.                     {
  327.                         throw new PageNotFoundException('Page not found: ' . Environment::get('uri'));
  328.                     }
  330.                     // Send a 403 header if the article cannot be accessed
  331.                     if (!static::isVisibleElement($objArticle))
  332.                     {
  333.                         throw new AccessDeniedException('Access denied: ' . Environment::get('uri'));
  334.                     }
  336.                     // Add the "first" and "last" classes (see #2583)
  337.                     $objArticle->classes = array('first', 'last');
  339.                     return static::getArticle($objArticle);
  340.                 }
  341.             }
  343.             // HOOK: add custom logic
  344.             if (isset($GLOBALS['TL_HOOKS']['getArticles']) && \is_array($GLOBALS['TL_HOOKS']['getArticles']))
  345.             {
  346.                 foreach ($GLOBALS['TL_HOOKS']['getArticles'] as $callback)
  347.                 {
  348.                     $return = static::importStatic($callback[0])->{$callback[1]}($objPage->id, $strColumn);
  350.                     if (\is_string($return))
  351.                     {
  352.                         return $return;
  353.                     }
  354.                 }
  355.             }
  357.             // Show all articles (no else block here, see #4740)
  358.             $objArticles = ArticleModel::findPublishedByPidAndColumn($objPage->id, $strColumn);
  360.             if ($objArticles === null)
  361.             {
  362.                 return '';
  363.             }
  365.             $return = '';
  366.             $intCount = 0;
  367.             $blnMultiMode = ($objArticles->count() > 1);
  368.             $intLast = $objArticles->count() - 1;
  370.             while ($objArticles->next())
  371.             {
  372.                 /** @var ArticleModel $objRow */
  373.                 $objRow = $objArticles->current();
  375.                 // Add the "first" and "last" classes (see #2583)
  376.                 if ($intCount == 0 || $intCount == $intLast)
  377.                 {
  378.                     $arrCss = array();
  380.                     if ($intCount == 0)
  381.                     {
  382.                         $arrCss[] = 'first';
  383.                     }
  385.                     if ($intCount == $intLast)
  386.                     {
  387.                         $arrCss[] = 'last';
  388.                     }
  390.                     $objRow->classes = $arrCss;
  391.                 }
  393.                 $return .= static::getArticle($objRow, $blnMultiMode, false, $strColumn);
  394.                 ++$intCount;
  395.             }
  397.             return $return;
  398.         }
  400.         // Other modules
  401.         if (\is_object($intId))
  402.         {
  403.             $objRow = $intId;
  404.         }
  405.         else
  406.         {
  407.             $objRow = ModuleModel::findByPk($intId);
  409.             if ($objRow === null)
  410.             {
  411.                 return '';
  412.             }
  413.         }
  415.         // Check the visibility (see #6311)
  416.         if (!static::isVisibleElement($objRow))
  417.         {
  418.             return '';
  419.         }
  421.         $strClass = Module::findClass($objRow->type);
  423.         // Return if the class does not exist
  424.         if (!class_exists($strClass))
  425.         {
  426.             static::log('Module class "' . $strClass . '" (module "' . $objRow->type . '") does not exist', __METHOD__, TL_ERROR);
  428.             return '';
  429.         }
  431.         $strStopWatchId = 'contao.frontend_module.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  433.         if (System::getContainer()->getParameter('kernel.debug'))
  434.         {
  435.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  436.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  437.         }
  439.         $objRow->typePrefix = 'mod_';
  441.         /** @var Module $objModule */
  442.         $objModule = new $strClass($objRow, $strColumn);
  443.         $strBuffer = $objModule->generate();
  445.         // HOOK: add custom logic
  446.         if (isset($GLOBALS['TL_HOOKS']['getFrontendModule']) && \is_array($GLOBALS['TL_HOOKS']['getFrontendModule']))
  447.         {
  448.             foreach ($GLOBALS['TL_HOOKS']['getFrontendModule'] as $callback)
  449.             {
  450.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objModule);
  451.             }
  452.         }
  454.         // Disable indexing if protected
  455.         if ($objModule->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  456.         {
  457.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  458.         }
  460.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  461.         {
  462.             $objStopwatch->stop($strStopWatchId);
  463.         }
  465.         return $strBuffer;
  466.     }
  468.     /**
  469.      * Generate an article and return it as string
  470.      *
  471.      * @param mixed   $varId          The article ID or a Model object
  472.      * @param boolean $blnMultiMode   If true, only teasers will be shown
  473.      * @param boolean $blnIsInsertTag If true, there will be no page relation
  474.      * @param string  $strColumn      The name of the column
  475.      *
  476.      * @return string|boolean The article HTML markup or false
  477.      */
  478.     public static function getArticle($varId, $blnMultiMode=false, $blnIsInsertTag=false, $strColumn='main')
  479.     {
  480.         /** @var PageModel $objPage */
  481.         global $objPage;
  483.         if (\is_object($varId))
  484.         {
  485.             $objRow = $varId;
  486.         }
  487.         else
  488.         {
  489.             if (!$varId)
  490.             {
  491.                 return '';
  492.             }
  494.             $objRow = ArticleModel::findByIdOrAliasAndPid($varId, (!$blnIsInsertTag ? $objPage->id : null));
  496.             if ($objRow === null)
  497.             {
  498.                 return false;
  499.             }
  500.         }
  502.         // Check the visibility (see #6311)
  503.         if (!static::isVisibleElement($objRow))
  504.         {
  505.             return '';
  506.         }
  508.         // Print the article as PDF
  509.         if (isset($_GET['pdf']) && Input::get('pdf') == $objRow->id)
  510.         {
  511.             // Deprecated since Contao 4.0, to be removed in Contao 5.0
  512.             if ($objRow->printable == 1)
  513.             {
  514.                 @trigger_error('Setting tl_article.printable to "1" has been deprecated and will no longer work in Contao 5.0.', E_USER_DEPRECATED);
  516.                 $objArticle = new ModuleArticle($objRow);
  517.                 $objArticle->generatePdf();
  518.             }
  519.             elseif ($objRow->printable)
  520.             {
  521.                 $options = StringUtil::deserialize($objRow->printable);
  523.                 if (\is_array($options) && \in_array('pdf', $options))
  524.                 {
  525.                     $objArticle = new ModuleArticle($objRow);
  526.                     $objArticle->generatePdf();
  527.                 }
  528.             }
  529.         }
  531.         $objRow->headline = $objRow->title;
  532.         $objRow->multiMode = $blnMultiMode;
  534.         // HOOK: add custom logic
  535.         if (isset($GLOBALS['TL_HOOKS']['getArticle']) && \is_array($GLOBALS['TL_HOOKS']['getArticle']))
  536.         {
  537.             foreach ($GLOBALS['TL_HOOKS']['getArticle'] as $callback)
  538.             {
  539.                 static::importStatic($callback[0])->{$callback[1]}($objRow);
  540.             }
  541.         }
  543.         $strStopWatchId = 'contao.article (ID ' . $objRow->id . ')';
  545.         if (System::getContainer()->getParameter('kernel.debug'))
  546.         {
  547.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  548.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  549.         }
  551.         $objArticle = new ModuleArticle($objRow, $strColumn);
  552.         $strBuffer = $objArticle->generate($blnIsInsertTag);
  554.         // Disable indexing if protected
  555.         if ($objArticle->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  556.         {
  557.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  558.         }
  560.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  561.         {
  562.             $objStopwatch->stop($strStopWatchId);
  563.         }
  565.         return $strBuffer;
  566.     }
  568.     /**
  569.      * Generate a content element and return it as string
  570.      *
  571.      * @param mixed  $intId     A content element ID or a Model object
  572.      * @param string $strColumn The column the element is in
  573.      *
  574.      * @return string The content element HTML markup
  575.      */
  576.     public static function getContentElement($intId, $strColumn='main')
  577.     {
  578.         if (\is_object($intId))
  579.         {
  580.             $objRow = $intId;
  581.         }
  582.         else
  583.         {
  584.             if ($intId < 1 || !\strlen($intId))
  585.             {
  586.                 return '';
  587.             }
  589.             $objRow = ContentModel::findByPk($intId);
  591.             if ($objRow === null)
  592.             {
  593.                 return '';
  594.             }
  595.         }
  597.         // Check the visibility (see #6311)
  598.         if (!static::isVisibleElement($objRow))
  599.         {
  600.             return '';
  601.         }
  603.         $strClass = ContentElement::findClass($objRow->type);
  605.         // Return if the class does not exist
  606.         if (!class_exists($strClass))
  607.         {
  608.             static::log('Content element class "' . $strClass . '" (content element "' . $objRow->type . '") does not exist', __METHOD__, TL_ERROR);
  610.             return '';
  611.         }
  613.         $objRow->typePrefix = 'ce_';
  614.         $strStopWatchId = 'contao.content_element.' . $objRow->type . ' (ID ' . $objRow->id . ')';
  616.         if ($objRow->type != 'module' && System::getContainer()->getParameter('kernel.debug'))
  617.         {
  618.             $objStopwatch = System::getContainer()->get('debug.stopwatch');
  619.             $objStopwatch->start($strStopWatchId, 'contao.layout');
  620.         }
  622.         /** @var ContentElement $objElement */
  623.         $objElement = new $strClass($objRow, $strColumn);
  624.         $strBuffer = $objElement->generate();
  626.         // HOOK: add custom logic
  627.         if (isset($GLOBALS['TL_HOOKS']['getContentElement']) && \is_array($GLOBALS['TL_HOOKS']['getContentElement']))
  628.         {
  629.             foreach ($GLOBALS['TL_HOOKS']['getContentElement'] as $callback)
  630.             {
  631.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  632.             }
  633.         }
  635.         // Disable indexing if protected
  636.         if ($objElement->protected && !preg_match('/^\s*<!-- indexer::stop/', $strBuffer))
  637.         {
  638.             $strBuffer = "\n<!-- indexer::stop -->" . $strBuffer . "<!-- indexer::continue -->\n";
  639.         }
  641.         if (isset($objStopwatch) && $objStopwatch->isStarted($strStopWatchId))
  642.         {
  643.             $objStopwatch->stop($strStopWatchId);
  644.         }
  646.         return $strBuffer;
  647.     }
  649.     /**
  650.      * Generate a form and return it as string
  651.      *
  652.      * @param mixed   $varId     A form ID or a Model object
  653.      * @param string  $strColumn The column the form is in
  654.      * @param boolean $blnModule Render the form as module
  655.      *
  656.      * @return string The form HTML markup
  657.      */
  658.     public static function getForm($varId, $strColumn='main', $blnModule=false)
  659.     {
  660.         if (\is_object($varId))
  661.         {
  662.             $objRow = $varId;
  663.         }
  664.         else
  665.         {
  666.             if (!$varId)
  667.             {
  668.                 return '';
  669.             }
  671.             $objRow = FormModel::findByIdOrAlias($varId);
  673.             if ($objRow === null)
  674.             {
  675.                 return '';
  676.             }
  677.         }
  679.         $strClass = $blnModule ? Module::findClass('form') : ContentElement::findClass('form');
  681.         if (!class_exists($strClass))
  682.         {
  683.             static::log('Form class "' . $strClass . '" does not exist', __METHOD__, TL_ERROR);
  685.             return '';
  686.         }
  688.         $objRow->typePrefix = $blnModule ? 'mod_' : 'ce_';
  689.         $objRow->form = $objRow->id;
  691.         /** @var Form $objElement */
  692.         $objElement = new $strClass($objRow, $strColumn);
  693.         $strBuffer = $objElement->generate();
  695.         // HOOK: add custom logic
  696.         if (isset($GLOBALS['TL_HOOKS']['getForm']) && \is_array($GLOBALS['TL_HOOKS']['getForm']))
  697.         {
  698.             foreach ($GLOBALS['TL_HOOKS']['getForm'] as $callback)
  699.             {
  700.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($objRow, $strBuffer, $objElement);
  701.             }
  702.         }
  704.         return $strBuffer;
  705.     }
  707.     /**
  708.      * Return the languages for the TinyMCE spellchecker
  709.      *
  710.      * @return string The TinyMCE spellchecker language string
  711.      */
  712.     protected function getSpellcheckerString()
  713.     {
  714.         System::loadLanguageFile('languages');
  716.         $return = array();
  717.         $langs = scan(__DIR__ . '/../../languages');
  718.         array_unshift($langs, $GLOBALS['TL_LANGUAGE']);
  720.         foreach ($langs as $lang)
  721.         {
  722.             $lang = substr($lang, 0, 2);
  724.             if (isset($GLOBALS['TL_LANG']['LNG'][$lang]))
  725.             {
  726.                 $return[$lang] = $GLOBALS['TL_LANG']['LNG'][$lang] . '=' . $lang;
  727.             }
  728.         }
  730.         return '+' . implode(',', array_unique($return));
  731.     }
  733.     /**
  734.      * Calculate the page status icon name based on the page parameters
  735.      *
  736.      * @param PageModel|Result|\stdClass $objPage The page object
  737.      *
  738.      * @return string The status icon name
  739.      */
  740.     public static function getPageStatusIcon($objPage)
  741.     {
  742.         $sub = 0;
  743.         $image = $objPage->type . '.svg';
  745.         // Page not published or not active
  746.         if (!$objPage->published || ($objPage->start && $objPage->start > time()) || ($objPage->stop && $objPage->stop <= time()))
  747.         {
  748.             ++$sub;
  749.         }
  751.         // Page hidden from menu
  752.         if ($objPage->hide && !\in_array($objPage->type, array('root', 'error_401', 'error_403', 'error_404')))
  753.         {
  754.             $sub += 2;
  755.         }
  757.         // Page protected
  758.         if ($objPage->protected && !\in_array($objPage->type, array('root', 'error_401', 'error_403', 'error_404')))
  759.         {
  760.             $sub += 4;
  761.         }
  763.         // Get the image name
  764.         if ($sub > 0)
  765.         {
  766.             $image = $objPage->type . '_' . $sub . '.svg';
  767.         }
  769.         // HOOK: add custom logic
  770.         if (isset($GLOBALS['TL_HOOKS']['getPageStatusIcon']) && \is_array($GLOBALS['TL_HOOKS']['getPageStatusIcon']))
  771.         {
  772.             foreach ($GLOBALS['TL_HOOKS']['getPageStatusIcon'] as $callback)
  773.             {
  774.                 $image = static::importStatic($callback[0])->{$callback[1]}($objPage, $image);
  775.             }
  776.         }
  778.         return $image;
  779.     }
  781.     /**
  782.      * Check whether an element is visible in the front end
  783.      *
  784.      * @param Model|ContentModel|ModuleModel $objElement The element model
  785.      *
  786.      * @return boolean True if the element is visible
  787.      */
  788.     public static function isVisibleElement(Model $objElement)
  789.     {
  790.         $blnReturn = true;
  792.         // Only apply the restrictions in the front end
  793.         if (TL_MODE == 'FE')
  794.         {
  795.             $blnFeUserLoggedIn = System::getContainer()->get('contao.security.token_checker')->hasFrontendUser();
  797.             // Protected element
  798.             if ($objElement->protected)
  799.             {
  800.                 if (!$blnFeUserLoggedIn)
  801.                 {
  802.                     $blnReturn = false;
  803.                 }
  804.                 else
  805.                 {
  806.                     $objUser = FrontendUser::getInstance();
  808.                     if (!\is_array($objUser->groups))
  809.                     {
  810.                         $blnReturn = false;
  811.                     }
  812.                     else
  813.                     {
  814.                         $groups = StringUtil::deserialize($objElement->groups);
  816.                         if (empty($groups) || !\is_array($groups) || !\count(array_intersect($groups, $objUser->groups)))
  817.                         {
  818.                             $blnReturn = false;
  819.                         }
  820.                     }
  821.                 }
  822.             }
  824.             // Show to guests only
  825.             elseif ($objElement->guests && $blnFeUserLoggedIn)
  826.             {
  827.                 $blnReturn = false;
  828.             }
  829.         }
  831.         // HOOK: add custom logic
  832.         if (isset($GLOBALS['TL_HOOKS']['isVisibleElement']) && \is_array($GLOBALS['TL_HOOKS']['isVisibleElement']))
  833.         {
  834.             foreach ($GLOBALS['TL_HOOKS']['isVisibleElement'] as $callback)
  835.             {
  836.                 $blnReturn = static::importStatic($callback[0])->{$callback[1]}($objElement, $blnReturn);
  837.             }
  838.         }
  840.         return $blnReturn;
  841.     }
  843.     /**
  844.      * Replace insert tags with their values
  845.      *
  846.      * @param string  $strBuffer The text with the tags to be replaced
  847.      * @param boolean $blnCache  If false, non-cacheable tags will be replaced
  848.      *
  849.      * @return string The text with the replaced tags
  850.      */
  851.     public static function replaceInsertTags($strBuffer, $blnCache=true)
  852.     {
  853.         $objIt = new InsertTags();
  855.         return $objIt->replace($strBuffer, $blnCache);
  856.     }
  858.     /**
  859.      * Replace the dynamic script tags (see #4203)
  860.      *
  861.      * @param string $strBuffer The string with the tags to be replaced
  862.      *
  863.      * @return string The string with the replaced tags
  864.      */
  865.     public static function replaceDynamicScriptTags($strBuffer)
  866.     {
  867.         // HOOK: add custom logic
  868.         if (isset($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']) && \is_array($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags']))
  869.         {
  870.             foreach ($GLOBALS['TL_HOOKS']['replaceDynamicScriptTags'] as $callback)
  871.             {
  872.                 $strBuffer = static::importStatic($callback[0])->{$callback[1]}($strBuffer);
  873.             }
  874.         }
  876.         $arrReplace = array();
  877.         $strScripts = '';
  879.         // Add the internal jQuery scripts
  880.         if (!empty($GLOBALS['TL_JQUERY']) && \is_array($GLOBALS['TL_JQUERY']))
  881.         {
  882.             foreach (array_unique($GLOBALS['TL_JQUERY']) as $script)
  883.             {
  884.                 $strScripts .= $script;
  885.             }
  886.         }
  888.         $arrReplace['[[TL_JQUERY]]'] = $strScripts;
  889.         $strScripts = '';
  891.         // Add the internal MooTools scripts
  892.         if (!empty($GLOBALS['TL_MOOTOOLS']) && \is_array($GLOBALS['TL_MOOTOOLS']))
  893.         {
  894.             foreach (array_unique($GLOBALS['TL_MOOTOOLS']) as $script)
  895.             {
  896.                 $strScripts .= $script;
  897.             }
  898.         }
  900.         $arrReplace['[[TL_MOOTOOLS]]'] = $strScripts;
  901.         $strScripts = '';
  903.         // Add the internal <body> tags
  904.         if (!empty($GLOBALS['TL_BODY']) && \is_array($GLOBALS['TL_BODY']))
  905.         {
  906.             foreach (array_unique($GLOBALS['TL_BODY']) as $script)
  907.             {
  908.                 $strScripts .= $script;
  909.             }
  910.         }
  912.         global $objPage;
  914.         $objLayout = LayoutModel::findByPk($objPage->layoutId);
  915.         $blnCombineScripts = ($objLayout === null) ? false : $objLayout->combineScripts;
  917.         $arrReplace['[[TL_BODY]]'] = $strScripts;
  918.         $strScripts = '';
  920.         $objCombiner = new Combiner();
  922.         // Add the CSS framework style sheets
  923.         if (!empty($GLOBALS['TL_FRAMEWORK_CSS']) && \is_array($GLOBALS['TL_FRAMEWORK_CSS']))
  924.         {
  925.             foreach (array_unique($GLOBALS['TL_FRAMEWORK_CSS']) as $stylesheet)
  926.             {
  927.                 $objCombiner->add($stylesheet);
  928.             }
  929.         }
  931.         // Add the internal style sheets
  932.         if (!empty($GLOBALS['TL_CSS']) && \is_array($GLOBALS['TL_CSS']))
  933.         {
  934.             foreach (array_unique($GLOBALS['TL_CSS']) as $stylesheet)
  935.             {
  936.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  938.                 if ($options->static)
  939.                 {
  940.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  941.                 }
  942.                 else
  943.                 {
  944.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  945.                 }
  946.             }
  947.         }
  949.         // Add the user style sheets
  950.         if (!empty($GLOBALS['TL_USER_CSS']) && \is_array($GLOBALS['TL_USER_CSS']))
  951.         {
  952.             foreach (array_unique($GLOBALS['TL_USER_CSS']) as $stylesheet)
  953.             {
  954.                 $options = StringUtil::resolveFlaggedUrl($stylesheet);
  956.                 if ($options->static)
  957.                 {
  958.                     $objCombiner->add($stylesheet, $options->mtime, $options->media);
  959.                 }
  960.                 else
  961.                 {
  962.                     $strScripts .= Template::generateStyleTag(static::addAssetsUrlTo($stylesheet), $options->media, $options->mtime);
  963.                 }
  964.             }
  965.         }
  967.         // Create the aggregated style sheet
  968.         if ($objCombiner->hasEntries())
  969.         {
  970.             if ($blnCombineScripts)
  971.             {
  972.                 $strScripts .= Template::generateStyleTag($objCombiner->getCombinedFile(), 'all');
  973.             }
  974.             else
  975.             {
  976.                 foreach ($objCombiner->getFileUrls() as $strUrl)
  977.                 {
  978.                     $options = StringUtil::resolveFlaggedUrl($strUrl);
  979.                     $strScripts .= Template::generateStyleTag($strUrl, $options->media, $options->mtime);
  980.                 }
  981.             }
  982.         }
  984.         $arrReplace['[[TL_CSS]]'] = $strScripts;
  985.         $strScripts = '';
  987.         // Add the internal scripts
  988.         if (!empty($GLOBALS['TL_JAVASCRIPT']) && \is_array($GLOBALS['TL_JAVASCRIPT']))
  989.         {
  990.             $objCombiner = new Combiner();
  991.             $objCombinerAsync = new Combiner();
  993.             foreach (array_unique($GLOBALS['TL_JAVASCRIPT']) as $javascript)
  994.             {
  995.                 $options = StringUtil::resolveFlaggedUrl($javascript);
  997.                 if ($options->static)
  998.                 {
  999.                     $options->async ? $objCombinerAsync->add($javascript, $options->mtime) : $objCombiner->add($javascript, $options->mtime);
  1000.                 }
  1001.                 else
  1002.                 {
  1003.                     $strScripts .= Template::generateScriptTag(static::addAssetsUrlTo($javascript), $options->async, $options->mtime);
  1004.                 }
  1005.             }
  1007.             // Create the aggregated script and add it before the non-static scripts (see #4890)
  1008.             if ($objCombiner->hasEntries())
  1009.             {
  1010.                 if ($blnCombineScripts)
  1011.                 {
  1012.                     $strScripts = Template::generateScriptTag($objCombiner->getCombinedFile()) . $strScripts;
  1013.                 }
  1014.                 else
  1015.                 {
  1016.                     $arrReversed = array_reverse($objCombiner->getFileUrls());
  1018.                     foreach ($arrReversed as $strUrl)
  1019.                     {
  1020.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  1021.                         $strScripts = Template::generateScriptTag($strUrl, false, $options->mtime) . $strScripts;
  1022.                     }
  1023.                 }
  1024.             }
  1026.             if ($objCombinerAsync->hasEntries())
  1027.             {
  1028.                 if ($blnCombineScripts)
  1029.                 {
  1030.                     $strScripts = Template::generateScriptTag($objCombinerAsync->getCombinedFile(), true) . $strScripts;
  1031.                 }
  1032.                 else
  1033.                 {
  1034.                     $arrReversed = array_reverse($objCombinerAsync->getFileUrls());
  1036.                     foreach ($arrReversed as $strUrl)
  1037.                     {
  1038.                         $options = StringUtil::resolveFlaggedUrl($strUrl);
  1039.                         $strScripts = Template::generateScriptTag($strUrl, true, $options->mtime) . $strScripts;
  1040.                     }
  1041.                 }
  1042.             }
  1043.         }
  1045.         // Add the internal <head> tags
  1046.         if (!empty($GLOBALS['TL_HEAD']) && \is_array($GLOBALS['TL_HEAD']))
  1047.         {
  1048.             foreach (array_unique($GLOBALS['TL_HEAD']) as $head)
  1049.             {
  1050.                 $strScripts .= $head;
  1051.             }
  1052.         }
  1054.         $arrReplace['[[TL_HEAD]]'] = $strScripts;
  1056.         return str_replace(array_keys($arrReplace), $arrReplace, $strBuffer);
  1057.     }
  1059.     /**
  1060.      * Compile the margin format definition based on an array of values
  1061.      *
  1062.      * @param array  $arrValues An array of four values and a unit
  1063.      * @param string $strType   Either "margin" or "padding"
  1064.      *
  1065.      * @return string The CSS markup
  1066.      */
  1067.     public static function generateMargin($arrValues, $strType='margin')
  1068.     {
  1069.         // Initialize an empty array (see #5217)
  1070.         if (!\is_array($arrValues))
  1071.         {
  1072.             $arrValues = array('top'=>'', 'right'=>'', 'bottom'=>'', 'left'=>'', 'unit'=>'');
  1073.         }
  1075.         $top = $arrValues['top'];
  1076.         $right = $arrValues['right'];
  1077.         $bottom = $arrValues['bottom'];
  1078.         $left = $arrValues['left'];
  1080.         // Try to shorten the definition
  1081.         if ($top && $right  && $bottom  && $left)
  1082.         {
  1083.             if ($top == $right && $top == $bottom && $top == $left)
  1084.             {
  1085.                 return $strType . ':' . $top . $arrValues['unit'] . ';';
  1086.             }
  1088.             if ($top == $bottom && $right == $left)
  1089.             {
  1090.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1091.             }
  1093.             if ($top != $bottom && $right == $left)
  1094.             {
  1095.                 return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ';';
  1096.             }
  1098.             return $strType . ':' . $top . $arrValues['unit'] . ' ' . $right . $arrValues['unit'] . ' ' . $bottom . $arrValues['unit'] . ' ' . $left . $arrValues['unit'] . ';';
  1099.         }
  1101.         $return = array();
  1102.         $arrDir = compact('top', 'right', 'bottom', 'left');
  1104.         foreach ($arrDir as $k=>$v)
  1105.         {
  1106.             if ($v)
  1107.             {
  1108.                 $return[] = $strType . '-' . $k . ':' . $v . $arrValues['unit'] . ';';
  1109.             }
  1110.         }
  1112.         return implode('', $return);
  1113.     }
  1115.     /**
  1116.      * Add a request string to the current URL
  1117.      *
  1118.      * @param string  $strRequest The string to be added
  1119.      * @param boolean $blnAddRef  Add the referer ID
  1120.      * @param array   $arrUnset   An optional array of keys to unset
  1121.      *
  1122.      * @return string The new URL
  1123.      */
  1124.     public static function addToUrl($strRequest, $blnAddRef=true, $arrUnset=array())
  1125.     {
  1126.         $pairs = array();
  1127.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  1129.         if ($request->server->has('QUERY_STRING'))
  1130.         {
  1131.             $cacheKey = md5($request->server->get('QUERY_STRING'));
  1133.             if (!isset(static::$arrQueryCache[$cacheKey]))
  1134.             {
  1135.                 parse_str($request->server->get('QUERY_STRING'), $pairs);
  1136.                 ksort($pairs);
  1138.                 static::$arrQueryCache[$cacheKey] = $pairs;
  1139.             }
  1141.             $pairs = static::$arrQueryCache[$cacheKey];
  1142.         }
  1144.         // Remove the request token and referer ID
  1145.         unset($pairs['rt'], $pairs['ref']);
  1147.         foreach ($arrUnset as $key)
  1148.         {
  1149.             unset($pairs[$key]);
  1150.         }
  1152.         // Merge the request string to be added
  1153.         if ($strRequest)
  1154.         {
  1155.             parse_str(str_replace('&amp;', '&', $strRequest), $newPairs);
  1156.             $pairs = array_merge($pairs, $newPairs);
  1157.         }
  1159.         // Add the referer ID
  1160.         if ($request->query->has('ref') || ($strRequest && $blnAddRef))
  1161.         {
  1162.             $pairs['ref'] = $request->attributes->get('_contao_referer_id');
  1163.         }
  1165.         $uri = '';
  1167.         if (!empty($pairs))
  1168.         {
  1169.             $uri = '?' . http_build_query($pairs, '', '&amp;', PHP_QUERY_RFC3986);
  1170.         }
  1172.         return TL_SCRIPT . $uri;
  1173.     }
  1175.     /**
  1176.      * Reload the current page
  1177.      */
  1178.     public static function reload()
  1179.     {
  1180.         static::redirect(Environment::get('uri'));
  1181.     }
  1183.     /**
  1184.      * Redirect to another page
  1185.      *
  1186.      * @param string  $strLocation The target URL
  1187.      * @param integer $intStatus   The HTTP status code (defaults to 303)
  1188.      */
  1189.     public static function redirect($strLocation, $intStatus=303)
  1190.     {
  1191.         $strLocation = str_replace('&amp;', '&', $strLocation);
  1192.         $strLocation = static::replaceOldBePaths($strLocation);
  1194.         // Make the location an absolute URL
  1195.         if (!preg_match('@^https?://@i', $strLocation))
  1196.         {
  1197.             $strLocation = Environment::get('base') . ltrim($strLocation, '/');
  1198.         }
  1200.         // Ajax request
  1201.         if (Environment::get('isAjaxRequest'))
  1202.         {
  1203.             throw new AjaxRedirectResponseException($strLocation);
  1204.         }
  1206.         throw new RedirectResponseException($strLocation, $intStatus);
  1207.     }
  1209.     /**
  1210.      * Replace the old back end paths
  1211.      *
  1212.      * @param string $strContext The context
  1213.      *
  1214.      * @return string The modified context
  1215.      */
  1216.     protected static function replaceOldBePaths($strContext)
  1217.     {
  1218.         $arrCache = &self::$arrOldBePathCache;
  1220.         $arrMapper = array
  1221.         (
  1222.             'contao/confirm.php'   => 'contao_backend_confirm',
  1223.             'contao/file.php'      => 'contao_backend_file',
  1224.             'contao/help.php'      => 'contao_backend_help',
  1225.             'contao/index.php'     => 'contao_backend_login',
  1226.             'contao/main.php'      => 'contao_backend',
  1227.             'contao/page.php'      => 'contao_backend_page',
  1228.             'contao/password.php'  => 'contao_backend_password',
  1229.             'contao/popup.php'     => 'contao_backend_popup',
  1230.             'contao/preview.php'   => 'contao_backend_preview',
  1231.         );
  1233.         $replace = static function ($matches) use ($arrMapper, &$arrCache)
  1234.         {
  1235.             $key = $matches[0];
  1237.             if (!isset($arrCache[$key]))
  1238.             {
  1239.                 $router = System::getContainer()->get('router');
  1240.                 $arrCache[$key] = substr($router->generate($arrMapper[$key]), \strlen(Environment::get('path')) + 1);
  1241.             }
  1243.             return $arrCache[$key];
  1244.         };
  1246.         $regex = '(' . implode('|', array_map('preg_quote', array_keys($arrMapper))) . ')';
  1248.         return preg_replace_callback($regex, $replace, $strContext);
  1249.     }
  1251.     /**
  1252.      * Generate a front end URL
  1253.      *
  1254.      * @param array   $arrRow       An array of page parameters
  1255.      * @param string  $strParams    An optional string of URL parameters
  1256.      * @param string  $strForceLang Force a certain language
  1257.      * @param boolean $blnFixDomain Check the domain of the target page and append it if necessary
  1258.      *
  1259.      * @return string An URL that can be used in the front end
  1260.      *
  1261.      * @deprecated Deprecated since Contao 4.2, to be removed in Contao 5.0.
  1262.      *             Use the contao.routing.url_generator service or PageModel::getFrontendUrl() instead.
  1263.      */
  1264.     public static function generateFrontendUrl(array $arrRow, $strParams=null, $strForceLang=null, $blnFixDomain=false)
  1265.     {
  1266.         @trigger_error('Using Controller::generateFrontendUrl() has been deprecated and will no longer work in Contao 5.0. Use the contao.routing.url_generator service or PageModel::getFrontendUrl() instead.', E_USER_DEPRECATED);
  1268.         if (!isset($arrRow['rootId']))
  1269.         {
  1270.             $row = PageModel::findWithDetails($arrRow['id']);
  1272.             $arrRow['rootId'] = $row->rootId;
  1274.             foreach (array('domain', 'rootLanguage', 'rootUseSSL') as $key)
  1275.             {
  1276.                 if (!isset($arrRow[$key]))
  1277.                 {
  1278.                     $arrRow[$key] = $row->$key;
  1279.                 }
  1280.             }
  1281.         }
  1283.         $arrParams = array();
  1285.         // Set the language
  1286.         if ($strForceLang)
  1287.         {
  1288.             $arrParams['_locale'] = $strForceLang;
  1289.         }
  1290.         elseif (isset($arrRow['rootLanguage']))
  1291.         {
  1292.             $arrParams['_locale'] = $arrRow['rootLanguage'];
  1293.         }
  1294.         elseif (isset($arrRow['language']) && $arrRow['type'] == 'root')
  1295.         {
  1296.             $arrParams['_locale'] = $arrRow['language'];
  1297.         }
  1298.         elseif (TL_MODE == 'FE')
  1299.         {
  1300.             /** @var PageModel $objPage */
  1301.             global $objPage;
  1303.             $arrParams['_locale'] = $objPage->rootLanguage;
  1304.         }
  1306.         // Add the domain if it differs from the current one (see #3765 and #6927)
  1307.         if ($blnFixDomain)
  1308.         {
  1309.             $arrParams['_domain'] = $arrRow['domain'];
  1310.             $arrParams['_ssl'] = (bool) $arrRow['rootUseSSL'];
  1311.         }
  1313.         $objUrlGenerator = System::getContainer()->get('contao.routing.url_generator');
  1314.         $strUrl = $objUrlGenerator->generate(($arrRow['alias'] ?: $arrRow['id']) . $strParams, $arrParams);
  1316.         // Remove path from absolute URLs
  1317.         if (0 === strncmp($strUrl, '/', 1))
  1318.         {
  1319.             $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  1320.         }
  1322.         // Decode sprintf placeholders
  1323.         if (strpos($strParams, '%') !== false)
  1324.         {
  1325.             $arrMatches = array();
  1326.             preg_match_all('/%([sducoxXbgGeEfF])/', $strParams, $arrMatches);
  1328.             foreach (array_unique($arrMatches[1]) as $v)
  1329.             {
  1330.                 $strUrl = str_replace('%25' . $v, '%' . $v, $strUrl);
  1331.             }
  1332.         }
  1334.         // HOOK: add custom logic
  1335.         if (isset($GLOBALS['TL_HOOKS']['generateFrontendUrl']) && \is_array($GLOBALS['TL_HOOKS']['generateFrontendUrl']))
  1336.         {
  1337.             foreach ($GLOBALS['TL_HOOKS']['generateFrontendUrl'] as $callback)
  1338.             {
  1339.                 $strUrl = static::importStatic($callback[0])->{$callback[1]}($arrRow, $strParams, $strUrl);
  1340.             }
  1341.         }
  1343.         return $strUrl;
  1344.     }
  1346.     /**
  1347.      * Convert relative URLs in href and src attributes to absolute URLs
  1348.      *
  1349.      * @param string  $strContent  The text with the URLs to be converted
  1350.      * @param string  $strBase     An optional base URL
  1351.      * @param boolean $blnHrefOnly If true, only href attributes will be converted
  1352.      *
  1353.      * @return string The text with the replaced URLs
  1354.      */
  1355.     public static function convertRelativeUrls($strContent, $strBase='', $blnHrefOnly=false)
  1356.     {
  1357.         if (!$strBase)
  1358.         {
  1359.             $strBase = Environment::get('base');
  1360.         }
  1362.         $search = $blnHrefOnly ? 'href' : 'href|src';
  1363.         $arrUrls = preg_split('/((' . $search . ')="([^"]+)")/i', $strContent, -1, PREG_SPLIT_DELIM_CAPTURE);
  1364.         $strContent = '';
  1366.         for ($i=0, $c=\count($arrUrls); $i<$c; $i+=4)
  1367.         {
  1368.             $strContent .= $arrUrls[$i];
  1370.             if (!isset($arrUrls[$i+2]))
  1371.             {
  1372.                 continue;
  1373.             }
  1375.             $strAttribute = $arrUrls[$i+2];
  1376.             $strUrl = $arrUrls[$i+3];
  1378.             if (!preg_match('@^(?:[a-z0-9]+:|#)@i', $strUrl))
  1379.             {
  1380.                 $strUrl = $strBase . (($strUrl != '/') ? $strUrl : '');
  1381.             }
  1383.             $strContent .= $strAttribute . '="' . $strUrl . '"';
  1384.         }
  1386.         return $strContent;
  1387.     }
  1389.     /**
  1390.      * Send a file to the browser so the "save as …" dialogue opens
  1391.      *
  1392.      * @param string  $strFile The file path
  1393.      * @param boolean $inline  Show the file in the browser instead of opening the download dialog
  1394.      *
  1395.      * @throws AccessDeniedException
  1396.      */
  1397.     public static function sendFileToBrowser($strFile, $inline=false)
  1398.     {
  1399.         // Make sure there are no attempts to hack the file system
  1400.         if (preg_match('@^\.+@', $strFile) || preg_match('@\.+/@', $strFile) || preg_match('@(://)+@', $strFile))
  1401.         {
  1402.             throw new PageNotFoundException('Invalid file name');
  1403.         }
  1405.         // Limit downloads to the files directory
  1406.         if (!preg_match('@^' . preg_quote(Config::get('uploadPath'), '@') . '@i', $strFile))
  1407.         {
  1408.             throw new PageNotFoundException('Invalid path');
  1409.         }
  1411.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1413.         // Check whether the file exists
  1414.         if (!file_exists($projectDir . '/' . $strFile))
  1415.         {
  1416.             throw new PageNotFoundException('File not found');
  1417.         }
  1419.         $objFile = new File($strFile);
  1420.         $arrAllowedTypes = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1422.         // Check whether the file type is allowed to be downloaded
  1423.         if (!\in_array($objFile->extension, $arrAllowedTypes))
  1424.         {
  1425.             throw new AccessDeniedException(sprintf('File type "%s" is not allowed', $objFile->extension));
  1426.         }
  1428.         // HOOK: post download callback
  1429.         if (isset($GLOBALS['TL_HOOKS']['postDownload']) && \is_array($GLOBALS['TL_HOOKS']['postDownload']))
  1430.         {
  1431.             foreach ($GLOBALS['TL_HOOKS']['postDownload'] as $callback)
  1432.             {
  1433.                 static::importStatic($callback[0])->{$callback[1]}($strFile);
  1434.             }
  1435.         }
  1437.         // Send the file (will stop the script execution)
  1438.         $objFile->sendToBrowser('', $inline);
  1439.     }
  1441.     /**
  1442.      * Load a set of DCA files
  1443.      *
  1444.      * @param string  $strTable   The table name
  1445.      * @param boolean $blnNoCache If true, the cache will be bypassed
  1446.      */
  1447.     public static function loadDataContainer($strTable, $blnNoCache=false)
  1448.     {
  1449.         $loader = new DcaLoader($strTable);
  1450.         $loader->load($blnNoCache);
  1451.     }
  1453.     /**
  1454.      * Do not name this "reset" because it might result in conflicts with child classes
  1455.      * @see https://github.com/contao/contao/issues/4257
  1456.      *
  1457.      * @internal
  1458.      */
  1459.     public static function resetControllerCache()
  1460.     {
  1461.         self::$arrQueryCache = array();
  1462.         self::$arrOldBePathCache = array();
  1463.     }
  1465.     /**
  1466.      * Redirect to a front end page
  1467.      *
  1468.      * @param integer $intPage    The page ID
  1469.      * @param string  $strArticle An optional article alias
  1470.      * @param boolean $blnReturn  If true, return the URL and don't redirect
  1471.      *
  1472.      * @return string The URL of the target page
  1473.      */
  1474.     protected function redirectToFrontendPage($intPage, $strArticle=null, $blnReturn=false)
  1475.     {
  1476.         if (($intPage = (int) $intPage) <= 0)
  1477.         {
  1478.             return '';
  1479.         }
  1481.         $objPage = PageModel::findWithDetails($intPage);
  1483.         if ($objPage === null)
  1484.         {
  1485.             return '';
  1486.         }
  1488.         $strParams = null;
  1490.         // Add the /article/ fragment (see #673)
  1491.         if ($strArticle !== null && ($objArticle = ArticleModel::findByAlias($strArticle)) !== null)
  1492.         {
  1493.             $strParams = '/articles/' . (($objArticle->inColumn != 'main') ? $objArticle->inColumn . ':' : '') . $strArticle;
  1494.         }
  1496.         $strUrl = $objPage->getPreviewUrl($strParams);
  1498.         if (!$blnReturn)
  1499.         {
  1500.             $this->redirect($strUrl);
  1501.         }
  1503.         return $strUrl;
  1504.     }
  1506.     /**
  1507.      * Get the parent records of an entry and return them as string which can
  1508.      * be used in a log message
  1509.      *
  1510.      * @param string  $strTable The table name
  1511.      * @param integer $intId    The record ID
  1512.      *
  1513.      * @return string A string that can be used in a log message
  1514.      */
  1515.     protected function getParentEntries($strTable, $intId)
  1516.     {
  1517.         // No parent table
  1518.         if (empty($GLOBALS['TL_DCA'][$strTable]['config']['ptable']))
  1519.         {
  1520.             return '';
  1521.         }
  1523.         $arrParent = array();
  1525.         do
  1526.         {
  1527.             // Get the pid
  1528.             $objParent = $this->Database->prepare("SELECT pid FROM " . $strTable . " WHERE id=?")
  1529.                                         ->limit(1)
  1530.                                         ->execute($intId);
  1532.             if ($objParent->numRows < 1)
  1533.             {
  1534.                 break;
  1535.             }
  1537.             // Store the parent table information
  1538.             $strTable = $GLOBALS['TL_DCA'][$strTable]['config']['ptable'];
  1539.             $intId = $objParent->pid;
  1541.             // Add the log entry
  1542.             $arrParent[] = $strTable . '.id=' . $intId;
  1544.             // Load the data container of the parent table
  1545.             $this->loadDataContainer($strTable);
  1546.         }
  1547.         while ($intId && isset($GLOBALS['TL_DCA'][$strTable]['config']['ptable']));
  1549.         if (empty($arrParent))
  1550.         {
  1551.             return '';
  1552.         }
  1554.         return ' (parent records: ' . implode(', ', $arrParent) . ')';
  1555.     }
  1557.     /**
  1558.      * Take an array of file paths and eliminate the nested ones
  1559.      *
  1560.      * @param array $arrPaths The array of file paths
  1561.      *
  1562.      * @return array The file paths array without the nested paths
  1563.      */
  1564.     protected function eliminateNestedPaths($arrPaths)
  1565.     {
  1566.         $arrPaths = array_filter($arrPaths);
  1568.         if (empty($arrPaths) || !\is_array($arrPaths))
  1569.         {
  1570.             return array();
  1571.         }
  1573.         $nested = array();
  1575.         foreach ($arrPaths as $path)
  1576.         {
  1577.             $nested[] = preg_grep('/^' . preg_quote($path, '/') . '\/.+/', $arrPaths);
  1578.         }
  1580.         if (!empty($nested))
  1581.         {
  1582.             $nested = array_merge(...$nested);
  1583.         }
  1585.         return array_values(array_diff($arrPaths, $nested));
  1586.     }
  1588.     /**
  1589.      * Take an array of pages and eliminate the nested ones
  1590.      *
  1591.      * @param array   $arrPages   The array of page IDs
  1592.      * @param string  $strTable   The table name
  1593.      * @param boolean $blnSorting True if the table has a sorting field
  1594.      *
  1595.      * @return array The page IDs array without the nested IDs
  1596.      */
  1597.     protected function eliminateNestedPages($arrPages, $strTable=null, $blnSorting=false)
  1598.     {
  1599.         if (empty($arrPages) || !\is_array($arrPages))
  1600.         {
  1601.             return array();
  1602.         }
  1604.         if (!$strTable)
  1605.         {
  1606.             $strTable = 'tl_page';
  1607.         }
  1609.         // Thanks to Andreas Schempp (see #2475 and #3423)
  1610.         $arrPages = array_intersect($arrPages, $this->Database->getChildRecords(0, $strTable, $blnSorting));
  1611.         $arrPages = array_values(array_diff($arrPages, $this->Database->getChildRecords($arrPages, $strTable, $blnSorting)));
  1613.         return $arrPages;
  1614.     }
  1616.     /**
  1617.      * Add an image to a template
  1618.      *
  1619.      * @param object     $objTemplate   The template object to add the image to
  1620.      * @param array      $arrItem       The element or module as array
  1621.      * @param integer    $intMaxWidth   An optional maximum width of the image
  1622.      * @param string     $strLightboxId An optional lightbox ID
  1623.      * @param FilesModel $objModel      An optional files model
  1624.      */
  1625.     public static function addImageToTemplate($objTemplate, $arrItem, $intMaxWidth=null, $strLightboxId=null, FilesModel $objModel=null)
  1626.     {
  1627.         try
  1628.         {
  1629.             $objFile = new File($arrItem['singleSRC']);
  1630.         }
  1631.         catch (\Exception $e)
  1632.         {
  1633.             $objFile = null;
  1634.         }
  1636.         $imgSize = $objFile->imageSize ?? array();
  1637.         $size = StringUtil::deserialize($arrItem['size']);
  1639.         if (is_numeric($size))
  1640.         {
  1641.             $size = array(0, 0, (int) $size);
  1642.         }
  1643.         elseif (!$size instanceof PictureConfiguration)
  1644.         {
  1645.             if (!\is_array($size))
  1646.             {
  1647.                 $size = array();
  1648.             }
  1650.             $size += array(0, 0, 'crop');
  1651.         }
  1653.         if ($intMaxWidth === null)
  1654.         {
  1655.             $intMaxWidth = Config::get('maxImageWidth');
  1656.         }
  1658.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  1660.         if ($request && System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  1661.         {
  1662.             $arrMargin = array();
  1663.         }
  1664.         else
  1665.         {
  1666.             $arrMargin = StringUtil::deserialize($arrItem['imagemargin']);
  1667.         }
  1669.         // Store the original dimensions
  1670.         $objTemplate->width = $imgSize[0];
  1671.         $objTemplate->height = $imgSize[1];
  1673.         // Adjust the image size
  1674.         if ($intMaxWidth > 0)
  1675.         {
  1676.             @trigger_error('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.', E_USER_DEPRECATED);
  1678.             // Subtract the margins before deciding whether to resize (see #6018)
  1679.             if (\is_array($arrMargin) && $arrMargin['unit'] == 'px')
  1680.             {
  1681.                 $intMargin = (int) $arrMargin['left'] + (int) $arrMargin['right'];
  1683.                 // Reset the margin if it exceeds the maximum width (see #7245)
  1684.                 if ($intMaxWidth - $intMargin < 1)
  1685.                 {
  1686.                     $arrMargin['left'] = '';
  1687.                     $arrMargin['right'] = '';
  1688.                 }
  1689.                 else
  1690.                 {
  1691.                     $intMaxWidth -= $intMargin;
  1692.                 }
  1693.             }
  1695.             if (\is_array($size) && ($size[0] > $intMaxWidth || (!$size[0] && !$size[1] && (!$imgSize[0] || $imgSize[0] > $intMaxWidth))))
  1696.             {
  1697.                 // See #2268 (thanks to Thyon)
  1698.                 $ratio = ($size[0] && $size[1]) ? $size[1] / $size[0] : (($imgSize[0] && $imgSize[1]) ? $imgSize[1] / $imgSize[0] : 0);
  1700.                 $size[0] = $intMaxWidth;
  1701.                 $size[1] = floor($intMaxWidth * $ratio);
  1702.             }
  1703.         }
  1705.         $container = System::getContainer();
  1707.         try
  1708.         {
  1709.             $projectDir = $container->getParameter('kernel.project_dir');
  1710.             $staticUrl = $container->get('contao.assets.files_context')->getStaticUrl();
  1711.             $picture = $container->get('contao.image.picture_factory')->create($projectDir . '/' . $arrItem['singleSRC'], $size);
  1713.             $picture = array
  1714.             (
  1715.                 'img' => $picture->getImg($projectDir, $staticUrl),
  1716.                 'sources' => $picture->getSources($projectDir, $staticUrl)
  1717.             );
  1719.             $src = $picture['img']['src'];
  1721.             if ($src !== $arrItem['singleSRC'])
  1722.             {
  1723.                 $objFile = new File(rawurldecode($src));
  1724.             }
  1725.         }
  1726.         catch (\Exception $e)
  1727.         {
  1728.             System::log('Image "' . $arrItem['singleSRC'] . '" could not be processed: ' . $e->getMessage(), __METHOD__, TL_ERROR);
  1730.             $src = '';
  1731.             $picture = array('img'=>array('src'=>'', 'srcset'=>''), 'sources'=>array());
  1732.         }
  1734.         // Image dimensions
  1735.         if ($objFile && isset($objFile->imageSize[0], $objFile->imageSize[1]))
  1736.         {
  1737.             $objTemplate->arrSize = $objFile->imageSize;
  1738.             $objTemplate->imgSize = ' width="' . $objFile->imageSize[0] . '" height="' . $objFile->imageSize[1] . '"';
  1739.         }
  1741.         $arrMeta = array();
  1743.         // Load the meta data
  1744.         if ($objModel instanceof FilesModel)
  1745.         {
  1746.             if (TL_MODE == 'FE')
  1747.             {
  1748.                 global $objPage;
  1750.                 $arrMeta = Frontend::getMetaData($objModel->meta, $objPage->language);
  1752.                 if (empty($arrMeta) && $objPage->rootFallbackLanguage !== null)
  1753.                 {
  1754.                     $arrMeta = Frontend::getMetaData($objModel->meta, $objPage->rootFallbackLanguage);
  1755.                 }
  1756.             }
  1757.             else
  1758.             {
  1759.                 $arrMeta = Frontend::getMetaData($objModel->meta, $GLOBALS['TL_LANGUAGE']);
  1760.             }
  1762.             self::loadDataContainer('tl_files');
  1764.             // Add any missing fields
  1765.             foreach (array_keys($GLOBALS['TL_DCA']['tl_files']['fields']['meta']['eval']['metaFields']) as $k)
  1766.             {
  1767.                 if (!isset($arrMeta[$k]))
  1768.                 {
  1769.                     $arrMeta[$k] = '';
  1770.                 }
  1771.             }
  1773.             $arrMeta['imageTitle'] = $arrMeta['title'];
  1774.             $arrMeta['imageUrl'] = $arrMeta['link'];
  1775.             unset($arrMeta['title'], $arrMeta['link']);
  1777.             // Add the meta data to the item
  1778.             if (!$arrItem['overwriteMeta'])
  1779.             {
  1780.                 foreach ($arrMeta as $k=>$v)
  1781.                 {
  1782.                     switch ($k)
  1783.                     {
  1784.                         case 'alt':
  1785.                         case 'imageTitle':
  1786.                             $arrItem[$k] = StringUtil::specialchars($v);
  1787.                             break;
  1789.                         default:
  1790.                             $arrItem[$k] = $v;
  1791.                             break;
  1792.                     }
  1793.                 }
  1794.             }
  1795.         }
  1797.         $picture['alt'] = StringUtil::specialchars($arrItem['alt']);
  1799.         // Move the title to the link tag so it is shown in the lightbox
  1800.         if ($arrItem['imageTitle'] && !$arrItem['linkTitle'] && ($arrItem['fullsize'] || $arrItem['imageUrl']))
  1801.         {
  1802.             $arrItem['linkTitle'] = $arrItem['imageTitle'];
  1803.             unset($arrItem['imageTitle']);
  1804.         }
  1806.         if (isset($arrItem['imageTitle']))
  1807.         {
  1808.             $picture['title'] = StringUtil::specialchars($arrItem['imageTitle']);
  1809.         }
  1811.         $objTemplate->picture = $picture;
  1813.         // Provide an ID for single lightbox images in HTML5 (see #3742)
  1814.         if ($strLightboxId === null && $arrItem['fullsize'] && $objTemplate instanceof Template && !empty($arrItem['id']))
  1815.         {
  1816.             $strLightboxId = substr(md5($objTemplate->getName() . '_' . $arrItem['id']), 0, 6);
  1817.         }
  1819.         // Float image
  1820.         if ($arrItem['floating'])
  1821.         {
  1822.             $objTemplate->floatClass = ' float_' . $arrItem['floating'];
  1823.         }
  1825.         // Do not override the "href" key (see #6468)
  1826.         $strHrefKey = $objTemplate->href ? 'imageHref' : 'href';
  1827.         $lightboxSize = StringUtil::deserialize($arrItem['lightboxSize'] ?? null, true);
  1829.         if (!$lightboxSize && $arrItem['fullsize'] && isset($GLOBALS['objPage']->layoutId))
  1830.         {
  1831.             $lightboxSize = StringUtil::deserialize(LayoutModel::findByPk($GLOBALS['objPage']->layoutId)->lightboxSize ?? null, true);
  1832.         }
  1834.         // Image link
  1835.         if (TL_MODE == 'FE' && $arrItem['imageUrl'])
  1836.         {
  1837.             $objTemplate->$strHrefKey = $arrItem['imageUrl'];
  1838.             $objTemplate->attributes = '';
  1840.             if ($arrItem['fullsize'])
  1841.             {
  1842.                 // Always replace insert tags (see #2674)
  1843.                 $imageUrl = self::replaceInsertTags($arrItem['imageUrl']);
  1845.                 $blnIsExternal = strncmp($imageUrl, 'http://', 7) === 0 || strncmp($imageUrl, 'https://', 8) === 0;
  1847.                 // Open images in the lightbox
  1848.                 if (preg_match('/\.(' . strtr(preg_quote(Config::get('validImageTypes'), '/'), ',', '|') . ')$/i', $imageUrl))
  1849.                 {
  1850.                     // Do not add the TL_FILES_URL to external URLs (see #4923)
  1851.                     if (!$blnIsExternal)
  1852.                     {
  1853.                         try
  1854.                         {
  1855.                             $projectDir = $container->getParameter('kernel.project_dir');
  1856.                             $staticUrl = $container->get('contao.assets.files_context')->getStaticUrl();
  1858.                             // The image url is always an url encoded string and must be decoded beforehand (see #2674)
  1859.                             $picture = $container->get('contao.image.picture_factory')->create($projectDir . '/' . urldecode($imageUrl), $lightboxSize);
  1861.                             $objTemplate->lightboxPicture = array
  1862.                             (
  1863.                                 'img' => $picture->getImg($projectDir, $staticUrl),
  1864.                                 'sources' => $picture->getSources($projectDir, $staticUrl)
  1865.                             );
  1867.                             $objTemplate->$strHrefKey = $objTemplate->lightboxPicture['img']['src'];
  1868.                         }
  1869.                         catch (\Exception $e)
  1870.                         {
  1871.                             $objTemplate->$strHrefKey = static::addFilesUrlTo($imageUrl);
  1872.                             $objTemplate->lightboxPicture = array('img'=>array('src'=>$objTemplate->$strHrefKey, 'srcset'=>$objTemplate->$strHrefKey), 'sources'=>array());
  1873.                         }
  1874.                     }
  1876.                     $objTemplate->attributes = ' data-lightbox="' . $strLightboxId . '"';
  1877.                 }
  1878.                 else
  1879.                 {
  1880.                     $objTemplate->attributes = ' target="_blank"';
  1882.                     if ($blnIsExternal)
  1883.                     {
  1884.                         $objTemplate->attributes .= ' rel="noreferrer noopener"';
  1885.                     }
  1886.                 }
  1887.             }
  1888.         }
  1890.         // Fullsize view
  1891.         elseif (TL_MODE == 'FE' && $arrItem['fullsize'])
  1892.         {
  1893.             try
  1894.             {
  1895.                 $projectDir = $container->getParameter('kernel.project_dir');
  1896.                 $staticUrl = $container->get('contao.assets.files_context')->getStaticUrl();
  1897.                 $picture = $container->get('contao.image.picture_factory')->create($projectDir . '/' . $arrItem['singleSRC'], $lightboxSize);
  1899.                 $objTemplate->lightboxPicture = array
  1900.                 (
  1901.                     'img' => $picture->getImg($projectDir, $staticUrl),
  1902.                     'sources' => $picture->getSources($projectDir, $staticUrl)
  1903.                 );
  1905.                 $objTemplate->$strHrefKey = $objTemplate->lightboxPicture['img']['src'];
  1906.             }
  1907.             catch (\Exception $e)
  1908.             {
  1909.                 $objTemplate->$strHrefKey = static::addFilesUrlTo(System::urlEncode($arrItem['singleSRC']));
  1910.                 $objTemplate->lightboxPicture = array('img'=>array('src'=>$objTemplate->$strHrefKey, 'srcset'=>$objTemplate->$strHrefKey), 'sources'=>array());
  1911.             }
  1913.             $objTemplate->attributes = ' data-lightbox="' . $strLightboxId . '"';
  1914.         }
  1916.         // Add the meta data to the template
  1917.         foreach (array_keys($arrMeta) as $k)
  1918.         {
  1919.             $objTemplate->$k = $arrItem[$k];
  1920.         }
  1922.         // Do not urlEncode() here because getImage() already does (see #3817)
  1923.         $objTemplate->src = static::addFilesUrlTo($src);
  1924.         $objTemplate->singleSRC = $arrItem['singleSRC'];
  1925.         $objTemplate->linkTitle = StringUtil::specialchars($arrItem['linkTitle'] ?: $arrItem['title']);
  1926.         $objTemplate->fullsize = $arrItem['fullsize'] ? true : false;
  1927.         $objTemplate->addBefore = ($arrItem['floating'] != 'below');
  1928.         $objTemplate->margin = static::generateMargin($arrMargin);
  1929.         $objTemplate->addImage = true;
  1930.     }
  1932.     /**
  1933.      * Add enclosures to a template
  1934.      *
  1935.      * @param object $objTemplate The template object to add the enclosures to
  1936.      * @param array  $arrItem     The element or module as array
  1937.      * @param string $strKey      The name of the enclosures field in $arrItem
  1938.      */
  1939.     public static function addEnclosuresToTemplate($objTemplate, $arrItem, $strKey='enclosure')
  1940.     {
  1941.         $arrEnclosures = StringUtil::deserialize($arrItem[$strKey]);
  1943.         if (empty($arrEnclosures) || !\is_array($arrEnclosures))
  1944.         {
  1945.             return;
  1946.         }
  1948.         $objFiles = FilesModel::findMultipleByUuids($arrEnclosures);
  1950.         if ($objFiles === null)
  1951.         {
  1952.             return;
  1953.         }
  1955.         $file = Input::get('file', true);
  1957.         // Send the file to the browser and do not send a 404 header (see #5178)
  1958.         if ($file)
  1959.         {
  1960.             while ($objFiles->next())
  1961.             {
  1962.                 if ($file == $objFiles->path)
  1963.                 {
  1964.                     static::sendFileToBrowser($file);
  1965.                 }
  1966.             }
  1968.             $objFiles->reset();
  1969.         }
  1971.         /** @var PageModel $objPage */
  1972.         global $objPage;
  1974.         $arrEnclosures = array();
  1975.         $allowedDownload = StringUtil::trimsplit(',', strtolower(Config::get('allowedDownload')));
  1977.         // Add download links
  1978.         while ($objFiles->next())
  1979.         {
  1980.             if ($objFiles->type == 'file')
  1981.             {
  1982.                 $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  1984.                 if (!\in_array($objFiles->extension, $allowedDownload) || !is_file($projectDir . '/' . $objFiles->path))
  1985.                 {
  1986.                     continue;
  1987.                 }
  1989.                 $objFile = new File($objFiles->path);
  1990.                 $strHref = Environment::get('request');
  1992.                 // Remove an existing file parameter (see #5683)
  1993.                 if (preg_match('/(&(amp;)?|\?)file=/', $strHref))
  1994.                 {
  1995.                     $strHref = preg_replace('/(&(amp;)?|\?)file=[^&]+/', '', $strHref);
  1996.                 }
  1998.                 $strHref .= ((strpos($strHref, '?') !== false) ? '&amp;' : '?') . 'file=' . System::urlEncode($objFiles->path);
  2000.                 $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->language);
  2002.                 if (empty($arrMeta) && $objPage->rootFallbackLanguage !== null)
  2003.                 {
  2004.                     $arrMeta = Frontend::getMetaData($objFiles->meta, $objPage->rootFallbackLanguage);
  2005.                 }
  2007.                 // Use the file name as title if none is given
  2008.                 if (!$arrMeta['title'])
  2009.                 {
  2010.                     $arrMeta['title'] = StringUtil::specialchars($objFile->basename);
  2011.                 }
  2013.                 $arrEnclosures[] = array
  2014.                 (
  2015.                     'id'        => $objFiles->id,
  2016.                     'uuid'      => $objFiles->uuid,
  2017.                     'name'      => $objFile->basename,
  2018.                     'title'     => StringUtil::specialchars(sprintf($GLOBALS['TL_LANG']['MSC']['download'], $objFile->basename)),
  2019.                     'link'      => $arrMeta['title'],
  2020.                     'caption'   => $arrMeta['caption'],
  2021.                     'href'      => $strHref,
  2022.                     'filesize'  => static::getReadableSize($objFile->filesize),
  2023.                     'icon'      => Image::getPath($objFile->icon),
  2024.                     'mime'      => $objFile->mime,
  2025.                     'meta'      => $arrMeta,
  2026.                     'extension' => $objFile->extension,
  2027.                     'path'      => $objFile->dirname,
  2028.                     'enclosure' => $objFiles->path // backwards compatibility
  2029.                 );
  2030.             }
  2031.         }
  2033.         // Order the enclosures
  2034.         if (!empty($arrItem['orderEnclosure']))
  2035.         {
  2036.             $tmp = StringUtil::deserialize($arrItem['orderEnclosure']);
  2038.             if (!empty($tmp) && \is_array($tmp))
  2039.             {
  2040.                 // Remove all values
  2041.                 $arrOrder = array_map(static function () {}, array_flip($tmp));
  2043.                 // Move the matching elements to their position in $arrOrder
  2044.                 foreach ($arrEnclosures as $k=>$v)
  2045.                 {
  2046.                     if (\array_key_exists($v['uuid'], $arrOrder))
  2047.                     {
  2048.                         $arrOrder[$v['uuid']] = $v;
  2049.                         unset($arrEnclosures[$k]);
  2050.                     }
  2051.                 }
  2053.                 // Append the left-over enclosures at the end
  2054.                 if (!empty($arrEnclosures))
  2055.                 {
  2056.                     $arrOrder = array_merge($arrOrder, array_values($arrEnclosures));
  2057.                 }
  2059.                 // Remove empty (unreplaced) entries
  2060.                 $arrEnclosures = array_values(array_filter($arrOrder));
  2061.                 unset($arrOrder);
  2062.             }
  2063.         }
  2065.         $objTemplate->enclosure = $arrEnclosures;
  2066.     }
  2068.     /**
  2069.      * Set the static URL constants
  2070.      */
  2071.     public static function setStaticUrls()
  2072.     {
  2073.         if (\defined('TL_FILES_URL'))
  2074.         {
  2075.             return;
  2076.         }
  2078.         if (\func_num_args() > 0)
  2079.         {
  2080.             @trigger_error('Using Controller::setStaticUrls() has been deprecated and will no longer work in Contao 5.0. Use the asset contexts instead.', E_USER_DEPRECATED);
  2082.             if (!isset($GLOBALS['objPage']))
  2083.             {
  2084.                 $GLOBALS['objPage'] = func_get_arg(0);
  2085.             }
  2086.         }
  2088.         \define('TL_ASSETS_URL', System::getContainer()->get('contao.assets.assets_context')->getStaticUrl());
  2089.         \define('TL_FILES_URL', System::getContainer()->get('contao.assets.files_context')->getStaticUrl());
  2091.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  2092.         \define('TL_SCRIPT_URL', TL_ASSETS_URL);
  2093.         \define('TL_PLUGINS_URL', TL_ASSETS_URL);
  2094.     }
  2096.     /**
  2097.      * Add a static URL to a script
  2098.      *
  2099.      * @param string             $script  The script path
  2100.      * @param ContaoContext|null $context
  2101.      *
  2102.      * @return string The script path with the static URL
  2103.      */
  2104.     public static function addStaticUrlTo($script, ContaoContext $context = null)
  2105.     {
  2106.         // Absolute URLs
  2107.         if (preg_match('@^https?://@', $script))
  2108.         {
  2109.             return $script;
  2110.         }
  2112.         if ($context === null)
  2113.         {
  2114.             $context = System::getContainer()->get('contao.assets.assets_context');
  2115.         }
  2117.         if ($strStaticUrl = $context->getStaticUrl())
  2118.         {
  2119.             return $strStaticUrl . $script;
  2120.         }
  2122.         return $script;
  2123.     }
  2125.     /**
  2126.      * Add the assets URL to a script
  2127.      *
  2128.      * @param string $script The script path
  2129.      *
  2130.      * @return string The script path with the assets URL
  2131.      */
  2132.     public static function addAssetsUrlTo($script)
  2133.     {
  2134.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.assets_context'));
  2135.     }
  2137.     /**
  2138.      * Add the files URL to a script
  2139.      *
  2140.      * @param string $script The script path
  2141.      *
  2142.      * @return string The script path with the files URL
  2143.      */
  2144.     public static function addFilesUrlTo($script)
  2145.     {
  2146.         return static::addStaticUrlTo($script, System::getContainer()->get('contao.assets.files_context'));
  2147.     }
  2149.     /**
  2150.      * Return the current theme as string
  2151.      *
  2152.      * @return string The name of the theme
  2153.      *
  2154.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2155.      *             Use Backend::getTheme() instead.
  2156.      */
  2157.     public static function getTheme()
  2158.     {
  2159.         @trigger_error('Using Controller::getTheme() has been deprecated and will no longer work in Contao 5.0. Use Backend::getTheme() instead.', E_USER_DEPRECATED);
  2161.         return Backend::getTheme();
  2162.     }
  2164.     /**
  2165.      * Return the back end themes as array
  2166.      *
  2167.      * @return array An array of available back end themes
  2168.      *
  2169.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2170.      *             Use Backend::getThemes() instead.
  2171.      */
  2172.     public static function getBackendThemes()
  2173.     {
  2174.         @trigger_error('Using Controller::getBackendThemes() has been deprecated and will no longer work in Contao 5.0. Use Backend::getThemes() instead.', E_USER_DEPRECATED);
  2176.         return Backend::getThemes();
  2177.     }
  2179.     /**
  2180.      * Get the details of a page including inherited parameters
  2181.      *
  2182.      * @param mixed $intId A page ID or a Model object
  2183.      *
  2184.      * @return PageModel The page model or null
  2185.      *
  2186.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2187.      *             Use PageModel::findWithDetails() or PageModel->loadDetails() instead.
  2188.      */
  2189.     public static function getPageDetails($intId)
  2190.     {
  2191.         @trigger_error('Using Controller::getPageDetails() has been deprecated and will no longer work in Contao 5.0. Use PageModel::findWithDetails() or PageModel->loadDetails() instead.', E_USER_DEPRECATED);
  2193.         if ($intId instanceof PageModel)
  2194.         {
  2195.             return $intId->loadDetails();
  2196.         }
  2198.         if ($intId instanceof Collection)
  2199.         {
  2200.             /** @var PageModel $objPage */
  2201.             $objPage = $intId->current();
  2203.             return $objPage->loadDetails();
  2204.         }
  2206.         if (\is_object($intId))
  2207.         {
  2208.             $strKey = __METHOD__ . '-' . $intId->id;
  2210.             // Try to load from cache
  2211.             if (Cache::has($strKey))
  2212.             {
  2213.                 return Cache::get($strKey);
  2214.             }
  2216.             // Create a model from the database result
  2217.             $objPage = new PageModel();
  2218.             $objPage->setRow($intId->row());
  2219.             $objPage->loadDetails();
  2221.             Cache::set($strKey, $objPage);
  2223.             return $objPage;
  2224.         }
  2226.         // Invalid ID
  2227.         if ($intId < 1 || !\strlen($intId))
  2228.         {
  2229.             return null;
  2230.         }
  2232.         $strKey = __METHOD__ . '-' . $intId;
  2234.         // Try to load from cache
  2235.         if (Cache::has($strKey))
  2236.         {
  2237.             return Cache::get($strKey);
  2238.         }
  2240.         $objPage = PageModel::findWithDetails($intId);
  2242.         Cache::set($strKey, $objPage);
  2244.         return $objPage;
  2245.     }
  2247.     /**
  2248.      * Remove old XML files from the share directory
  2249.      *
  2250.      * @param boolean $blnReturn If true, only return the finds and don't delete
  2251.      *
  2252.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2253.      *             Use Automator::purgeXmlFiles() instead.
  2254.      */
  2255.     protected function removeOldFeeds($blnReturn=false)
  2256.     {
  2257.         @trigger_error('Using Controller::removeOldFeeds() has been deprecated and will no longer work in Contao 5.0. Use Automator::purgeXmlFiles() instead.', E_USER_DEPRECATED);
  2259.         $this->import(Automator::class, 'Automator');
  2260.         $this->Automator->purgeXmlFiles($blnReturn);
  2261.     }
  2263.     /**
  2264.      * Return true if a class exists (tries to autoload the class)
  2265.      *
  2266.      * @param string $strClass The class name
  2267.      *
  2268.      * @return boolean True if the class exists
  2269.      *
  2270.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2271.      *             Use the PHP function class_exists() instead.
  2272.      */
  2273.     protected function classFileExists($strClass)
  2274.     {
  2275.         @trigger_error('Using Controller::classFileExists() has been deprecated and will no longer work in Contao 5.0. Use the PHP function class_exists() instead.', E_USER_DEPRECATED);
  2277.         return class_exists($strClass);
  2278.     }
  2280.     /**
  2281.      * Restore basic entities
  2282.      *
  2283.      * @param string $strBuffer The string with the tags to be replaced
  2284.      *
  2285.      * @return string The string with the original entities
  2286.      *
  2287.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2288.      *             Use StringUtil::restoreBasicEntities() instead.
  2289.      */
  2290.     public static function restoreBasicEntities($strBuffer)
  2291.     {
  2292.         @trigger_error('Using Controller::restoreBasicEntities() has been deprecated and will no longer work in Contao 5.0. Use StringUtil::restoreBasicEntities() instead.', E_USER_DEPRECATED);
  2294.         return StringUtil::restoreBasicEntities($strBuffer);
  2295.     }
  2297.     /**
  2298.      * Resize an image and crop it if necessary
  2299.      *
  2300.      * @param string  $image  The image path
  2301.      * @param integer $width  The target width
  2302.      * @param integer $height The target height
  2303.      * @param string  $mode   An optional resize mode
  2304.      *
  2305.      * @return boolean True if the image has been resized correctly
  2306.      *
  2307.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2308.      *             Use Image::resize() instead.
  2309.      */
  2310.     protected function resizeImage($image, $width, $height, $mode='')
  2311.     {
  2312.         @trigger_error('Using Controller::resizeImage() has been deprecated and will no longer work in Contao 5.0. Use Image::resize() instead.', E_USER_DEPRECATED);
  2314.         return Image::resize($image, $width, $height, $mode);
  2315.     }
  2317.     /**
  2318.      * Resize an image and crop it if necessary
  2319.      *
  2320.      * @param string  $image  The image path
  2321.      * @param integer $width  The target width
  2322.      * @param integer $height The target height
  2323.      * @param string  $mode   An optional resize mode
  2324.      * @param string  $target An optional target to be replaced
  2325.      * @param boolean $force  Override existing target images
  2326.      *
  2327.      * @return string|null The image path or null
  2328.      *
  2329.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2330.      *             Use Image::get() instead.
  2331.      */
  2332.     protected function getImage($image, $width, $height, $mode='', $target=null, $force=false)
  2333.     {
  2334.         @trigger_error('Using Controller::getImage() has been deprecated and will no longer work in Contao 5.0. Use Image::get() instead.', E_USER_DEPRECATED);
  2336.         return Image::get($image, $width, $height, $mode, $target, $force);
  2337.     }
  2339.     /**
  2340.      * Generate an image tag and return it as string
  2341.      *
  2342.      * @param string $src        The image path
  2343.      * @param string $alt        An optional alt attribute
  2344.      * @param string $attributes A string of other attributes
  2345.      *
  2346.      * @return string The image HTML tag
  2347.      *
  2348.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2349.      *             Use Image::getHtml() instead.
  2350.      */
  2351.     public static function generateImage($src, $alt='', $attributes='')
  2352.     {
  2353.         @trigger_error('Using Controller::generateImage() has been deprecated and will no longer work in Contao 5.0. Use Image::getHtml() instead.', E_USER_DEPRECATED);
  2355.         return Image::getHtml($src, $alt, $attributes);
  2356.     }
  2358.     /**
  2359.      * Return the date picker string (see #3218)
  2360.      *
  2361.      * @return boolean
  2362.      *
  2363.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2364.      *             Specify "datepicker"=>true in your DCA file instead.
  2365.      */
  2366.     protected function getDatePickerString()
  2367.     {
  2368.         @trigger_error('Using Controller::getDatePickerString() has been deprecated and will no longer work in Contao 5.0. Specify "datepicker"=>true in your DCA file instead.', E_USER_DEPRECATED);
  2370.         return true;
  2371.     }
  2373.     /**
  2374.      * Return the installed back end languages as array
  2375.      *
  2376.      * @return array An array of available back end languages
  2377.      *
  2378.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2379.      *             Use System::getLanguages(true) instead.
  2380.      */
  2381.     protected function getBackendLanguages()
  2382.     {
  2383.         @trigger_error('Using Controller::getBackendLanguages() has been deprecated and will no longer work in Contao 5.0. Use System::getLanguages(true) instead.', E_USER_DEPRECATED);
  2385.         return $this->getLanguages(true);
  2386.     }
  2388.     /**
  2389.      * Parse simple tokens that can be used to personalize newsletters
  2390.      *
  2391.      * @param string $strBuffer The text with the tokens to be replaced
  2392.      * @param array  $arrData   The replacement data as array
  2393.      *
  2394.      * @return string The text with the replaced tokens
  2395.      *
  2396.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2397.      *             Use StringUtil::parseSimpleTokens() instead.
  2398.      */
  2399.     protected function parseSimpleTokens($strBuffer, $arrData)
  2400.     {
  2401.         @trigger_error('Using Controller::parseSimpleTokens() has been deprecated and will no longer work in Contao 5.0. Use StringUtil::parseSimpleTokens() instead.', E_USER_DEPRECATED);
  2403.         return StringUtil::parseSimpleTokens($strBuffer, $arrData);
  2404.     }
  2406.     /**
  2407.      * Convert a DCA file configuration to be used with widgets
  2408.      *
  2409.      * @param array  $arrData  The field configuration array
  2410.      * @param string $strName  The field name in the form
  2411.      * @param mixed  $varValue The field value
  2412.      * @param string $strField The field name in the database
  2413.      * @param string $strTable The table name
  2414.      *
  2415.      * @return array An array that can be passed to a widget
  2416.      *
  2417.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2418.      *             Use Widget::getAttributesFromDca() instead.
  2419.      */
  2420.     protected function prepareForWidget($arrData, $strName, $varValue=null, $strField='', $strTable='')
  2421.     {
  2422.         @trigger_error('Using Controller::prepareForWidget() has been deprecated and will no longer work in Contao 5.0. Use Widget::getAttributesFromDca() instead.', E_USER_DEPRECATED);
  2424.         return Widget::getAttributesFromDca($arrData, $strName, $varValue, $strField, $strTable);
  2425.     }
  2427.     /**
  2428.      * Return the IDs of all child records of a particular record (see #2475)
  2429.      *
  2430.      * @author Andreas Schempp
  2431.      *
  2432.      * @param mixed   $arrParentIds An array of parent IDs
  2433.      * @param string  $strTable     The table name
  2434.      * @param boolean $blnSorting   True if the table has a sorting field
  2435.      * @param array   $arrReturn    The array to be returned
  2436.      * @param string  $strWhere     Additional WHERE condition
  2437.      *
  2438.      * @return array An array of child record IDs
  2439.      *
  2440.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2441.      *             Use Database::getChildRecords() instead.
  2442.      */
  2443.     protected function getChildRecords($arrParentIds, $strTable, $blnSorting=false, $arrReturn=array(), $strWhere='')
  2444.     {
  2445.         @trigger_error('Using Controller::getChildRecords() has been deprecated and will no longer work in Contao 5.0. Use Database::getChildRecords() instead.', E_USER_DEPRECATED);
  2447.         return $this->Database->getChildRecords($arrParentIds, $strTable, $blnSorting, $arrReturn, $strWhere);
  2448.     }
  2450.     /**
  2451.      * Return the IDs of all parent records of a particular record
  2452.      *
  2453.      * @param integer $intId    The ID of the record
  2454.      * @param string  $strTable The table name
  2455.      *
  2456.      * @return array An array of parent record IDs
  2457.      *
  2458.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2459.      *             Use Database::getParentRecords() instead.
  2460.      */
  2461.     protected function getParentRecords($intId, $strTable)
  2462.     {
  2463.         @trigger_error('Using Controller::getParentRecords() has been deprecated and will no longer work in Contao 5.0. Use Database::getParentRecords() instead.', E_USER_DEPRECATED);
  2465.         return $this->Database->getParentRecords($intId, $strTable);
  2466.     }
  2468.     /**
  2469.      * Print an article as PDF and stream it to the browser
  2470.      *
  2471.      * @param ModuleModel $objArticle An article object
  2472.      *
  2473.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2474.      *             Use ModuleArticle->generatePdf() instead.
  2475.      */
  2476.     protected function printArticleAsPdf($objArticle)
  2477.     {
  2478.         @trigger_error('Using Controller::printArticleAsPdf() has been deprecated and will no longer work in Contao 5.0. Use ModuleArticle->generatePdf() instead.', E_USER_DEPRECATED);
  2480.         $objArticle = new ModuleArticle($objArticle);
  2481.         $objArticle->generatePdf();
  2482.     }
  2484.     /**
  2485.      * Return all page sections as array
  2486.      *
  2487.      * @return array An array of active page sections
  2488.      *
  2489.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2490.      *             See https://github.com/contao/core/issues/4693.
  2491.      */
  2492.     public static function getPageSections()
  2493.     {
  2494.         @trigger_error('Using Controller::getPageSections() has been deprecated and will no longer work in Contao 5.0.', E_USER_DEPRECATED);
  2496.         return array('header', 'left', 'right', 'main', 'footer');
  2497.     }
  2499.     /**
  2500.      * Return a "selected" attribute if the option is selected
  2501.      *
  2502.      * @param string $strOption The option to check
  2503.      * @param mixed  $varValues One or more values to check against
  2504.      *
  2505.      * @return string The attribute or an empty string
  2506.      *
  2507.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2508.      *             Use Widget::optionSelected() instead.
  2509.      */
  2510.     public static function optionSelected($strOption, $varValues)
  2511.     {
  2512.         @trigger_error('Using Controller::optionSelected() has been deprecated and will no longer work in Contao 5.0. Use Widget::optionSelected() instead.', E_USER_DEPRECATED);
  2514.         return Widget::optionSelected($strOption, $varValues);
  2515.     }
  2517.     /**
  2518.      * Return a "checked" attribute if the option is checked
  2519.      *
  2520.      * @param string $strOption The option to check
  2521.      * @param mixed  $varValues One or more values to check against
  2522.      *
  2523.      * @return string The attribute or an empty string
  2524.      *
  2525.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2526.      *             Use Widget::optionChecked() instead.
  2527.      */
  2528.     public static function optionChecked($strOption, $varValues)
  2529.     {
  2530.         @trigger_error('Using Controller::optionChecked() has been deprecated and will no longer work in Contao 5.0. Use Widget::optionChecked() instead.', E_USER_DEPRECATED);
  2532.         return Widget::optionChecked($strOption, $varValues);
  2533.     }
  2535.     /**
  2536.      * Find a content element in the TL_CTE array and return the class name
  2537.      *
  2538.      * @param string $strName The content element name
  2539.      *
  2540.      * @return string The class name
  2541.      *
  2542.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2543.      *             Use ContentElement::findClass() instead.
  2544.      */
  2545.     public static function findContentElement($strName)
  2546.     {
  2547.         @trigger_error('Using Controller::findContentElement() has been deprecated and will no longer work in Contao 5.0. Use ContentElement::findClass() instead.', E_USER_DEPRECATED);
  2549.         return ContentElement::findClass($strName);
  2550.     }
  2552.     /**
  2553.      * Find a front end module in the FE_MOD array and return the class name
  2554.      *
  2555.      * @param string $strName The front end module name
  2556.      *
  2557.      * @return string The class name
  2558.      *
  2559.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2560.      *             Use Module::findClass() instead.
  2561.      */
  2562.     public static function findFrontendModule($strName)
  2563.     {
  2564.         @trigger_error('Using Controller::findFrontendModule() has been deprecated and will no longer work in Contao 5.0. Use Module::findClass() instead.', E_USER_DEPRECATED);
  2566.         return Module::findClass($strName);
  2567.     }
  2569.     /**
  2570.      * Create an initial version of a record
  2571.      *
  2572.      * @param string  $strTable The table name
  2573.      * @param integer $intId    The ID of the element to be versioned
  2574.      *
  2575.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2576.      *             Use Versions->initialize() instead.
  2577.      */
  2578.     protected function createInitialVersion($strTable, $intId)
  2579.     {
  2580.         @trigger_error('Using Controller::createInitialVersion() has been deprecated and will no longer work in Contao 5.0. Use Versions->initialize() instead.', E_USER_DEPRECATED);
  2582.         $objVersions = new Versions($strTable, $intId);
  2583.         $objVersions->initialize();
  2584.     }
  2586.     /**
  2587.      * Create a new version of a record
  2588.      *
  2589.      * @param string  $strTable The table name
  2590.      * @param integer $intId    The ID of the element to be versioned
  2591.      *
  2592.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  2593.      *             Use Versions->create() instead.
  2594.      */
  2595.     protected function createNewVersion($strTable, $intId)
  2596.     {
  2597.         @trigger_error('Using Controller::createNewVersion() has been deprecated and will no longer work in Contao 5.0. Use Versions->create() instead.', E_USER_DEPRECATED);
  2599.         $objVersions = new Versions($strTable, $intId);
  2600.         $objVersions->create();
  2601.     }
  2603.     /**
  2604.      * Return the files matching a GLOB pattern
  2605.      *
  2606.      * @param string $pattern
  2607.      *
  2608.      * @return array|false
  2609.      */
  2610.     protected static function braceGlob($pattern)
  2611.     {
  2612.         // Use glob() if possible
  2613.         if (false === strpos($pattern, '/**/') && (\defined('GLOB_BRACE') || false === strpos($pattern, '{')))
  2614.         {
  2615.             return glob($pattern, \defined('GLOB_BRACE') ? GLOB_BRACE : 0);
  2616.         }
  2618.         $finder = new Finder();
  2619.         $regex = Glob::toRegex($pattern);
  2621.         // All files in the given template folder
  2622.         $filesIterator = $finder
  2623.             ->files()
  2624.             ->followLinks()
  2625.             ->sortByName()
  2626.             ->in(\dirname($pattern))
  2627.         ;
  2629.         // Match the actual regex and filter the files
  2630.         $filesIterator = $filesIterator->filter(static function (\SplFileInfo $info) use ($regex)
  2631.         {
  2632.             $path = $info->getPathname();
  2634.             return preg_match($regex, $path) && $info->isFile();
  2635.         });
  2637.         $files = iterator_to_array($filesIterator);
  2639.         return array_keys($files);
  2640.     }
  2641. }
  2643. class_alias(Controller::class, 'Controller');