SysTemplateTreeBuilder.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\TypoScript\IncludeTree;
 
use ‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DefaultRestrictionContainer;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\HiddenRestriction;
use TYPO3\CMS\Core\Package\PackageManager;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\Entity\SiteInterface;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\DefaultTypoScriptInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\DefaultTypoScriptMagicKeyInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\ExtensionStaticInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\FileInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\IncludeInterface;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\IncludeStaticFileDatabaseInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\IncludeStaticFileFileInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\RootInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\SiteInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\SysTemplateInclude;
use ‪TYPO3\CMS\Core\TypoScript\Tokenizer\TokenizerInterface;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
final class ‪SysTemplateTreeBuilder
{
    private array ‪$includedSysTemplateUids = [];
 
    private string ‪$type;
 
    private ‪TokenizerInterface ‪$tokenizer;
    private ?‪PhpFrontend ‪$cache = null;
 
    public function ‪__construct(
        private readonly ‪ConnectionPool $connectionPool,
        private readonly PackageManager $packageManager,
        private readonly ‪Context $context,
        private readonly ‪TreeFromLineStreamBuilder $treeFromTokenStreamBuilder,
    ) {
    }
 
    public function ‪getTreeBySysTemplateRowsAndSite(
        string ‪$type,
        array $sysTemplateRows,
        ‪TokenizerInterface ‪$tokenizer,
        ?‪SiteInterface $site = null,
        ‪PhpFrontend ‪$cache = null
    ): ‪RootInclude {
        if (!in_array(‪$type, ['constants', 'setup'], true)) {
            throw new \RuntimeException('type must be either constants or setup', 1653737656);
        }
        $this->tokenizer = ‪$tokenizer;
        $this->cache = ‪$cache;
        $this->type = ‪$type;
        $this->includedSysTemplateUids = [];
 
        $rootNode = new ‪RootInclude();
        if (empty($sysTemplateRows)) {
            return $rootNode;
        }
 
        // Convenience code: Usually, at least one sys_template records needs to have 'clear' set. This resets
        // the AST and triggers inclusion of "globals" TypoScript. When integrators missed to set the clear flags,
        // important globals TypoScript is not loaded, leading to pretty hard to find issues in Frontend
        // rendering. Since the details of the 'clear' flags are rather complex anyway, this code scans the given
        // sys_template records if the flag is set somewhere and if not, actively sets it dynamically for the
        // first templates. As a result, integrators do not need to think about the 'clear' flags at all for
        // simple instances, it 'just works'.
        $atLeastOneSysTemplateRowHasClearFlag = false;
        foreach ($sysTemplateRows as $sysTemplateRow) {
            if (($this->type === 'constants' && $sysTemplateRow['clear'] & 1) || ($this->type === 'setup' && $sysTemplateRow['clear'] & 2)) {
                $atLeastOneSysTemplateRowHasClearFlag = true;
            }
        }
        if (!$atLeastOneSysTemplateRowHasClearFlag) {
            $firstRow = reset($sysTemplateRows);
            $firstRow['clear'] = $this->type === 'constants' ? 1 : 2;
            $sysTemplateRows[array_key_first($sysTemplateRows)] = $firstRow;
        }
 
        foreach ($sysTemplateRows as $sysTemplateRow) {
            $cacheIdentifier = 'sys-template-' . $this->type . '-' . $this->‪getSysTemplateRowIdentifier($sysTemplateRow, $site);
            if ($this->cache) {
                // Get from cache if possible
                $includeNode = $this->cache->require($cacheIdentifier);
                if ($includeNode) {
                    $rootNode->addChild($includeNode);
                    continue;
                }
            }
            $includeNode = new ‪SysTemplateInclude();
            $name = '[sys_template:' . $sysTemplateRow['uid'] . '] ' . $sysTemplateRow['title'];
            $includeNode->setName($name);
            $includeNode->setPid((int)$sysTemplateRow['pid']);
            if ($this->type === 'constants') {
                $includeNode->setLineStream($this->tokenizer->tokenize($sysTemplateRow['constants'] ?? ''));
            } else {
                $includeNode->setLineStream($this->tokenizer->tokenize($sysTemplateRow['config'] ?? ''));
            }
            if ($sysTemplateRow['root']) {
                $includeNode->setRoot(true);
            }
            $clear = $sysTemplateRow['clear'];
            if (($this->type === 'constants' && $clear & 1) || ($this->type === 'setup' && $clear & 2)) {
                $includeNode->setClear(true);
            }
            $this->‪handleSysTemplateRecordInclude($includeNode, $sysTemplateRow, $site);
            $this->treeFromTokenStreamBuilder->buildTree($includeNode, $this->type, $this->tokenizer);
            $this->cache?->set($cacheIdentifier, $this->‪prepareNodeForCache($includeNode));
            $rootNode->addChild($includeNode);
        }
 
        return $rootNode;
    }
 
    private function ‪handleSysTemplateRecordInclude(‪IncludeInterface $parentNode, array $row, ?‪SiteInterface $site): void
    {
        $this->includedSysTemplateUids[] = (int)$row['uid'];
 
        $isRoot = (bool)$row['root'];
        $clearConstants = (int)$row['clear'] & 1;
        $clearSetup = (int)$row['clear'] & 2;
        $staticFileMode = (int)($row['static_file_mode']);
        $includeStaticAfterBasedOn = (bool)$row['includeStaticAfterBasedOn'];
 
        if ($this->type === 'constants' && $clearConstants) {
            $this->‪addDefaultTypoScriptFromGlobals($parentNode);
            $this->‪addDefaultTypoScriptConstantsFromSite($parentNode, $site);
        }
        if ($this->type === 'setup' && $clearSetup) {
            $this->‪addDefaultTypoScriptFromGlobals($parentNode);
        }
        if ($staticFileMode === 3 && $isRoot) {
            $this->‪addExtensionStatics($parentNode);
        }
        if (!$includeStaticAfterBasedOn) {
            $this->‪handleIncludeStaticFileArray($parentNode, (string)$row['include_static_file']);
        }
        if (!empty($row['basedOn'])) {
            $this->‪handleIncludeBasedOnTemplates($parentNode, (string)$row['basedOn'], $site);
        }
        if ($includeStaticAfterBasedOn) {
            $this->‪handleIncludeStaticFileArray($parentNode, (string)$row['include_static_file']);
        }
        if ($staticFileMode === 1 || ($staticFileMode === 0 && $isRoot)) {
            $this->‪addExtensionStatics($parentNode);
        }
    }
 
    private function ‪handleIncludeStaticFileArray(‪IncludeInterface $parentNode, string $includeStaticFileString): void
    {
        $includeStaticFileIncludeArray = GeneralUtility::trimExplode(',', $includeStaticFileString, true);
        foreach ($includeStaticFileIncludeArray as $includeStaticFile) {
            $cacheIdentifier = preg_replace('/[^[:alnum:]]/u', '-', mb_strtolower($includeStaticFile)) . '-' . ‪$this->type;
            if ($this->cache) {
                $node = $this->cache->require($cacheIdentifier);
                if ($node) {
                    $parentNode->‪addChild($node);
                    continue;
                }
            }
            $node = new ‪IncludeStaticFileDatabaseInclude();
            $node->setName($includeStaticFile);
            $this->‪handleSingleIncludeStaticFile($node, $includeStaticFile);
            $this->cache?->set($cacheIdentifier, $this->‪prepareNodeForCache($node));
            $parentNode->‪addChild($node);
        }
    }
 
    private function ‪handleIncludeBasedOnTemplates(‪IncludeInterface $parentNode, string $basedOnList, ?‪SiteInterface $site): void
    {
        $basedOnTemplateUids = GeneralUtility::intExplode(',', $basedOnList, true);
        // Filter uids that have been handled already.
        $basedOnTemplateUids = array_diff($basedOnTemplateUids, $this->includedSysTemplateUids);
        if (empty($basedOnTemplateUids)) {
            return;
        }
 
        $basedOnTemplateRows = $this->‪getBasedOnSysTemplateRowsFromDatabase($basedOnTemplateUids);
 
        foreach ($basedOnTemplateUids as $basedOnTemplateUid) {
            if (is_array($basedOnTemplateRows[$basedOnTemplateUid] ?? false)) {
                $sysTemplateRow = $basedOnTemplateRows[$basedOnTemplateUid];
                $this->includedSysTemplateUids[] = (int)$sysTemplateRow['uid'];
                $includeNode = new ‪SysTemplateInclude();
                $name = '[sys_template:' . $sysTemplateRow['uid'] . '] ' . $sysTemplateRow['title'];
                $includeNode->setName($name);
                $includeNode->setPid((int)$sysTemplateRow['pid']);
                if ($this->type === 'constants') {
                    $includeNode->setLineStream($this->tokenizer->tokenize($sysTemplateRow['constants'] ?? ''));
                } else {
                    $includeNode->setLineStream($this->tokenizer->tokenize($sysTemplateRow['config'] ?? ''));
                }
                $this->treeFromTokenStreamBuilder->buildTree($includeNode, $this->type, $this->tokenizer);
                if ($sysTemplateRow['root']) {
                    $includeNode->setRoot(true);
                }
                $clear = $sysTemplateRow['clear'];
                if (($this->type === 'constants' && $clear & 1)
                    || ($this->type === 'setup' && $clear & 2)
                ) {
                    $includeNode->setClear(true);
                }
                $parentNode->‪addChild($includeNode);
                $this->‪handleSysTemplateRecordInclude($includeNode, $sysTemplateRow, $site);
            }
        }
    }
 
    private function ‪handleSingleIncludeStaticFile(‪IncludeInterface $parentNode, $includeStaticFileString): void
    {
        if (!‪PathUtility::isExtensionPath($includeStaticFileString)) {
            // Must start with 'EXT:'
            throw new \RuntimeException(
                'Single include_static_file does not start with "EXT:": ' . $includeStaticFileString,
                1651137904
            );
        }
 
        // Cut off 'EXT:'
        $includeStaticFileWithoutExt = substr($includeStaticFileString, 4);
        $includeStaticFileExtKeyAndPath = GeneralUtility::trimExplode('/', $includeStaticFileWithoutExt, true, 2);
        if (empty($includeStaticFileExtKeyAndPath[0]) || empty($includeStaticFileExtKeyAndPath[1])) {
            throw new \RuntimeException(
                'Syntax of static includes is "EXT:extension_key/Path". Usually enforced as such by ExtensionManagementUtility::addStaticFile',
                1651138603
            );
        }
        $extensionKey = $includeStaticFileExtKeyAndPath[0];
        if (!‪ExtensionManagementUtility::isLoaded($extensionKey)) {
            return;
        }
        // example: '/.../my_extension/Configuration/TypoScript/MyStaticInclude/'
        $pathSegmentWithAppendedSlash = rtrim($includeStaticFileExtKeyAndPath[1]) . '/';
        $path = ‪ExtensionManagementUtility::extPath($extensionKey, $pathSegmentWithAppendedSlash);
 
        // '/.../my_extension/Configuration/TypoScript/MyStaticInclude/include_static_file.txt'
        $includeStaticFileFileIncludePath = $path . 'include_static_file.txt';
        if (file_exists($path . 'include_static_file.txt')) {
            $includeStaticFileFileInclude = new ‪IncludeStaticFileFileInclude();
            $name = 'EXT:' . $extensionKey . '/' . $pathSegmentWithAppendedSlash . 'include_static_file.txt';
            $includeStaticFileFileInclude->setName($name);
            $includeStaticFileFileInclude->setPath($includeStaticFileString);
            $parentNode->‪addChild($includeStaticFileFileInclude);
            $includeStaticFileFileIncludeContent = (string)file_get_contents($includeStaticFileFileIncludePath);
            // @todo: There is no array_unique() for DB based include_static_file content?!
            $includeStaticFileFileIncludeArray = array_unique(GeneralUtility::trimExplode(',', $includeStaticFileFileIncludeContent));
            foreach ($includeStaticFileFileIncludeArray as $includeStaticFileFileIncludeString) {
                $this->‪handleSingleIncludeStaticFile($includeStaticFileFileInclude, $includeStaticFileFileIncludeString);
            }
        }
 
        $extensions = ['.typoscript', '.ts', '.txt'];
        foreach ($extensions as $extension) {
            // '/.../my_extension/Configuration/TypoScript/MyStaticInclude/[constants|setup]' plus one of the allowed extensions like '.typoscript'
            $fileName = $path . $this->type . $extension;
            if (file_exists($fileName)) {
                $fileContent = file_get_contents($fileName);
                $fileNode = new ‪FileInclude();
                $name = 'EXT:' . $extensionKey . '/' . $pathSegmentWithAppendedSlash . $this->type . $extension;
                $fileNode->setName($name);
                $fileNode->setPath($name);
                $fileNode->setLineStream($this->tokenizer->tokenize($fileContent));
                $this->treeFromTokenStreamBuilder->buildTree($fileNode, $this->type, $this->tokenizer);
                $parentNode->‪addChild($fileNode);
            }
        }
 
        $extensionKeyWithoutUnderscores = str_replace('_', '', $extensionKey);
        $this->‪addStaticMagicFromGlobals($parentNode, $extensionKeyWithoutUnderscores . '/' . $pathSegmentWithAppendedSlash);
    }
 
    private function ‪addExtensionStatics(‪IncludeInterface $parentNode): void
    {
        foreach ($this->packageManager->getActivePackages() as $package) {
            $extensionKey = $package->getPackageKey();
            $extensionKeyWithoutUnderscores = str_replace('_', '', $extensionKey);
            $file = $package->getPackagePath() . 'ext_typoscript_' . $this->type . '.typoscript';
            if (file_exists($file)) {
                ‪$identifier = preg_replace('/[^[:alnum:]]/u', '-', 'ext-' . $extensionKey . '-ext-typoscript-' . $this->type . '-typoscript');
                if ($this->cache) {
                    $node = $this->cache->require(‪$identifier);
                    if ($node) {
                        $parentNode->‪addChild($node);
                        continue;
                    }
                }
                $fileContent = file_get_contents($file);
                $this->‪addStaticMagicFromGlobals($parentNode, $extensionKeyWithoutUnderscores);
                $node = new ‪ExtensionStaticInclude();
                $node->setName('EXT:' . $extensionKey . '/ext_typoscript_' . $this->type . '.typoscript');
                $node->setPath('EXT:' . $extensionKey . '/ext_typoscript_' . $this->type . '.typoscript');
                $node->setLineStream($this->tokenizer->tokenize($fileContent));
                $this->treeFromTokenStreamBuilder->buildTree($node, $this->type, $this->tokenizer);
                $this->cache?->set(‪$identifier, $this->‪prepareNodeForCache($node));
                $parentNode->‪addChild($node);
            }
        }
    }
 
    private function ‪addDefaultTypoScriptFromGlobals(‪IncludeInterface $parentConstantNode): void
    {
        $defaultTypoScriptConstants = ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . ‪$this->type] ?? '';
        if (!empty($defaultTypoScriptConstants)) {
            $cacheIdentifier = 'globals-defaulttyposcript-' . $this->type . '-' . hash('xxh3', $defaultTypoScriptConstants);
            if ($this->cache) {
                $node = $this->cache->require($cacheIdentifier);
                if ($node) {
                    $parentConstantNode->‪addChild($node);
                    return;
                }
            }
            $node = new ‪DefaultTypoScriptInclude();
            $node->setName('TYPO3_CONF_VARS[\'FE\'][\'defaultTypoScript_' . $this->type . '\']');
            $node->setLineStream($this->tokenizer->tokenize($defaultTypoScriptConstants));
            $this->treeFromTokenStreamBuilder->buildTree($node, $this->type, $this->tokenizer);
            $this->cache?->set($cacheIdentifier, $this->prepareNodeForCache($node));
            $parentConstantNode->addChild($node);
        }
    }
 
    private function addDefaultTypoScriptConstantsFromSite(IncludeInterface $parentConstantNode, ?SiteInterface $site): void
    {
        if (!$site instanceof Site) {
            return;
        }
        $siteConstants = '';
        $siteSettings = $site->getSettings();
        if ($siteSettings->isEmpty()) {
            return;
        }
        $cacheIdentifier = 'site-constants-' . hash('xxh3', json_encode($siteSettings, JSON_THROW_ON_ERROR));
        if ($this->cache) {
            $node = $this->cache->require($cacheIdentifier);
            if ($node) {
                $parentConstantNode->addChild($node);
                return;
            }
        }
        $siteSettings = $siteSettings->getAllFlat();
        foreach ($siteSettings as $nodeIdentifier => $value) {
            $siteConstants .= $nodeIdentifier . ' = ' . $value . LF;
        }
        $node = new SiteInclude();
        $node->setName('‪Site constants settings of site "' . $site->getIdentifier() . '"');
        $node->setLineStream($this->tokenizer->tokenize($siteConstants));
        $this->cache?->set($cacheIdentifier, $this->prepareNodeForCache($node));
        $parentConstantNode->addChild($node);
    }
 
    private function addStaticMagicFromGlobals(IncludeInterface $parentNode, string $identifier): void
    {
        // defaultTypoScript_constants.' or defaultTypoScript_setup.'
        $source = $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $this->type . '.'][$identifier] ?? null;
        if (!empty($source)) {
            $node = new DefaultTypoScriptMagicKeyInclude();
            $node->setName('TYPO3_CONF_VARS globals_defaultTypoScript_' . $this->type . '.' . $identifier);
            $node->setLineStream($this->tokenizer->tokenize($source));
            $this->treeFromTokenStreamBuilder->buildTree($node, $this->type, $this->tokenizer);
            $parentNode->addChild($node);
        }
        // If this is a template of type "default content rendering", see if other extensions have added their TypoScript that should be included.
        if (in_array($identifier, $GLOBALS['TYPO3_CONF_VARS']['FE']['contentRenderingTemplates'], true)) {
            $source = $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $this->type . '.']['defaultContentRendering'] ?? null;
            if (!empty($source)) {
                $node = new DefaultTypoScriptMagicKeyInclude();
                $node->setName('TYPO3_CONF_VARS defaultContentRendering ' . $this->type . ' for ' . $identifier);
                $node->setLineStream($this->tokenizer->tokenize($source));
                $this->treeFromTokenStreamBuilder->buildTree($node, $this->type, $this->tokenizer);
                $parentNode->addChild($node);
            }
        }
    }
 
    private function getBasedOnSysTemplateRowsFromDatabase(array $basedOnTemplateUids): array
    {
        $queryBuilder = $this->connectionPool->getQueryBuilderForTable('sys_template');
        $queryBuilder->setRestrictions($this->getSysTemplateQueryRestrictionContainer());
        $basedOnTemplateRows = $queryBuilder
            ->select('*')
            ->from('sys_template')
            ->where(
                $queryBuilder->expr()->in(
                    'uid',
                    $queryBuilder->createNamedParameter($basedOnTemplateUids, Connection::PARAM_INT_ARRAY)
                )
            )
            ->executeQuery()
            ->fetchAllAssociative();
        return array_combine(array_column($basedOnTemplateRows, 'uid'), $basedOnTemplateRows);
    }
 
    private function getSysTemplateRowIdentifier(array $sysTemplateRow, ?SiteInterface $site): string
    {
        $siteIdentifier = 'dummy';
        if ($this->type === 'constants' && ((int)$sysTemplateRow['clear'] & 1) && $site !== null) {
            $siteIdentifier = $site->getIdentifier();
        }
        $cacheRelevantSysTemplateRowValues = [
            'root' => (int)$sysTemplateRow['root'],
            'clear' => (int)$sysTemplateRow['clear'],
            'include_static_file' => (string)$sysTemplateRow['include_static_file'],
            'constants' => (string)$sysTemplateRow['constants'],
            'config' => (string)$sysTemplateRow['config'],
            'basedOn' => (string)$sysTemplateRow['basedOn'],
            'includeStaticAfterBasedOn' => (int)$sysTemplateRow['includeStaticAfterBasedOn'],
            'static_file_mode' => (int)$sysTemplateRow['static_file_mode'],
            'siteIdentifier' => $siteIdentifier,
        ];
        return hash('xxh3', json_encode($cacheRelevantSysTemplateRowValues, JSON_THROW_ON_ERROR));
    }
 
    private function prepareNodeForCache(IncludeInterface $node): string
    {
        return 'return unserialize(\'' . addcslashes(serialize($node), '\'\\') . '\');';
    }
 
    private function ‪getSysTemplateQueryRestrictionContainer(): ‪DefaultRestrictionContainer
    {
        $restrictionContainer = GeneralUtility::makeInstance(DefaultRestrictionContainer::class);
        if ($this->context->getPropertyFromAspect('visibility', 'includeHiddenContent', false)) {
            $restrictionContainer->removeByType(HiddenRestriction::class);
        }
        return $restrictionContainer;
    }
}