CacheService.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\Extbase\Service;
 
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
 
class ‪CacheService implements ‪SingletonInterface
{
    protected array ‪$clearCacheForTables = [];
    protected \SplStack ‪$pageIdStack;
 
    public function ‪__construct(
        private readonly ‪ConfigurationManagerInterface $configurationManager,
        private readonly ‪CacheManager $cacheManager,
        private readonly ‪ConnectionPool $connectionPool,
    ) {
        $this->pageIdStack = new \SplStack();
    }
 
    public function ‪getPageIdStack(): \SplStack
    {
        return ‪$this->pageIdStack;
    }
 
    public function ‪clearPageCache($pageIdsToClear = null): void
    {
        if ($pageIdsToClear === null) {
            $this->cacheManager->flushCachesInGroup('pages');
        } else {
            if (!is_array($pageIdsToClear)) {
                $pageIdsToClear = [(int)$pageIdsToClear];
            }
            $tags = array_map(static fn(int $item): string => 'pageId_' . $item, $pageIdsToClear);
            $this->cacheManager->flushCachesInGroupByTags('pages', $tags);
        }
    }
 
    public function ‪clearCachesOfRegisteredPageIds(): void
    {
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (!empty($frameworkConfiguration['persistence']['enableAutomaticCacheClearing'] ?? false)) {
            foreach ($this->clearCacheForTables as $table => $ids) {
                foreach ($ids as $id) {
                    $this->‪clearPageCacheForGivenRecord($table, $id);
                }
            }
        }
        if (!$this->pageIdStack->isEmpty()) {
            $pageIds = [];
            while (!$this->pageIdStack->isEmpty()) {
                $pageIds[] = (int)$this->pageIdStack->pop();
            }
            $pageIds = array_values(array_unique($pageIds));
            $this->‪clearPageCache($pageIds);
        }
    }
 
    public function ‪clearCacheForRecord(string $table, int ‪$uid): void
    {
        if (!is_array($this->clearCacheForTables[$table] ?? null)) {
            $this->clearCacheForTables[$table] = [];
        }
        $this->clearCacheForTables[$table][] = ‪$uid;
    }
 
    protected function ‪clearPageCacheForGivenRecord(string $tableName, int ‪$uid): void
    {
        $pageIdsToClear = [];
        $storagePage = null;
 
        $queryBuilder = $this->connectionPool->getQueryBuilderForTable($tableName);
        $queryBuilder->getRestrictions()->removeAll();
        $result = $queryBuilder
            ->select('pid')
            ->from($tableName)
            ->where(
                $queryBuilder->expr()->eq(
                    'uid',
                    $queryBuilder->createNamedParameter(‪$uid, ‪Connection::PARAM_INT)
                )
            )
            ->executeQuery();
        if ($row = $result->fetchAssociative()) {
            $storagePage = $row['pid'];
            $pageIdsToClear[] = $storagePage;
        }
        if ($storagePage === null) {
            return;
        }
 
        $pageTS = BackendUtility::getPagesTSconfig($storagePage);
        if (isset($pageTS['TCEMAIN.']['clearCacheCmd'])) {
            $clearCacheCommands = ‪GeneralUtility::trimExplode(',', strtolower((string)$pageTS['TCEMAIN.']['clearCacheCmd']), true);
            $clearCacheCommands = array_unique($clearCacheCommands);
            foreach ($clearCacheCommands as $clearCacheCommand) {
                if (‪MathUtility::canBeInterpretedAsInteger($clearCacheCommand)) {
                    $pageIdsToClear[] = $clearCacheCommand;
                }
            }
        }
 
        foreach ($pageIdsToClear as $pageIdToClear) {
            $this->‪getPageIdStack()->push($pageIdToClear);
        }
    }
}