vendor/contao/core-bundle/src/Framework/ContaoFramework.php line 286

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of Contao.
  7.  *
  8.  * (c) Leo Feyer
  9.  *
  10.  * @license LGPL-3.0-or-later
  11.  */
  13. namespace Contao\CoreBundle\Framework;
  15. use Contao\ClassLoader;
  16. use Contao\Config;
  17. use Contao\Controller;
  18. use Contao\CoreBundle\Exception\LegacyRoutingException;
  19. use Contao\CoreBundle\Exception\RedirectResponseException;
  20. use Contao\CoreBundle\Routing\ScopeMatcher;
  21. use Contao\CoreBundle\Security\Authentication\Token\TokenChecker;
  22. use Contao\CoreBundle\Session\LazySessionAccess;
  23. use Contao\CoreBundle\Util\LocaleUtil;
  24. use Contao\Environment;
  25. use Contao\Input;
  26. use Contao\InsertTags;
  27. use Contao\Model\Registry;
  28. use Contao\PageModel;
  29. use Contao\RequestToken;
  30. use Contao\System;
  31. use Contao\TemplateLoader;
  32. use Symfony\Component\DependencyInjection\ContainerAwareInterface;
  33. use Symfony\Component\DependencyInjection\ContainerAwareTrait;
  34. use Symfony\Component\Filesystem\Filesystem;
  35. use Symfony\Component\Filesystem\Path;
  36. use Symfony\Component\HttpFoundation\Request;
  37. use Symfony\Component\HttpFoundation\RequestStack;
  38. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  39. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  40. use Symfony\Contracts\Service\ResetInterface;
  42. /**
  43.  * @internal Do not use this class in your code; use the "contao.framework" service instead
  44.  */
  45. class ContaoFramework implements ContaoFrameworkInterface, ContainerAwareInterface, ResetInterface
  46. {
  47.     use ContainerAwareTrait;
  49.     private static bool $initialized = false;
  50.     private static string $nonce = '';
  52.     private RequestStack $requestStack;
  53.     private ScopeMatcher $scopeMatcher;
  54.     private TokenChecker $tokenChecker;
  55.     private Filesystem $filesystem;
  56.     private UrlGeneratorInterface $urlGenerator;
  57.     private string $projectDir;
  58.     private int $errorLevel;
  59.     private bool $legacyRouting;
  60.     private ?Request $request = null;
  61.     private bool $isFrontend = false;
  62.     private array $adapterCache = [];
  63.     private array $hookListeners = [];
  65.     public function __construct(RequestStack $requestStack, ScopeMatcher $scopeMatcher, TokenChecker $tokenChecker, Filesystem $filesystem, UrlGeneratorInterface $urlGenerator, string $projectDir, int $errorLevel, bool $legacyRouting)
  66.     {
  67.         $this->requestStack = $requestStack;
  68.         $this->scopeMatcher = $scopeMatcher;
  69.         $this->tokenChecker = $tokenChecker;
  70.         $this->filesystem = $filesystem;
  71.         $this->urlGenerator = $urlGenerator;
  72.         $this->projectDir = $projectDir;
  73.         $this->errorLevel = $errorLevel;
  74.         $this->legacyRouting = $legacyRouting;
  75.     }
  77.     public function reset(): void
  78.     {
  79.         $this->adapterCache = [];
  80.         $this->isFrontend = false;
  81.         self::$nonce = '';
  83.         if (!$this->isInitialized()) {
  84.             return;
  85.         }
  87.         Controller::resetControllerCache();
  88.         Environment::reset();
  89.         Input::resetCache();
  90.         Input::resetUnusedGet();
  91.         InsertTags::reset();
  92.         PageModel::reset();
  93.         Registry::getInstance()->reset();
  94.     }
  96.     public function isInitialized(): bool
  97.     {
  98.         return self::$initialized;
  99.     }
  101.     /**
  102.      * @throws \LogicException
  103.      */
  104.     public function initialize(bool $isFrontend = false): void
  105.     {
  106.         if ($this->isInitialized()) {
  107.             return;
  108.         }
  110.         // Set before calling any methods to prevent recursion
  111.         self::$initialized = true;
  113.         if (null === $this->container) {
  114.             throw new \LogicException('The service container has not been set.');
  115.         }
  117.         $this->isFrontend = $isFrontend;
  118.         $this->request = $this->requestStack->getMainRequest();
  120.         $this->setConstants();
  121.         $this->initializeFramework();
  123.         if (!$this->legacyRouting) {
  124.             $this->throwOnLegacyRoutingHooks();
  125.         }
  126.     }
  128.     public function setHookListeners(array $hookListeners): void
  129.     {
  130.         $this->hookListeners = $hookListeners;
  131.     }
  133.     /**
  134.      * @template T of object
  135.      *
  136.      * @param class-string<T> $class
  137.      *
  138.      * @return T
  139.      */
  140.     public function createInstance($class, $args = [])
  141.     {
  142.         if (\in_array('getInstance', get_class_methods($class), true)) {
  143.             return \call_user_func_array([$class, 'getInstance'], $args);
  144.         }
  146.         $reflection = new \ReflectionClass($class);
  148.         return $reflection->newInstanceArgs($args);
  149.     }
  151.     /**
  152.      * @template T
  153.      *
  154.      * @param class-string<T> $class
  155.      *
  156.      * @return Adapter<T>&T
  157.      *
  158.      * @phpstan-return Adapter<T>
  159.      */
  160.     public function getAdapter($class): Adapter
  161.     {
  162.         return $this->adapterCache[$class] ??= new Adapter($class);
  163.     }
  165.     public static function getNonce(): string
  166.     {
  167.         if ('' === self::$nonce) {
  168.             self::$nonce = bin2hex(random_bytes(16));
  169.         }
  171.         return self::$nonce;
  172.     }
  174.     /**
  175.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0
  176.      */
  177.     private function setConstants(): void
  178.     {
  179.         if (!\defined('TL_MODE')) {
  180.             \define('TL_MODE', $this->getMode());
  181.         }
  183.         \define('TL_START', microtime(true));
  184.         \define('TL_ROOT', $this->projectDir);
  185.         \define('TL_REFERER_ID', $this->getRefererId());
  187.         if (!\defined('TL_SCRIPT')) {
  188.             \define('TL_SCRIPT', $this->getRoute());
  189.         }
  191.         // Define the login status constants (see #4099, #5279)
  192.         if ('FE' === $this->getMode() && ($session = $this->getSession()) && $this->request->hasPreviousSession()) {
  193.             $session->start();
  195.             \define('BE_USER_LOGGED_IN', $this->tokenChecker->isPreviewMode());
  196.             \define('FE_USER_LOGGED_IN', $this->tokenChecker->hasFrontendUser());
  197.         } else {
  198.             \define('BE_USER_LOGGED_IN', false);
  199.             \define('FE_USER_LOGGED_IN', false);
  200.         }
  202.         // Define the relative path to the installation (see #5339)
  203.         \define('TL_PATH', $this->getPath());
  204.     }
  206.     private function getMode(): ?string
  207.     {
  208.         if (true === $this->isFrontend) {
  209.             return 'FE';
  210.         }
  212.         if (null === $this->request) {
  213.             return null;
  214.         }
  216.         if ($this->scopeMatcher->isBackendRequest($this->request)) {
  217.             return 'BE';
  218.         }
  220.         if ($this->scopeMatcher->isFrontendRequest($this->request)) {
  221.             return 'FE';
  222.         }
  224.         return null;
  225.     }
  227.     private function getRefererId(): ?string
  228.     {
  229.         if (null === $this->request) {
  230.             return null;
  231.         }
  233.         return $this->request->attributes->get('_contao_referer_id', '');
  234.     }
  236.     private function getRoute(): ?string
  237.     {
  238.         if (null === $this->request) {
  239.             return null;
  240.         }
  242.         return substr($this->request->getBaseUrl().$this->request->getPathInfo(), \strlen($this->request->getBasePath().'/'));
  243.     }
  245.     private function getPath(): ?string
  246.     {
  247.         if (null === $this->request) {
  248.             return null;
  249.         }
  251.         return $this->request->getBasePath();
  252.     }
  254.     private function initializeFramework(): void
  255.     {
  256.         // Set the error_reporting level
  257.         error_reporting($this->errorLevel);
  259.         $this->includeHelpers();
  260.         $this->includeBasicClasses();
  262.         // Set the container
  263.         System::setContainer($this->container);
  265.         $config = $this->getAdapter(Config::class);
  267.         // Preload the configuration (see #5872)
  268.         $config->preload();
  270.         // Register the class loader
  271.         ClassLoader::scanAndRegister();
  273.         $this->initializeLegacySessionAccess();
  274.         $this->setDefaultLanguage();
  276.         // Fully load the configuration
  277.         $config->getInstance();
  279.         $this->registerHookListeners();
  280.         $this->validateInstallation();
  282.         Input::initialize();
  283.         TemplateLoader::initialize();
  285.         $this->setTimezone();
  286.         $this->triggerInitializeSystemHook();
  287.         $this->handleRequestToken();
  288.     }
  290.     private function includeHelpers(): void
  291.     {
  292.         require __DIR__.'/../Resources/contao/helper/functions.php';
  293.         require __DIR__.'/../Resources/contao/config/constants.php';
  294.     }
  296.     /**
  297.      * Includes the basic classes required for further processing.
  298.      */
  299.     private function includeBasicClasses(): void
  300.     {
  301.         static $basicClasses = [
  302.             'System',
  303.             'Config',
  304.             'ClassLoader',
  305.             'TemplateLoader',
  306.             'ModuleLoader',
  307.         ];
  309.         foreach ($basicClasses as $class) {
  310.             if (!class_exists($class, false)) {
  311.                 require_once __DIR__.'/../Resources/contao/library/Contao/'.$class.'.php';
  312.             }
  313.         }
  314.     }
  316.     /**
  317.      * Initializes session access for $_SESSION['FE_DATA'] and $_SESSION['BE_DATA'].
  318.      */
  319.     private function initializeLegacySessionAccess(): void
  320.     {
  321.         if (!$session = $this->getSession()) {
  322.             return;
  323.         }
  325.         if (!$session->isStarted()) {
  326.             $_SESSION = new LazySessionAccess($session, $this->request && $this->request->hasPreviousSession());
  327.         } else {
  328.             $_SESSION['BE_DATA'] = $session->getBag('contao_backend');
  329.             $_SESSION['FE_DATA'] = $session->getBag('contao_frontend');
  330.         }
  331.     }
  333.     private function setDefaultLanguage(): void
  334.     {
  335.         $language = 'en';
  337.         if (null !== $this->request) {
  338.             $language = LocaleUtil::formatAsLanguageTag($this->request->getLocale());
  339.         }
  341.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  342.         $GLOBALS['TL_LANGUAGE'] = $language;
  343.     }
  345.     /**
  346.      * Redirects to the install tool if the installation is incomplete.
  347.      */
  348.     private function validateInstallation(): void
  349.     {
  350.         if (null === $this->request) {
  351.             return;
  352.         }
  354.         static $installRoutes = [
  355.             'contao_install',
  356.             'contao_install_redirect',
  357.         ];
  359.         if (\in_array($this->request->attributes->get('_route'), $installRoutes, true)) {
  360.             return;
  361.         }
  363.         if (!$this->getAdapter(Config::class)->isComplete()) {
  364.             throw new RedirectResponseException($this->urlGenerator->generate('contao_install', [], UrlGeneratorInterface::ABSOLUTE_URL));
  365.         }
  366.     }
  368.     private function setTimezone(): void
  369.     {
  370.         $config = $this->getAdapter(Config::class);
  372.         $this->iniSet('date.timezone', (string) $config->get('timeZone'));
  373.         date_default_timezone_set((string) $config->get('timeZone'));
  374.     }
  376.     private function triggerInitializeSystemHook(): void
  377.     {
  378.         if (
  379.             !empty($GLOBALS['TL_HOOKS']['initializeSystem'])
  380.             && \is_array($GLOBALS['TL_HOOKS']['initializeSystem'])
  381.             && is_dir(Path::join($this->projectDir, 'system/tmp'))
  382.         ) {
  383.             foreach ($GLOBALS['TL_HOOKS']['initializeSystem'] as $callback) {
  384.                 System::importStatic($callback[0])->{$callback[1]}();
  385.             }
  386.         }
  388.         if ($this->filesystem->exists($filePath = Path::join($this->projectDir, 'system/config/initconfig.php'))) {
  389.             trigger_deprecation('contao/core-bundle', '4.0', 'Using the "initconfig.php" file has been deprecated and will no longer work in Contao 5.0.');
  390.             include $filePath;
  391.         }
  392.     }
  394.     private function handleRequestToken(): void
  395.     {
  396.         $requestToken = $this->getAdapter(RequestToken::class);
  398.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  399.         if (!\defined('REQUEST_TOKEN')) {
  400.             \define('REQUEST_TOKEN', 'cli' === \PHP_SAPI ? null : $requestToken->get());
  401.         }
  402.     }
  404.     private function iniSet(string $key, string $value): void
  405.     {
  406.         if (\function_exists('ini_set')) {
  407.             ini_set($key, $value);
  408.         }
  409.     }
  411.     private function getSession(): ?SessionInterface
  412.     {
  413.         if (null === $this->request || !$this->request->hasSession()) {
  414.             return null;
  415.         }
  417.         return $this->request->getSession();
  418.     }
  420.     private function registerHookListeners(): void
  421.     {
  422.         foreach ($this->hookListeners as $hookName => $priorities) {
  423.             if (isset($GLOBALS['TL_HOOKS'][$hookName]) && \is_array($GLOBALS['TL_HOOKS'][$hookName])) {
  424.                 if (isset($priorities[0])) {
  425.                     $priorities[0] = array_merge($GLOBALS['TL_HOOKS'][$hookName], $priorities[0]);
  426.                 } else {
  427.                     $priorities[0] = $GLOBALS['TL_HOOKS'][$hookName];
  428.                     krsort($priorities);
  429.                 }
  430.             }
  432.             $GLOBALS['TL_HOOKS'][$hookName] = array_merge(...$priorities);
  433.         }
  434.     }
  436.     private function throwOnLegacyRoutingHooks(): void
  437.     {
  438.         if (empty($GLOBALS['TL_HOOKS']['getPageIdFromUrl']) && empty($GLOBALS['TL_HOOKS']['getRootPageFromUrl'])) {
  439.             return;
  440.         }
  442.         throw new LegacyRoutingException('Legacy routing is required to support the "getPageIdFromUrl" and "getRootPageFromUrl" hooks. Check the Symfony inspector for more information.');
  443.     }
  444. }