vendor/contao/core-bundle/src/Resources/contao/classes/Frontend.php line 301

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\Exception\LegacyRoutingException;
  14. use Contao\CoreBundle\Exception\NoRootPageFoundException;
  15. use Contao\CoreBundle\Search\Document;
  16. use Contao\CoreBundle\Util\LocaleUtil;
  17. use Symfony\Cmf\Component\Routing\RouteObjectInterface;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\Routing\Exception\ExceptionInterface as RoutingExceptionInterface;
  21. use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;
  23. /**
  24.  * Provide methods to manage front end controllers.
  25.  *
  26.  * @author Leo Feyer <https://github.com/leofeyer>
  27.  */
  28. abstract class Frontend extends Controller
  29. {
  30.     /**
  31.      * Meta array
  32.      * @var array
  33.      */
  34.     protected $arrMeta = array();
  36.     /**
  37.      * Aux array
  38.      * @var array
  39.      */
  40.     protected $arrAux = array();
  42.     /**
  43.      * Processed files array
  44.      * @var array
  45.      */
  46.     protected $arrProcessed = array();
  48.     /**
  49.      * Load the database object
  50.      *
  51.      * Make the constructor public, so pages can be instantiated (see #6182)
  52.      */
  53.     public function __construct()
  54.     {
  55.         parent::__construct();
  56.         $this->import(Database::class, 'Database');
  57.     }
  59.     /**
  60.      * Split the current request into fragments, strip the URL suffix, recreate the $_GET array and return the page ID
  61.      *
  62.      * @return mixed
  63.      *
  64.      * @deprecated Deprecated since Contao 4.7, to be removed in Contao 5.0.
  65.      *             Use the Symfony routing instead.
  66.      */
  67.     public static function getPageIdFromUrl()
  68.     {
  69.         trigger_deprecation('contao/core-bundle', '4.7', 'Using "Contao\Frontend::getPageIdFromUrl()" has been deprecated and will no longer work in Contao 5.0. Use the Symfony routing instead.');
  71.         if (!System::getContainer()->getParameter('contao.legacy_routing'))
  72.         {
  73.             throw new LegacyRoutingException('Frontend::getPageIdFromUrl() requires legacy routing. Configure "prepend_locale" or "url_suffix" in your app configuration (e.g. config.yml).');
  74.         }
  76.         $strRequest = Environment::get('relativeRequest');
  78.         if (!$strRequest)
  79.         {
  80.             return null;
  81.         }
  83.         // Get the request without the query string
  84.         list($strRequest) = explode('?', $strRequest, 2);
  86.         // URL decode here (see #6232)
  87.         $strRequest = rawurldecode($strRequest);
  89.         // The request string must not contain "auto_item" (see #4012)
  90.         if (strpos($strRequest, '/auto_item/') !== false)
  91.         {
  92.             return false;
  93.         }
  95.         // Extract the language
  96.         if (Config::get('addLanguageToUrl'))
  97.         {
  98.             $arrMatches = array();
  100.             // Use the matches instead of substr() (thanks to Mario Müller)
  101.             if (preg_match('@^([a-z]{2}(-[A-Z]{2})?)/(.*)$@', $strRequest, $arrMatches))
  102.             {
  103.                 Input::setGet('language', $arrMatches[1]);
  105.                 // Trigger the root page if only the language was given
  106.                 if (!$arrMatches[3])
  107.                 {
  108.                     return null;
  109.                 }
  111.                 $strRequest = $arrMatches[3];
  112.             }
  113.             else
  114.             {
  115.                 return false; // Language not provided
  116.             }
  117.         }
  119.         // Remove the URL suffix if not just a language root (e.g. en/) is requested
  120.         if ($strRequest && (!Config::get('addLanguageToUrl') || !preg_match('@^[a-z]{2}(-[A-Z]{2})?/$@', $strRequest)))
  121.         {
  122.             $intSuffixLength = \strlen(Config::get('urlSuffix'));
  124.             // Return false if the URL suffix does not match (see #2864)
  125.             if ($intSuffixLength > 0)
  126.             {
  127.                 if (substr($strRequest, -$intSuffixLength) != Config::get('urlSuffix'))
  128.                 {
  129.                     return false;
  130.                 }
  132.                 $strRequest = substr($strRequest, 0, -$intSuffixLength);
  133.             }
  134.         }
  136.         $arrFragments = null;
  138.         // Use folder-style URLs
  139.         if (strpos($strRequest, '/') !== false)
  140.         {
  141.             $strAlias = $strRequest;
  142.             $arrOptions = array($strAlias);
  144.             // Compile all possible aliases by applying dirname() to the request (e.g. news/archive/item, news/archive, news)
  145.             while ($strAlias != '/' && strpos($strAlias, '/') !== false)
  146.             {
  147.                 $strAlias = \dirname($strAlias);
  148.                 $arrOptions[] = $strAlias;
  149.             }
  151.             /** @var PageModel $objPageModel */
  152.             $objPageModel = System::getContainer()->get('contao.framework')->getAdapter(PageModel::class);
  154.             // Check if there are pages with a matching alias
  155.             $objPages = $objPageModel->findByAliases($arrOptions);
  157.             if ($objPages !== null)
  158.             {
  159.                 $arrPages = array();
  161.                 // Order by domain and language
  162.                 while ($objPages->next())
  163.                 {
  164.                     /** @var PageModel $objModel */
  165.                     $objModel = $objPages->current();
  166.                     $objPage  = $objModel->loadDetails();
  168.                     $domain = $objPage->domain ?: '*';
  169.                     $arrPages[$domain][$objPage->rootLanguage][] = $objPage;
  171.                     // Also store the fallback language
  172.                     if ($objPage->rootIsFallback)
  173.                     {
  174.                         $arrPages[$domain]['*'][] = $objPage;
  175.                     }
  176.                 }
  178.                 $arrAliases = array();
  179.                 $strHost = Environment::get('host');
  181.                 // Look for a root page whose domain name matches the host name
  182.                 $arrLangs = $arrPages[$strHost] ?? $arrPages['*'] ?? array();
  184.                 // Use the first result (see #4872)
  185.                 if (!Config::get('addLanguageToUrl'))
  186.                 {
  187.                     $arrAliases = current($arrLangs);
  188.                 }
  189.                 // Try to find a page matching the language parameter
  190.                 elseif (($lang = Input::get('language')) && isset($arrLangs[$lang]))
  191.                 {
  192.                     $arrAliases = $arrLangs[$lang];
  193.                 }
  195.                 // Return if there are no matches
  196.                 if (empty($arrAliases))
  197.                 {
  198.                     return false;
  199.                 }
  201.                 $objPage = $arrAliases[0];
  203.                 // The request consists of the alias only
  204.                 if ($strRequest == $objPage->alias)
  205.                 {
  206.                     $arrFragments = array($strRequest);
  207.                 }
  208.                 // Remove the alias from the request string, explode it and then re-insert the alias at the beginning
  209.                 else
  210.                 {
  211.                     $arrFragments = explode('/', substr($strRequest, \strlen($objPage->alias) + 1));
  212.                     array_unshift($arrFragments, $objPage->alias);
  213.                 }
  214.             }
  215.         }
  217.         // If folderUrl is deactivated or did not find a matching page
  218.         if ($arrFragments === null)
  219.         {
  220.             if ($strRequest == '/')
  221.             {
  222.                 return false;
  223.             }
  225.             $arrFragments = explode('/', $strRequest);
  226.         }
  228.         // Add the second fragment as auto_item if the number of fragments is even
  229.         if (\count($arrFragments) % 2 == 0)
  230.         {
  231.             if (!Config::get('useAutoItem'))
  232.             {
  233.                 return false; // see #264
  234.             }
  236.             ArrayUtil::arrayInsert($arrFragments, 1, array('auto_item'));
  237.         }
  239.         // HOOK: add custom logic
  240.         if (isset($GLOBALS['TL_HOOKS']['getPageIdFromUrl']) && \is_array($GLOBALS['TL_HOOKS']['getPageIdFromUrl']))
  241.         {
  242.             foreach ($GLOBALS['TL_HOOKS']['getPageIdFromUrl'] as $callback)
  243.             {
  244.                 $arrFragments = static::importStatic($callback[0])->{$callback[1]}($arrFragments);
  245.             }
  246.         }
  248.         // Return if the alias is empty (see #4702 and #4972)
  249.         if (!$arrFragments[0] && \count($arrFragments) > 1)
  250.         {
  251.             return false;
  252.         }
  254.         // Add the fragments to the $_GET array
  255.         for ($i=1, $c=\count($arrFragments); $i<$c; $i+=2)
  256.         {
  257.             // Return false if the key is empty (see #4702 and #263)
  258.             if (!$arrFragments[$i])
  259.             {
  260.                 return false;
  261.             }
  263.             // Return false if there is a duplicate parameter (duplicate content) (see #4277)
  264.             if (isset($_GET[$arrFragments[$i]]))
  265.             {
  266.                 return false;
  267.             }
  269.             // Return false if the request contains an auto_item keyword (duplicate content) (see #4012)
  270.             if (Config::get('useAutoItem') && \in_array($arrFragments[$i], $GLOBALS['TL_AUTO_ITEM']))
  271.             {
  272.                 return false;
  273.             }
  275.             Input::setGet($arrFragments[$i], $arrFragments[$i+1], true);
  276.         }
  278.         return $arrFragments[0] ?: null;
  279.     }
  281.     /**
  282.      * Return the root page ID
  283.      *
  284.      * @return integer
  285.      *
  286.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  287.      *             Use Frontend::getRootPageFromUrl()->id instead.
  288.      */
  289.     public static function getRootIdFromUrl()
  290.     {
  291.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Frontend::getRootIdFromUrl()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Frontend::getRootPageFromUrl()->id" instead.');
  293.         return static::getRootPageFromUrl()->id;
  294.     }
  296.     /**
  297.      * Try to find a root page based on language and URL
  298.      *
  299.      * @return PageModel
  300.      */
  301.     public static function getRootPageFromUrl()
  302.     {
  303.         if (!System::getContainer()->getParameter('contao.legacy_routing'))
  304.         {
  305.             $objRequest = System::getContainer()->get('request_stack')->getCurrentRequest();
  307.             if ($objRequest instanceof Request)
  308.             {
  309.                 $objPage = $objRequest->attributes->get('pageModel');
  311.                 if ($objPage instanceof PageModel)
  312.                 {
  313.                     $objPage->loadDetails();
  315.                     return PageModel::findByPk($objPage->rootId);
  316.                 }
  317.             }
  319.             throw new NoRootPageFoundException('No root page found');
  320.         }
  322.         $accept_language = Environment::get('httpAcceptLanguage');
  323.         $blnAddLanguageToUrl = System::getContainer()->getParameter('contao.prepend_locale');
  325.         // Get the language from the URL if it is not set (see #456)
  326.         if (!isset($_GET['language']) && $blnAddLanguageToUrl)
  327.         {
  328.             $arrMatches = array();
  330.             // Get the request without the query string
  331.             list($strRequest) = explode('?', Environment::get('relativeRequest'), 2);
  333.             if (preg_match('@^([a-z]{2}(-[A-Z]{2})?)/@', $strRequest, $arrMatches))
  334.             {
  335.                 Input::setGet('language', $arrMatches[1]);
  336.             }
  337.         }
  339.         // The language is set in the URL
  340.         if (!empty($_GET['language']) && $blnAddLanguageToUrl)
  341.         {
  342.             $strUri = Environment::get('url') . '/' . Input::get('language') . '/';
  343.         }
  345.         // No language given
  346.         else
  347.         {
  348.             $strUri = Environment::get('url') . '/';
  349.         }
  351.         $objRequest = Request::create($strUri);
  352.         $objRequest->headers->set('Accept-Language', $accept_language);
  354.         try
  355.         {
  356.             $arrParameters = System::getContainer()->get('contao.routing.nested_matcher')->matchRequest($objRequest);
  357.         }
  358.         catch (RoutingExceptionInterface $exception)
  359.         {
  360.             try
  361.             {
  362.                 $arrParameters = System::getContainer()->get('contao.routing.nested_404_matcher')->matchRequest($objRequest);
  363.             }
  364.             catch (RoutingExceptionInterface $exception)
  365.             {
  366.                 throw new NoRootPageFoundException('No root page found', 0, $exception);
  367.             }
  368.         }
  370.         $objRootPage = $arrParameters['pageModel'] ?? null;
  372.         if (!$objRootPage instanceof PageModel)
  373.         {
  374.             throw new MissingMandatoryParametersException('Every Contao route must have a "pageModel" parameter');
  375.         }
  377.         // Redirect to the website root or language root (e.g. en/)
  378.         if (!Environment::get('relativeRequest'))
  379.         {
  380.             if ($blnAddLanguageToUrl)
  381.             {
  382.                 $arrParams = array('_locale' => LocaleUtil::formatAsLocale($objRootPage->language));
  384.                 $strUrl = System::getContainer()->get('router')->generate('contao_index', $arrParams);
  385.                 $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  387.                 static::redirect($strUrl);
  388.             }
  390.             // Redirect if the page alias is not "index" or "/" (see #8498, #8560 and #1210)
  391.             elseif ($objRootPage->type !== 'root' && !\in_array($objRootPage->alias, array('index', '/')))
  392.             {
  393.                 static::redirect($objRootPage->getAbsoluteUrl());
  394.             }
  395.         }
  397.         if ($objRootPage->type != 'root')
  398.         {
  399.             return PageModel::findByPk($objRootPage->rootId);
  400.         }
  402.         return $objRootPage;
  403.     }
  405.     /**
  406.      * Overwrite the parent method as front end URLs are handled differently
  407.      *
  408.      * @param string  $strRequest
  409.      * @param boolean $blnIgnoreParams
  410.      * @param array   $arrUnset
  411.      *
  412.      * @return string
  413.      */
  414.     public static function addToUrl($strRequest, $blnIgnoreParams=false, $arrUnset=array())
  415.     {
  416.         /** @var PageModel $objPage */
  417.         global $objPage;
  419.         $arrGet = $blnIgnoreParams ? array() : $_GET;
  421.         // Clean the $_GET values (thanks to thyon)
  422.         foreach (array_keys($arrGet) as $key)
  423.         {
  424.             $arrGet[$key] = Input::get($key, true, true);
  425.         }
  427.         $arrFragments = preg_split('/&(amp;)?/i', $strRequest);
  429.         // Merge the new request string
  430.         foreach ($arrFragments as $strFragment)
  431.         {
  432.             list($key, $value) = explode('=', $strFragment);
  434.             if (!$value)
  435.             {
  436.                 unset($arrGet[$key]);
  437.             }
  438.             else
  439.             {
  440.                 $arrGet[$key] = $value;
  441.             }
  442.         }
  444.         // Unset the language parameter
  445.         if ($objPage->urlPrefix)
  446.         {
  447.             unset($arrGet['language']);
  448.         }
  450.         $strParams    = '';
  451.         $strConnector = '/';
  452.         $strSeparator = '/';
  454.         // Compile the parameters string
  455.         foreach ($arrGet as $k=>$v)
  456.         {
  457.             // Omit the key if it is an auto_item key (see #5037)
  458.             if ($objPage->useAutoItem && ($k == 'auto_item' || \in_array($k, $GLOBALS['TL_AUTO_ITEM'])))
  459.             {
  460.                 $strParams = $strConnector . urlencode($v) . $strParams;
  461.             }
  462.             else
  463.             {
  464.                 $strParams .= $strConnector . urlencode($k) . $strSeparator . urlencode($v);
  465.             }
  466.         }
  468.         $strUrl = System::getContainer()->get('router')->generate(RouteObjectInterface::OBJECT_BASED_ROUTE_NAME, array(RouteObjectInterface::CONTENT_OBJECT => $objPage, 'parameters' => $strParams));
  469.         $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  471.         return $strUrl;
  472.     }
  474.     /**
  475.      * Redirect to a jumpTo page or reload the current page
  476.      *
  477.      * @param integer|array $intId
  478.      * @param string        $strParams
  479.      * @param string        $strForceLang
  480.      */
  481.     protected function jumpToOrReload($intId, $strParams=null, $strForceLang=null)
  482.     {
  483.         if ($strForceLang !== null)
  484.         {
  485.             trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Frontend::jumpToOrReload()" with $strForceLang has been deprecated and will no longer work in Contao 5.0.');
  486.         }
  488.         /** @var PageModel $objPage */
  489.         global $objPage;
  491.         // Always redirect if there are additional arguments (see #5734)
  492.         $blnForceRedirect = ($strParams !== null || $strForceLang !== null);
  494.         if (\is_array($intId))
  495.         {
  496.             $intId = $intId['id'] ?? 0;
  497.         }
  499.         if ($intId > 0 && ($intId != $objPage->id || $blnForceRedirect) && ($objNextPage = PageModel::findPublishedById($intId)) !== null)
  500.         {
  501.             $this->redirect($objNextPage->getFrontendUrl($strParams, $strForceLang));
  502.         }
  504.         $this->reload();
  505.     }
  507.     /**
  508.      * Check whether a back end or front end user is logged in
  509.      *
  510.      * @param string $strCookie
  511.      *
  512.      * @return boolean
  513.      *
  514.      * @deprecated Deprecated since Contao 4.5, to be removed in Contao 5.0.
  515.      *             Use Symfony security instead.
  516.      */
  517.     protected function getLoginStatus($strCookie)
  518.     {
  519.         trigger_deprecation('contao/core-bundle', '4.5', 'Using "Contao\Frontend::getLoginStatus()" has been deprecated and will no longer work in Contao 5.0. Use Symfony security instead.');
  521.         $objTokenChecker = System::getContainer()->get('contao.security.token_checker');
  523.         if ($strCookie == 'BE_USER_AUTH' && $objTokenChecker->hasBackendUser())
  524.         {
  525.             // Always return false if we are not in preview mode (show hidden elements)
  526.             if (TL_MODE == 'FE' && !$objTokenChecker->isPreviewMode())
  527.             {
  528.                 return false;
  529.             }
  531.             return true;
  532.         }
  534.         if ($strCookie == 'FE_USER_AUTH' && $objTokenChecker->hasFrontendUser())
  535.         {
  536.             return true;
  537.         }
  539.         return false;
  540.     }
  542.     /**
  543.      * Get the metadata from a serialized string
  544.      *
  545.      * @param string $strData
  546.      * @param string $strLanguage
  547.      *
  548.      * @return array
  549.      */
  550.     public static function getMetaData($strData, $strLanguage)
  551.     {
  552.         if (empty($strLanguage))
  553.         {
  554.             return array();
  555.         }
  557.         $arrData = StringUtil::deserialize($strData);
  559.         // Convert the language to a locale (see #5678)
  560.         $strLanguage = LocaleUtil::formatAsLocale($strLanguage);
  562.         if (!\is_array($arrData) || !isset($arrData[$strLanguage]))
  563.         {
  564.             return array();
  565.         }
  567.         return $arrData[$strLanguage];
  568.     }
  570.     /**
  571.      * Prepare a text to be used in the meta description tag
  572.      *
  573.      * @param string $strText
  574.      *
  575.      * @return string
  576.      *
  577.      * @deprecated Deprecated since Contao 4.12, to be removed in Contao 5.0.
  578.      *             Use StringUtil::htmlToPlainText() instead.
  579.      */
  580.     protected function prepareMetaDescription($strText)
  581.     {
  582.         trigger_deprecation('contao/core-bundle', '4.12', 'Using "Contao\Frontend::prepareMetaDescription()" has been deprecated and will no longer work Contao 5.0. Use Contao\StringUtil::htmlToPlainText() instead.');
  584.         $strText = $this->replaceInsertTags($strText, false);
  585.         $strText = strip_tags($strText);
  586.         $strText = str_replace("\n", ' ', $strText);
  587.         $strText = StringUtil::substr($strText, 320);
  589.         return trim($strText);
  590.     }
  592.     /**
  593.      * Return the cron timeout in seconds
  594.      *
  595.      * @return integer
  596.      */
  597.     public static function getCronTimeout()
  598.     {
  599.         if (!empty($GLOBALS['TL_CRON']['minutely']))
  600.         {
  601.             return 60;
  602.         }
  604.         if (!empty($GLOBALS['TL_CRON']['hourly']))
  605.         {
  606.             return 3600;
  607.         }
  609.         return 86400; // daily
  610.     }
  612.     /**
  613.      * Index a page if applicable
  614.      *
  615.      * @param Response $response
  616.      *
  617.      * @deprecated Deprecated since Contao 4.9, to be removed in Contao 5.0.
  618.      *             Use the "contao.search.indexer" service instead.
  619.      */
  620.     public static function indexPageIfApplicable(Response $response)
  621.     {
  622.         trigger_deprecation('contao/core-bundle', '4.9', 'Using "Contao\Frontend::indexPageIfApplicable()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.search.indexer" service instead.');
  624.         $searchIndexer = System::getContainer()->get('contao.search.indexer');
  626.         // The search indexer is disabled
  627.         if ($searchIndexer === null)
  628.         {
  629.             return;
  630.         }
  632.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  634.         if ($request === null)
  635.         {
  636.             throw new \RuntimeException('The request stack did not contain a request');
  637.         }
  639.         $document = Document::createFromRequestResponse($request, $response);
  641.         $searchIndexer->index($document);
  642.     }
  644.     /**
  645.      * Check whether there is a cached version of the page and return a response object
  646.      *
  647.      * @return Response|null
  648.      *
  649.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  650.      *             Use proper response caching headers instead.
  651.      */
  652.     public static function getResponseFromCache()
  653.     {
  654.         trigger_deprecation('contao/core-bundle', '4.3', 'Using "Contao\Frontend::getResponseFromCache()" has been deprecated and will no longer work in Contao 5.0. Use proper response caching headers instead.');
  656.         return null;
  657.     }
  658. }
  660. class_alias(Frontend::class, 'Frontend');