TypoScriptFrontendController.php

Go to the documentation of this file.

<?php
 
/*
 * 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\Frontend\Controller;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LogLevel;
use ‪TYPO3\CMS\Backend\FrontendBackendUserAuthentication;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Localization\LanguageServiceFactory;
use ‪TYPO3\CMS\Core\Localization\Locale;
use ‪TYPO3\CMS\Core\Localization\Locales;
use ‪TYPO3\CMS\Core\Page\AssetCollector;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\PageTitle\PageTitleProviderManager;
use ‪TYPO3\CMS\Core\TimeTracker\TimeTracker;
use ‪TYPO3\CMS\Core\Type\DocType;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
use ‪TYPO3\CMS\Frontend\Cache\CacheLifetimeCalculator;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\Event\AfterCacheableContentIsGeneratedEvent;
use ‪TYPO3\CMS\Frontend\Event\AfterCachedPageIsPersistedEvent;
 
class ‪TypoScriptFrontendController implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    public int ‪$id;
 
    public array ‪$rootLine = [];
 
    public ?array ‪$page = [];
 
    public int ‪$contentPid = 0;
 
    public ‪PageRepository ‪$sys_page;
 
    public array ‪$config = [];
 
    protected int ‪$cacheTimeOutDefault = 0;
 
    public bool ‪$pageContentWasLoadedFromCache = false;
 
    public int ‪$cacheExpires = 0;
 
    public int ‪$cacheGenerated = 0;
 
    public string ‪$newHash = '';
 
    public array ‪$additionalHeaderData = [];
 
    public array ‪$additionalFooterData = [];
 
    public string ‪$absRefPrefix = '';
 
    public array ‪$register = [];
 
    public array ‪$registerStack = [];
 
    public array ‪$recordRegister = [];
 
    public string ‪$currentRecord = '';
 
    protected int ‪$uniqueCounter = 0;
 
    protected string ‪$uniqueString = '';
 
    public ‪ContentObjectRenderer ‪$cObj;
 
    public string ‪$content = '';
 
    protected ‪LanguageService ‪$languageService;
 
    protected ?‪PageRenderer ‪$pageRenderer = null;
    protected ‪FrontendInterface ‪$pageCache;
 
    public array ‪$pageCacheTags = [];
 
    protected string ‪$contentType = 'text/html; charset=utf-8';
 
    protected ‪Context ‪$context;
 
    public ?string ‪$debugInformationHeader = null;
 
    public function ‪__construct()
    {
        $this->sys_page = GeneralUtility::makeInstance(PageRepository::class);
        $this->context = GeneralUtility::makeInstance(Context::class);
        $this->uniqueString = md5(microtime());
        $cacheManager = GeneralUtility::makeInstance(CacheManager::class);
        $this->pageCache = $cacheManager->getCache('pages');
    }
 
    public function ‪initializePageRenderer(ServerRequestInterface $request): void
    {
        if ($this->pageRenderer !== null) {
            return;
        }
        $this->pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);
        $this->pageRenderer->setTemplateFile('EXT:frontend/Resources/Private/Templates/MainPage.html');
        // As initPageRenderer could be called in constructor and for USER_INTs, this information is only set
        // once - in order to not override any previous settings of PageRenderer.
        $language = $request->getAttribute('language') ?? $request->getAttribute('site')->getDefaultLanguage();
        if ($language->hasCustomTypo3Language()) {
            $locale = GeneralUtility::makeInstance(Locales::class)->createLocale($language->getTypo3Language());
        } else {
            $locale = $language->getLocale();
        }
        $this->pageRenderer->setLanguage($locale);
    }
 
    public function ‪initializeLanguageService(ServerRequestInterface $request): void
    {
        $language = $request->getAttribute('language') ?? $request->getAttribute('site')->getDefaultLanguage();
        $this->languageService = GeneralUtility::makeInstance(LanguageServiceFactory::class)->createFromSiteLanguage($language);
    }
 
    public function ‪setContentType(string ‪$contentType): void
    {
        $this->contentType = ‪$contentType;
    }
 
    public function ‪isGeneratePage(): bool
    {
        return !‪$this->pageContentWasLoadedFromCache;
    }
 
    protected function ‪setPageCacheContent(
        ServerRequestInterface $request,
        string ‪$content,
        array $INTincScript,
        array $INTincScript_ext,
        array $pageTitleCache,
        int $expirationTstamp
    ): array {
        $pageInformation = $request->getAttribute('frontend.page.information');
        $pageId = $pageInformation->getId();
        $pageRecord = $pageInformation->getPageRecord();
        $cacheData = [
            'page_id' => $pageId,
            'content' => ‪$content,
            'contentType' => ‪$this->contentType,
            'INTincScript' => $INTincScript,
            'INTincScript_ext' => $INTincScript_ext,
            'pageTitleCache' => $pageTitleCache,
            'expires' => $expirationTstamp,
            'tstamp' => ‪$GLOBALS['EXEC_TIME'],
        ];
        $this->cacheExpires = $expirationTstamp;
        $this->pageCacheTags[] = 'pageId_' . $pageId;
        // Respect the page cache when content of pid is shown
        if ($pageId !== $pageInformation->getContentFromPid()) {
            $this->pageCacheTags[] = 'pageId_' . $pageInformation->getContentFromPid();
        }
        if (!empty($pageRecord['cache_tags'])) {
            $tags = ‪GeneralUtility::trimExplode(',', $pageRecord['cache_tags'], true);
            $this->pageCacheTags = array_merge($this->pageCacheTags, $tags);
        }
        $this->pageCacheTags = array_unique($this->pageCacheTags);
        // Add the cache themselves as well, because they are fetched by getPageCacheTags()
        $cacheData['cacheTags'] = ‪$this->pageCacheTags;
        $this->pageCache->set($this->newHash, $cacheData, $this->pageCacheTags, $expirationTstamp - ‪$GLOBALS['EXEC_TIME']);
        return $cacheData;
    }
 
    protected function ‪setSysLastChanged(ServerRequestInterface $request): void
    {
        // Only update if browsing the live workspace
        $isInWorkspace = $this->context->getPropertyFromAspect('workspace', 'isOffline', false);
        if ($isInWorkspace) {
            return;
        }
        $pageInformation = $request->getAttribute('frontend.page.information');
        $pageRecord = $pageInformation->getPageRecord();
        if ($pageRecord['SYS_LASTCHANGED'] < (int)($this->register['SYS_LASTCHANGED'] ?? 0)) {
            $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('pages');
            $pageId = $pageRecord['_LOCALIZED_UID'] ?? $pageInformation->getId();
            $connection->update(
                'pages',
                [
                    'SYS_LASTCHANGED' => (int)$this->register['SYS_LASTCHANGED'],
                ],
                [
                    'uid' => (int)$pageId,
                ]
            );
        }
    }
 
    public function ‪addCacheTags(array $tags): void
    {
        $this->pageCacheTags = array_merge($this->pageCacheTags, $tags);
    }
 
    public function ‪getPageCacheTags(): array
    {
        return ‪$this->pageCacheTags;
    }
 
    public function ‪preparePageContentGeneration(ServerRequestInterface $request): void
    {
        $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
        // calculate the absolute path prefix
        if (!empty($this->absRefPrefix = trim($typoScriptConfigArray['absRefPrefix']))) {
            if ($this->absRefPrefix === 'auto') {
                $normalizedParams = $request->getAttribute('normalizedParams');
                $this->absRefPrefix = $normalizedParams->getSitePath();
            }
        }
        // config.forceAbsoluteUrls will override absRefPrefix
        if ($typoScriptConfigArray['forceAbsoluteUrls'] ?? false) {
            $normalizedParams = $request->getAttribute('normalizedParams');
            $this->absRefPrefix = $normalizedParams->getSiteUrl();
        }
 
        $docType = DocType::createFromConfigurationKey($typoScriptConfigArray['doctype']);
        $this->pageRenderer->setDocType($docType);
 
        // Global content object
        $this->‪newCObj($request);
    }
 
    public function ‪generatePage_postProcessing(ServerRequestInterface $request): void
    {
        $this->‪setAbsRefPrefix();
        $eventDispatcher = GeneralUtility::makeInstance(EventDispatcherInterface::class);
        $usePageCache = $request->getAttribute('frontend.cache.instruction')->isCachingAllowed();
        $event = new ‪AfterCacheableContentIsGeneratedEvent($request, $this, $this->newHash, $usePageCache);
        $event = $eventDispatcher->dispatch($event);
 
        // Processing if caching is enabled
        if ($event->isCachingEnabled()) {
            // Seconds until a cached page is too old
            $cacheTimeout = $this->‪get_cache_timeout($request);
            $timeOutTime = ‪$GLOBALS['EXEC_TIME'] + $cacheTimeout;
            // Write the page to cache, but do not cache localRootLine since that is always determined
            // and coming from PageInformation->getLocalRootLine().
            $cachedInformation = $this->‪setPageCacheContent(
                $request,
                $this->content,
                $this->config['INTincScript'] ?? [],
                $this->config['INTincScript_ext'] ?? [],
                $this->config['pageTitleCache'] ?? [],
                $timeOutTime
            );
            // Event for cache post processing (eg. writing static files)
            $event = new ‪AfterCachedPageIsPersistedEvent($request, $this, $this->newHash, $cachedInformation, $cacheTimeout);
            $eventDispatcher->dispatch($event);
        }
        $this->‪setSysLastChanged($request);
    }
 
    public function ‪generatePageTitle(ServerRequestInterface $request): string
    {
        $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
        // config.noPageTitle = 2 - means do not render the page title
        if ((int)($typoScriptConfigArray['noPageTitle'] ?? 0) === 2) {
            return '';
        }
 
        // Check for a custom pageTitleSeparator, and perform stdWrap on it
        $pageTitleSeparator = (string)$this->cObj->stdWrapValue('pageTitleSeparator', $typoScriptConfigArray);
        if ($pageTitleSeparator !== '' && $pageTitleSeparator === ($typoScriptConfigArray['pageTitleSeparator'] ?? '')) {
            $pageTitleSeparator .= ' ';
        }
 
        $titleProvider = GeneralUtility::makeInstance(PageTitleProviderManager::class);
        if (!empty($this->config['pageTitleCache'])) {
            $titleProvider->setPageTitleCache($this->config['pageTitleCache']);
        }
        $pageTitle = $titleProvider->getTitle($request);
        $this->config['pageTitleCache'] = $titleProvider->getPageTitleCache();
 
        $titleTagContent = $this->‪printTitle(
            $request,
            $pageTitle,
            (bool)($typoScriptConfigArray['noPageTitle'] ?? false),
            (bool)($typoScriptConfigArray['pageTitleFirst'] ?? false),
            $pageTitleSeparator,
            (bool)($typoScriptConfigArray['showWebsiteTitle'] ?? true)
        );
 
        if (isset($typoScriptConfigArray['pageTitle.']) && is_array($typoScriptConfigArray['pageTitle.'])) {
            // stdWrap for pageTitle if set in config.pageTitle.
            $pageTitleStdWrapArray = [
                'pageTitle' => $titleTagContent,
                'pageTitle.' => $typoScriptConfigArray['pageTitle.'],
            ];
            $titleTagContent = $this->cObj->stdWrapValue('pageTitle', $pageTitleStdWrapArray);
        }
 
        if ($titleTagContent !== '') {
            $this->pageRenderer->setTitle($titleTagContent);
        }
        return (string)$titleTagContent;
    }
 
    protected function ‪printTitle(ServerRequestInterface $request, string $pageTitle, bool $noPageTitle = false, bool $showPageTitleFirst = false, string $pageTitleSeparator = '', bool $showWebsiteTitle = true): string
    {
        $websiteTitle = $showWebsiteTitle ? $this->‪getWebsiteTitle($request) : '';
        $pageTitle = $noPageTitle ? '' : $pageTitle;
        // only show a separator if there are both site title and page title
        if ($pageTitle === '' || $websiteTitle === '') {
            $pageTitleSeparator = '';
        } elseif (empty($pageTitleSeparator)) {
            // use the default separator if non given
            $pageTitleSeparator = ': ';
        }
        if ($showPageTitleFirst) {
            return $pageTitle . $pageTitleSeparator . $websiteTitle;
        }
        return $websiteTitle . $pageTitleSeparator . $pageTitle;
    }
 
    protected function ‪getWebsiteTitle(ServerRequestInterface $request): string
    {
        // @todo: Check when/if there are scenarios where attribute 'language' is not yet set in $request.
        $language = $request->getAttribute('language') ?? $request->getAttribute('site')->getDefaultLanguage();
        if (trim($language->getWebsiteTitle()) !== '') {
            return trim($language->getWebsiteTitle());
        }
        $siteConfiguration = $request->getAttribute('site')->getConfiguration();
        if (trim($siteConfiguration['websiteTitle'] ?? '') !== '') {
            return trim($siteConfiguration['websiteTitle']);
        }
        return '';
    }
 
    public function ‪INTincScript(ServerRequestInterface $request): void
    {
        $this->additionalHeaderData = $this->config['INTincScript_ext']['additionalHeaderData'] ?? [];
        $this->additionalFooterData = $this->config['INTincScript_ext']['additionalFooterData'] ?? [];
        if (empty($this->config['INTincScript_ext']['pageRendererState'])) {
            $this->‪initializePageRenderer($request);
        } else {
            $pageRendererState = unserialize($this->config['INTincScript_ext']['pageRendererState'], ['allowed_classes' => [Locale::class]]);
            $this->pageRenderer->updateState($pageRendererState);
        }
        if (!empty($this->config['INTincScript_ext']['assetCollectorState'])) {
            $assetCollectorState = unserialize($this->config['INTincScript_ext']['assetCollectorState'], ['allowed_classes' => false]);
            GeneralUtility::makeInstance(AssetCollector::class)->updateState($assetCollectorState);
        }
 
        $this->‪recursivelyReplaceIntPlaceholdersInContent($request);
        $this->‪getTimeTracker()->push('Substitute header section');
        $this->‪INTincScript_loadJSCode();
        $this->‪generatePageTitle($request);
 
        $this->content = str_replace(
            [
                '<!--HD_' . $this->config['INTincScript_ext']['divKey'] . '-->',
                '<!--FD_' . $this->config['INTincScript_ext']['divKey'] . '-->',
            ],
            [
                implode(LF, $this->additionalHeaderData),
                implode(LF, $this->additionalFooterData),
            ],
            $this->pageRenderer->renderJavaScriptAndCssForProcessingOfUncachedContentObjects($this->content, $this->config['INTincScript_ext']['divKey'])
        );
        // Replace again, because header and footer data and page renderer replacements may introduce additional placeholders (see #44825)
        $this->‪recursivelyReplaceIntPlaceholdersInContent($request);
        $this->‪setAbsRefPrefix();
        $this->‪getTimeTracker()->pull();
    }
 
    protected function ‪recursivelyReplaceIntPlaceholdersInContent(ServerRequestInterface $request): void
    {
        do {
            $nonCacheableData = $this->config['INTincScript'];
            $this->‪processNonCacheableContentPartsAndSubstituteContentMarkers($nonCacheableData, $request);
            // Check if there were new items added to INTincScript during the previous execution:
            // array_diff_assoc throws notices if values are arrays but not strings. We suppress this here.
            $nonCacheableData = @array_diff_assoc($this->config['INTincScript'], $nonCacheableData);
            $reprocess = count($nonCacheableData) > 0;
        } while ($reprocess);
    }
 
    protected function ‪processNonCacheableContentPartsAndSubstituteContentMarkers(array $nonCacheableData, ServerRequestInterface $request): void
    {
        $timeTracker = $this->‪getTimeTracker();
        $timeTracker->push('Split content');
        // Splits content with the key.
        $contentSplitByUncacheableMarkers = explode('<!--INT_SCRIPT.', $this->content);
        $this->content = '';
        $timeTracker->setTSlogMessage('Parts: ' . count($contentSplitByUncacheableMarkers), LogLevel::INFO);
        $timeTracker->pull();
        foreach ($contentSplitByUncacheableMarkers as $counter => $contentPart) {
            // If the split had a comment-end after 32 characters it's probably a split-string
            if (substr($contentPart, 32, 3) === '-->') {
                $nonCacheableKey = 'INT_SCRIPT.' . substr($contentPart, 0, 32);
                if (is_array($nonCacheableData[$nonCacheableKey] ?? false)) {
                    $label = 'Include ' . $nonCacheableData[$nonCacheableKey]['type'];
                    $timeTracker->push($label);
                    $nonCacheableContent = '';
                    $contentObjectRendererForNonCacheable = unserialize($nonCacheableData[$nonCacheableKey]['cObj']);
                    if ($contentObjectRendererForNonCacheable instanceof ‪ContentObjectRenderer) {
                        $contentObjectRendererForNonCacheable->setRequest($request);
                        $nonCacheableContent = match ($nonCacheableData[$nonCacheableKey]['type']) {
                            'COA' => $contentObjectRendererForNonCacheable->cObjGetSingle('COA', $nonCacheableData[$nonCacheableKey]['conf']),
                            'FUNC' => $contentObjectRendererForNonCacheable->cObjGetSingle('USER', $nonCacheableData[$nonCacheableKey]['conf']),
                            'POSTUSERFUNC' => $contentObjectRendererForNonCacheable->callUserFunction($nonCacheableData[$nonCacheableKey]['postUserFunc'], $nonCacheableData[$nonCacheableKey]['conf'], $nonCacheableData[$nonCacheableKey]['content']),
                            default => '',
                        };
                    }
                    $this->content .= $nonCacheableContent;
                    $this->content .= substr($contentPart, 35);
                    $timeTracker->pull($nonCacheableContent);
                } else {
                    $this->content .= substr($contentPart, 35);
                }
            } elseif ($counter) {
                // If it's not the first entry (which would be "0" of the array keys), then re-add the INT_SCRIPT part
                $this->content .= '<!--INT_SCRIPT.' . $contentPart;
            } else {
                $this->content .= $contentPart;
            }
        }
        // invokes permanent, general handlers
        foreach ($nonCacheableData as $item) {
            if (empty($item['permanent']) || empty($item['target'])) {
                continue;
            }
            $parameters = array_merge($item['parameters'] ?? [], ['content' => $this->content]);
            $this->content = GeneralUtility::callUserFunction($item['target'], $parameters) ?? ‪$this->content;
        }
    }
 
    public function ‪INTincScript_loadJSCode(): void
    {
        // Prepare code and placeholders for additional header and footer files (and make sure that this isn't called twice)
        if ($this->‪isINTincScript() && (!isset($this->config['INTincScript_ext']) || $this->config['INTincScript_ext'] === [])) {
            $substituteHash = $this->‪uniqueHash();
            $this->config['INTincScript_ext']['divKey'] = $substituteHash;
            // Storing the header-data array
            $this->config['INTincScript_ext']['additionalHeaderData'] = ‪$this->additionalHeaderData;
            // Storing the footer-data array
            $this->config['INTincScript_ext']['additionalFooterData'] = ‪$this->additionalFooterData;
            // Clearing the array
            $this->additionalHeaderData = ['<!--HD_' . $substituteHash . '-->'];
            // Clearing the array
            $this->additionalFooterData = ['<!--FD_' . $substituteHash . '-->'];
        }
    }
 
    public function ‪isINTincScript(): bool
    {
        return !empty($this->config['INTincScript']) && is_array($this->config['INTincScript']);
    }
 
    public function ‪applyHttpHeadersToResponse(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        $response = $response->withHeader('Content-Type', $this->contentType);
        $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
        if (empty($typoScriptConfigArray['disableLanguageHeader'])) {
            // Set header for content language unless disabled
            // @todo: Check when/if there are scenarios where attribute 'language' is not yet set in $request.
            $language = $request->getAttribute('language') ?? $request->getAttribute('site')->getDefaultLanguage();
            $response = $response->withHeader('Content-Language', (string)$language->getLocale());
        }
 
        // Add a Response header to show debug information if a page was fetched from cache
        if ($this->debugInformationHeader) {
            $response = $response->withHeader('X-TYPO3-Debug-Cache', $this->debugInformationHeader);
        }
 
        // Set cache related headers to client (used to enable proxy / client caching!)
        $headers = $this->‪getCacheHeaders($request);
        foreach ($headers as $header => $value) {
            $response = $response->withHeader($header, $value);
        }
        // Set additional headers if any have been configured via TypoScript
        $additionalHeaders = $this->‪getAdditionalHeaders($request);
        foreach ($additionalHeaders as $headerConfig) {
            [$header, $value] = ‪GeneralUtility::trimExplode(':', $headerConfig['header'], false, 2);
            if ($headerConfig['statusCode']) {
                $response = $response->withStatus((int)$headerConfig['statusCode']);
            }
            if ($headerConfig['replace']) {
                $response = $response->withHeader($header, $value);
            } else {
                $response = $response->withAddedHeader($header, $value);
            }
        }
        return $response;
    }
 
    protected function ‪getCacheHeaders(ServerRequestInterface $request): array
    {
        $headers = [];
        // Getting status whether we can send cache control headers for proxy caching:
        $doCache = $this->‪isStaticCacheble($request);
        $isBackendUserLoggedIn = $this->context->getPropertyFromAspect('backend.user', 'isLoggedIn', false);
        $isInWorkspace = $this->context->getPropertyFromAspect('workspace', 'isOffline', false);
        // Finally, when backend users are logged in, do not send cache headers at all (Admin Panel might be displayed for instance).
        $isClientCachable = $doCache && !$isBackendUserLoggedIn && !$isInWorkspace;
        if ($isClientCachable) {
            // Only send the headers to the client that they are allowed to cache if explicitly activated.
            $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
            if (!empty($typoScriptConfigArray['sendCacheHeaders'])) {
                $headers = [
                    'Expires' => gmdate('D, d M Y H:i:s T', $this->cacheExpires),
                    'ETag' => '"' . md5($this->content) . '"',
                    'Cache-Control' => 'max-age=' . ($this->cacheExpires - ‪$GLOBALS['EXEC_TIME']),
                    // no-cache
                    'Pragma' => 'public',
                ];
            }
        } else {
            // "no-store" is used to ensure that the client HAS to ask the server every time, and is not allowed to store anything at all
            $headers = [
                'Cache-Control' => 'private, no-store',
            ];
            // Now, if a backend user is logged in, tell him in the Admin Panel log what the caching status would have been:
            if ($isBackendUserLoggedIn) {
                if ($doCache) {
                    $this->‪getTimeTracker()->setTSlogMessage('Cache-headers with max-age "' . ($this->cacheExpires - ‪$GLOBALS['EXEC_TIME']) . '" would have been sent');
                } else {
                    $reasonMsg = [];
                    if (!$request->getAttribute('frontend.cache.instruction')->isCachingAllowed()) {
                        $reasonMsg[] = 'Caching disabled.';
                    }
                    if ($this->‪isINTincScript()) {
                        $reasonMsg[] = '*_INT object(s) on page.';
                    }
                    if ($this->context->getPropertyFromAspect('frontend.user', 'isLoggedIn', false)) {
                        $reasonMsg[] = 'Frontend user logged in.';
                    }
                    $this->‪getTimeTracker()->setTSlogMessage('Cache-headers would disable proxy caching! Reason(s): "' . implode(' ', $reasonMsg) . '"', LogLevel::NOTICE);
                }
            }
        }
        return $headers;
    }
 
    public function ‪isStaticCacheble(ServerRequestInterface $request): bool
    {
        $isCachingAllowed = $request->getAttribute('frontend.cache.instruction')->isCachingAllowed();
        return $isCachingAllowed && !$this->‪isINTincScript() && !$this->context->getAspect('frontend.user')->isUserOrGroupSet();
    }
 
    public function ‪newCObj(ServerRequestInterface $request): void
    {
        $this->cObj = GeneralUtility::makeInstance(ContentObjectRenderer::class, $this);
        $this->cObj->setRequest($request);
        $this->cObj->start($request->getAttribute('frontend.page.information')->getPageRecord(), 'pages');
    }
 
    protected function ‪setAbsRefPrefix(): void
    {
        if (!$this->absRefPrefix) {
            return;
        }
        $encodedAbsRefPrefix = htmlspecialchars($this->absRefPrefix, ENT_QUOTES | ENT_HTML5);
        $search = [
            '"_assets/',
            '"typo3temp/',
            '"' . ‪PathUtility::stripPathSitePrefix(‪Environment::getExtensionsPath()) . '/',
            '"' . ‪PathUtility::stripPathSitePrefix(‪Environment::getFrameworkBasePath()) . '/',
        ];
        $replace = [
            '"' . $encodedAbsRefPrefix . '_assets/',
            '"' . $encodedAbsRefPrefix . 'typo3temp/',
            '"' . $encodedAbsRefPrefix . ‪PathUtility::stripPathSitePrefix(‪Environment::getExtensionsPath()) . '/',
            '"' . $encodedAbsRefPrefix . ‪PathUtility::stripPathSitePrefix(‪Environment::getFrameworkBasePath()) . '/',
        ];
        // Process additional directories
        $directories = ‪GeneralUtility::trimExplode(',', ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['additionalAbsRefPrefixDirectories'], true);
        foreach ($directories as $directory) {
            $search[] = '"' . $directory;
            $replace[] = '"' . $encodedAbsRefPrefix . $directory;
        }
        $this->content = str_replace(
            $search,
            $replace,
            $this->content
        );
    }
 
    public function ‪logDeprecatedTyposcript(string $typoScriptProperty, string $explanation = ''): void
    {
        $explanationText = $explanation !== '' ? ' - ' . $explanation : '';
        $this->‪getTimeTracker()->setTSlogMessage($typoScriptProperty . ' is deprecated.' . $explanationText, LogLevel::WARNING);
        trigger_error('TypoScript property ' . $typoScriptProperty . ' is deprecated' . $explanationText, E_USER_DEPRECATED);
    }
 
    public function ‪uniqueHash(string $str = ''): string
    {
        return md5($this->uniqueString . '_' . $str . $this->uniqueCounter++);
    }
 
    public function ‪set_no_cache(string $reason = ''): void
    {
        $warning = '';
        ‪$context = [];
        if ($reason !== '') {
            $warning = '$TSFE->set_no_cache() was triggered. Reason: {reason}.';
            ‪$context['reason'] = $reason;
        } else {
            $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
            if (isset($trace[0]['class'])) {
                ‪$context['class'] = $trace[0]['class'];
                $warning = '$GLOBALS[\'TSFE\']->set_no_cache() was triggered by {class} on line {line}.';
            }
            if (isset($trace[0]['function'])) {
                ‪$context['function'] = $trace[0]['function'];
                $warning = '$GLOBALS[\'TSFE\']->set_no_cache() was triggered by {class}->{function} on line {line}.';
            }
            if (‪$context === []) {
                // Only store the filename, not the full path for safety reasons
                ‪$context['file'] = basename($trace[0]['file']);
                $warning = '$GLOBALS[\'TSFE\']->set_no_cache() was triggered by {file} on line {line}.';
            }
            ‪$context['line'] = $trace[0]['line'];
        }
        if (‪$GLOBALS['TYPO3_CONF_VARS']['FE']['disableNoCacheParameter']) {
            $warning .= ' However, $TYPO3_CONF_VARS[\'FE\'][\'disableNoCacheParameter\'] is set, so it will be ignored!';
            $this->‪getTimeTracker()->setTSlogMessage($warning, LogLevel::NOTICE);
        } else {
            $warning .= ' Caching is disabled!';
            $request = ‪$GLOBALS['TYPO3_REQUEST'];
            $cacheInstruction = $request->getAttribute('frontend.cache.instruction');
            $cacheInstruction->disableCache('EXT:frontend: Caching disabled using deprecated set_no_cache().');
        }
        $this->logger->notice($warning, ‪$context);
    }
 
    public function ‪set_cache_timeout_default(int $seconds): void
    {
        $seconds = (int)$seconds;
        if ($seconds > 0) {
            $this->cacheTimeOutDefault = $seconds;
        }
    }
 
    protected function ‪get_cache_timeout(ServerRequestInterface $request): int
    {
        $pageInformation = $request->getAttribute('frontend.page.information');
        $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
        return GeneralUtility::makeInstance(CacheLifetimeCalculator::class)
            ->calculateLifetimeForPage(
                $pageInformation->getId(),
                $pageInformation->getPageRecord(),
                $typoScriptConfigArray,
                $this->cacheTimeOutDefault,
                $this->context
            );
    }
 
    public function ‪sL(string $input): string
    {
        return $this->languageService->sL($input);
    }
 
    protected function ‪getAdditionalHeaders(ServerRequestInterface $request): array
    {
        $typoScriptConfigArray = $request->getAttribute('frontend.typoscript')->getConfigArray();
        if (!isset($typoScriptConfigArray['additionalHeaders.'])) {
            return [];
        }
        $additionalHeaders = [];
        $additionalHeadersConfig = $typoScriptConfigArray['additionalHeaders.'];
        ksort($additionalHeadersConfig);
        foreach ($additionalHeadersConfig as $options) {
            if (!is_array($options)) {
                continue;
            }
            $header = trim($options['header'] ?? '');
            if ($header === '') {
                continue;
            }
            $additionalHeaders[] = [
                'header' => $header,
                // "replace existing headers" is turned on by default, unless turned off
                'replace' => ($options['replace'] ?? '') !== '0',
                'statusCode' => (int)($options['httpResponseCode'] ?? 0) ?: null,
            ];
        }
        return $additionalHeaders;
    }
 
    protected function ‪getBackendUser(): ?‪FrontendBackendUserAuthentication
    {
        return ‪$GLOBALS['BE_USER'] ?? null;
    }
 
    protected function ‪getTimeTracker(): ‪TimeTracker
    {
        return GeneralUtility::makeInstance(TimeTracker::class);
    }
}