TreelistCacheUpdateHooks.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Frontend\Hooks;

/*
 * 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!
 */

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class TreelistCacheUpdateHooks
{
    private $updateRequiringFields = [
        'pid',
        'php_tree_stop',
        'extendToSubpages'
    ];

    public function __construct()
    {
        // As enableFields can be set dynamically we add them here
        $pagesEnableFields = $GLOBALS['TCA']['pages']['ctrl']['enablecolumns'];
        foreach ($pagesEnableFields as $pagesEnableField) {
            $this->updateRequiringFields[] = $pagesEnableField;
        }
        $this->updateRequiringFields[] = $GLOBALS['TCA']['pages']['ctrl']['delete'];
        // Extension can add fields to the pages table that require an
        // update of the treelist cache, too; so we also add those
        // example: $TYPO3_CONF_VARS['BE']['additionalTreelistUpdateFields'] .= ',my_field';
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['BE']['additionalTreelistUpdateFields'])) {
            $additionalTreelistUpdateFields = GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['BE']['additionalTreelistUpdateFields'], true);
            $this->updateRequiringFields = array_merge($this->updateRequiringFields, $additionalTreelistUpdateFields);
        }
    }

    public function processDatamap_afterDatabaseOperations($status, $table, $recordId, array $updatedFields, DataHandler $dataHandler)
    {
        if ($table === 'pages' && $this->requiresUpdate($updatedFields)) {
            $affectedPagePid = 0;
            $affectedPageUid = 0;
            if ($status === 'new') {
                // Detect new pages
                // Resolve the uid
                $affectedPageUid = $dataHandler->substNEWwithIDs[$recordId];
                $affectedPagePid = $updatedFields['pid'];
            } elseif ($status === 'update') {
                // Detect updated pages
                $affectedPageUid = $recordId;
                // When updating a page the pid is not directly available so we
                // need to retrieve it ourselves.
                $fullPageRecord = BackendUtility::getRecord($table, $recordId);
                $affectedPagePid = $fullPageRecord['pid'];
            }
            $clearCacheActions = $this->determineClearCacheActions($status, $updatedFields);
            $this->processClearCacheActions($affectedPageUid, $affectedPagePid, $updatedFields, $clearCacheActions);
        }
    }

    public function processCmdmap_postProcess($command, $table, $recordId, $commandValue, DataHandler $dataHandler)
    {
        $action = (is_array($commandValue) && isset($commandValue['action'])) ? (string)$commandValue['action'] : '';
        if ($table === 'pages' && ($command === 'delete' || ($command === 'version' && $action === 'swap'))) {
            $affectedRecord = BackendUtility::getRecord($table, $recordId, '*', '', false);
            $affectedPageUid = $affectedRecord['uid'];
            $affectedPagePid = $affectedRecord['pid'];

            // Faking the updated fields
            $updatedFields = [];
            if ($command === 'delete') {
                $updatedFields['deleted'] = 1;
            } else {
                // page was published to live (swapped)
                $updatedFields['t3ver_wsid'] = 0;
            }
            $clearCacheActions = $this->determineClearCacheActions(
                'update',
                $updatedFields
            );

            $this->processClearCacheActions($affectedPageUid, $affectedPagePid, $updatedFields, $clearCacheActions);
        }
    }

    public function moveRecord_firstElementPostProcess($table, $recordId, $destinationPid, array $movedRecord, array $updatedFields, DataHandler $dataHandler)
    {
        if ($table === 'pages' && $this->requiresUpdate($updatedFields)) {
            $affectedPageUid = $recordId;
            $affectedPageOldPid = $movedRecord['pid'];
            $affectedPageNewPid = $updatedFields['pid'];
            $clearCacheActions = $this->determineClearCacheActions('update', $updatedFields);
            // Clear treelist entries for old parent page
            $this->processClearCacheActions($affectedPageUid, $affectedPageOldPid, $updatedFields, $clearCacheActions);
            // Clear treelist entries for new parent page
            $this->processClearCacheActions($affectedPageUid, $affectedPageNewPid, $updatedFields, $clearCacheActions);
        }
    }

    public function moveRecord_afterAnotherElementPostProcess($table, $recordId, $destinationPid, $originalDestinationPid, array $movedRecord, array $updatedFields, DataHandler $dataHandler)
    {
        if ($table === 'pages' && $this->requiresUpdate($updatedFields)) {
            $affectedPageUid = $recordId;
            $affectedPageOldPid = $movedRecord['pid'];
            $affectedPageNewPid = $updatedFields['pid'];
            $clearCacheActions = $this->determineClearCacheActions('update', $updatedFields);
            // Clear treelist entries for old parent page
            $this->processClearCacheActions($affectedPageUid, $affectedPageOldPid, $updatedFields, $clearCacheActions);
            // Clear treelist entries for new parent page
            $this->processClearCacheActions($affectedPageUid, $affectedPageNewPid, $updatedFields, $clearCacheActions);
        }
    }

    protected function requiresUpdate(array $updatedFields)
    {
        $requiresUpdate = false;
        $updatedFieldNames = array_keys($updatedFields);
        foreach ($updatedFieldNames as $updatedFieldName) {
            if (in_array($updatedFieldName, $this->updateRequiringFields, true)) {
                $requiresUpdate = true;
                break;
            }
        }
        return $requiresUpdate;
    }

    protected function processClearCacheActions($affectedPage, $affectedParentPage, $updatedFields, array $actions)
    {
        $actionNames = array_keys($actions);
        foreach ($actionNames as $actionName) {
            switch ($actionName) {
                case 'allParents':
                    $this->clearCacheForAllParents($affectedParentPage);
                    break;
                case 'setExpiration':
                    // Only used when setting an end time for a page
                    $expirationTime = $updatedFields['endtime'];
                    $this->setCacheExpiration($affectedPage, $expirationTime);
                    break;
                case 'uidInTreelist':
                    $this->clearCacheWhereUidInTreelist($affectedPage);
                    break;
            }
        }
        // From time to time clean the cache from expired entries
        // (theoretically every 1000 calls)
        $randomNumber = rand(1, 1000);
        if ($randomNumber === 500) {
            $this->removeExpiredCacheEntries();
        }
    }

    protected function clearCacheForAllParents($affectedParentPage)
    {
        $rootLine = BackendUtility::BEgetRootLine($affectedParentPage);
        $rootLineIds = [];
        foreach ($rootLine as $page) {
            if ($page['uid'] != 0) {
                $rootLineIds[] = $page['uid'];
            }
        }
        if (!empty($rootLineIds)) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('cache_treelist');
            $queryBuilder
                ->delete('cache_treelist')
                ->where(
                    $queryBuilder->expr()->in(
                        'pid',
                        $queryBuilder->createNamedParameter($rootLineIds, Connection::PARAM_INT_ARRAY)
                    )
                )
                ->execute();
        }
    }

    protected function clearCacheWhereUidInTreelist($affectedPage)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('cache_treelist');
        $queryBuilder
            ->delete('cache_treelist')
            ->where(
                $queryBuilder->expr()->inSet('treelist', $queryBuilder->quote($affectedPage))
            )
            ->execute();
    }

    protected function setCacheExpiration($affectedPage, $expirationTime)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('cache_treelist');
        $queryBuilder
            ->update('cache_treelist')
            ->where(
                $queryBuilder->expr()->inSet('treelist', $queryBuilder->quote($affectedPage))
            )
            ->set('expires', $expirationTime)
            ->execute();
    }

    protected function removeExpiredCacheEntries()
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('cache_treelist');
        $queryBuilder
            ->delete('cache_treelist')
            ->where(
                $queryBuilder->expr()->lte(
                    'expires',
                    $queryBuilder->createNamedParameter($GLOBALS['EXEC_TIME'], \PDO::PARAM_INT)
                )
            )
            ->execute();
    }

    protected function determineClearCacheActions($status, $updatedFields): array
    {
        $actions = [];
        if ($status === 'new') {
            // New page
            $actions['allParents'] = true;
        } elseif ($status === 'update') {
            $updatedFieldNames = array_keys($updatedFields);
            foreach ($updatedFieldNames as $updatedFieldName) {
                switch ($updatedFieldName) {
                    case 'pid':

                    case $GLOBALS['TCA']['pages']['ctrl']['enablecolumns']['disabled']:

                    case $GLOBALS['TCA']['pages']['ctrl']['delete']:

                    case $GLOBALS['TCA']['pages']['ctrl']['enablecolumns']['starttime']:

                    case $GLOBALS['TCA']['pages']['ctrl']['enablecolumns']['fe_group']:

                    case 'extendToSubpages':

                    case 't3ver_wsid':

                    case 'php_tree_stop':
                        // php_tree_stop
                        $actions['allParents'] = true;
                        $actions['uidInTreelist'] = true;
                        break;
                    case $GLOBALS['TCA']['pages']['ctrl']['enablecolumns']['endtime']:
                        // end time set/unset
                        // When setting an end time the cache entry needs an
                        // expiration time. When unsetting the end time the
                        // page must become listed in the treelist again.
                        if ($updatedFields['endtime'] > 0) {
                            $actions['setExpiration'] = true;
                        } else {
                            $actions['uidInTreelist'] = true;
                        }
                        break;
                    default:
                        if (in_array($updatedFieldName, $this->updateRequiringFields, true)) {
                            $actions['uidInTreelist'] = true;
                        }
                }
            }
        }
        return $actions;
    }
}