DeletedRecordsCommand.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\Lowlevel\Command;
 
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use ‪TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Core\Bootstrap;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
 
class ‪DeletedRecordsCommand extends Command
{
 
    public function ‪configure()
    {
        $this
            ->setDescription('Permanently deletes all records marked as "deleted" in the database.')
            ->setHelp('Traverse page tree and find and flush deleted records. If you want to get more detailed information, use the --verbose option.')
            ->addOption(
                'pid',
                'p',
                InputOption::VALUE_REQUIRED,
                'Setting start page in page tree. Default is the page tree root, 0 (zero)'
            )
            ->addOption(
                'depth',
                'd',
                InputOption::VALUE_REQUIRED,
                'Setting traversal depth. 0 (zero) will only analyze start page (see --pid), 1 will traverse one level of subpages etc.'
            )
            ->addOption(
                'dry-run',
                null,
                InputOption::VALUE_NONE,
                'If this option is set, the records will not actually be deleted, but just the output which records would be deleted are shown'
            );
    }
 
    protected function ‪execute(InputInterface $input, OutputInterface ‪$output)
    {
        // Make sure the _cli_ user is loaded
        ‪Bootstrap::initializeBackendAuthentication();
 
        $io = new SymfonyStyle($input, ‪$output);
        $io->title($this->getDescription());
 
        $startingPoint = 0;
        if ($input->hasOption('pid') && ‪MathUtility::canBeInterpretedAsInteger($input->getOption('pid'))) {
            $startingPoint = ‪MathUtility::forceIntegerInRange((int)$input->getOption('pid'), 0);
        }
 
        $depth = 1000;
        if ($input->hasOption('depth') && ‪MathUtility::canBeInterpretedAsInteger($input->getOption('depth'))) {
            $depth = ‪MathUtility::forceIntegerInRange((int)$input->getOption('depth'), 0);
        }
 
        if ($io->isVerbose()) {
            $io->section('Searching the database now for deleted records.');
        }
 
        // type unsafe comparison and explicit boolean setting on purpose
        $dryRun = $input->hasOption('dry-run') && $input->getOption('dry-run') != false ? true : false;
 
        // find all records that should be deleted
        $deletedRecords = $this->‪findAllFlaggedRecordsInPage($startingPoint, $depth);
 
        if (!$io->isQuiet()) {
            $totalAmountOfTables = count($deletedRecords);
            $totalAmountOfRecords = 0;
            foreach ($deletedRecords as $tableName => $itemsInTable) {
                $totalAmountOfRecords += count($itemsInTable);
 
                if ($io->isVeryVerbose()) {
                    $io->writeln('Found ' . count($itemsInTable) . ' deleted records in table "' . $tableName . '".');
                }
            }
            $io->note('Found ' . $totalAmountOfRecords . ' records in ' . $totalAmountOfTables . ' database tables ready to be deleted.');
        }
 
        $io->section('Deletion process starting now.' . ($dryRun ? ' (Not deleting now, just a dry run)' : ''));
 
        // actually permanently delete them
        $this->‪deleteRecords($deletedRecords, $dryRun, $io);
 
        $io->success('All done!');
        return 0;
    }
 
    protected function ‪findAllFlaggedRecordsInPage(int $pageId, int $depth, array $deletedRecords = []): array
    {
        $queryBuilderForPages = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('pages');
        $queryBuilderForPages->getRestrictions()->removeAll();
 
        $pageId = (int)$pageId;
        if ($pageId > 0) {
            $queryBuilderForPages
                ->select('uid', 'deleted')
                ->from('pages')
                ->where(
                    $queryBuilderForPages->expr()->andX(
                        $queryBuilderForPages->expr()->eq(
                            'uid',
                            $queryBuilderForPages->createNamedParameter($pageId, \PDO::PARAM_INT)
                        ),
                        $queryBuilderForPages->expr()->neq('deleted', 0)
                    )
                )
                ->‪execute();
            $rowCount = $queryBuilderForPages
                ->count('uid')
                ->execute()
                ->fetchColumn(0);
            // Register if page itself is deleted
            if ($rowCount > 0) {
                $deletedRecords['pages'][$pageId] = $pageId;
            }
        }
 
        $databaseTables = $this->‪getTablesWithDeletedFlags();
        // Traverse tables of records that belongs to page
        foreach ($databaseTables as $tableName => $deletedField) {
            // Select all records belonging to page
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable($tableName);
 
            $queryBuilder->getRestrictions()->removeAll();
 
            $result = $queryBuilder
                ->select('uid', $deletedField)
                ->from($tableName)
                ->where(
                    $queryBuilder->expr()->eq(
                        'pid',
                        $queryBuilder->createNamedParameter($pageId, \PDO::PARAM_INT)
                    )
                )
                ->execute();
 
            while ($recordOnPage = $result->fetch()) {
                // Register record as deleted
                if ($recordOnPage[$deletedField]) {
                    $deletedRecords[$tableName][$recordOnPage['uid']] = $recordOnPage['uid'];
                }
                // Add any versions of those records
                $versions = ‪BackendUtility::selectVersionsOfRecord(
                    $tableName,
                    $recordOnPage['uid'],
                    'uid,t3ver_wsid,t3ver_count,' . $deletedField,
                    null,
                    true
                ) ?: [];
                if (is_array($versions)) {
                    foreach ($versions as $verRec) {
                        // Mark as deleted
                        if (!$verRec['_CURRENT_VERSION'] && $verRec[$deletedField]) {
                            $deletedRecords[$tableName][$verRec['uid']] = $verRec['uid'];
                        }
                    }
                }
            }
        }
 
        // Find subpages to root ID and go recursive
        if ($depth > 0) {
            $depth--;
            $result = $queryBuilderForPages
                ->select('uid')
                ->from('pages')
                ->where(
                    $queryBuilderForPages->expr()->eq('pid', $pageId)
                )
                ->orderBy('sorting')
                ->execute();
 
            while ($subPage = $result->fetch()) {
                $deletedRecords = $this->‪findAllFlaggedRecordsInPage($subPage['uid'], $depth, $deletedRecords);
            }
        }
 
        // Add any versions of the page
        if ($pageId > 0) {
            $versions = ‪BackendUtility::selectVersionsOfRecord(
                'pages',
                $pageId,
                'uid,t3ver_oid,t3ver_wsid,t3ver_count',
                null,
                true
            ) ?: [];
            if (is_array($versions)) {
                foreach ($versions as $verRec) {
                    if (!$verRec['_CURRENT_VERSION']) {
                        $deletedRecords = $this->‪findAllFlaggedRecordsInPage($verRec['uid'], $depth, $deletedRecords);
                    }
                }
            }
        }
 
        return $deletedRecords;
    }
 
    protected function ‪getTablesWithDeletedFlags(): array
    {
        $tables = [];
        foreach (‪$GLOBALS['TCA'] as $tableName => $configuration) {
            if ($tableName !== 'pages' && isset(‪$GLOBALS['TCA'][$tableName]['ctrl']['delete'])) {
                $tables[$tableName] = ‪$GLOBALS['TCA'][$tableName]['ctrl']['delete'];
            }
        }
        ksort($tables);
        return $tables;
    }
 
    protected function ‪deleteRecords(array $deletedRecords, bool $dryRun, SymfonyStyle $io)
    {
        // Putting "pages" table in the bottom
        if (isset($deletedRecords['pages'])) {
            $_pages = $deletedRecords['pages'];
            unset($deletedRecords['pages']);
            // To delete sub pages first assuming they are accumulated from top of page tree.
            $deletedRecords['pages'] = array_reverse($_pages);
        }
 
        // set up the data handler instance
        $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
        $dataHandler->start([], []);
 
        // Loop through all tables and their records
        foreach ($deletedRecords as $table => $list) {
            if ($io->isVerbose()) {
                $io->writeln('Flushing ' . count($list) . ' deleted records from table "' . $table . '"');
            }
            foreach ($list as $uid) {
                if ($io->isVeryVerbose()) {
                    $io->writeln('Flushing record "' . $table . ':' . $uid . '"');
                }
                if (!$dryRun) {
                    // Notice, we are deleting pages with no regard to subpages/subrecords - we do this since they
                    // should also be included in the set of deleted pages of course (no un-deleted record can exist
                    // under a deleted page...)
                    $dataHandler->deleteRecord($table, $uid, true, true);
                    // Return errors if any:
                    if (!empty($dataHandler->errorLog)) {
                        $errorMessage = array_merge(['DataHandler reported an error'], $dataHandler->errorLog);
                        $io->error($errorMessage);
                    } elseif (!$io->isQuiet()) {
                        $io->writeln('Permanently deleted record "' . $table . ':' . $uid . '".');
                    }
                }
            }
        }
    }
}