9.5/_deleted_records_command_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Lowlevel\Command;


/*

 * 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 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!');

    }


    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 . '".');

                    }

                }

            }

        }

    }

}