DeletedRecords.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\Recycler\Domain\Model;
 
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Platform\PlatformInformation;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryHelper;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\WorkspaceRestriction;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\Type\Bitmask\Permission;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Recycler\Utility\RecyclerUtility;
 
class ‪DeletedRecords
{
    protected ‪$deletedRows = [];
 
    protected ‪$limit = '';
 
    protected ‪$table = [];
 
    protected ‪$recyclerHelper;
 
    public ‪$label;
 
    public ‪$title;
 
    /************************************************************
     * GET DATA FUNCTIONS
     *
     *
     ************************************************************/
    public function ‪loadData($id, ‪$table, $depth, ‪$limit = '', $filter = '')
    {
        // set the limit
        $this->limit = trim(‪$limit);
        if (‪$table) {
            if (in_array(‪$table, ‪RecyclerUtility::getModifyableTables(), true)) {
                $this->table[] = ‪$table;
                $this->‪setData($id, ‪$table, $depth, $filter);
            }
        } else {
            foreach (‪RecyclerUtility::getModifyableTables() as $tableKey) {
                // only go into this table if the limit allows it
                if ($this->limit !== '') {
                    $parts = ‪GeneralUtility::intExplode(',', $this->limit, true);
                    // abort loop if LIMIT 0,0
                    if ($parts[0] === 0 && $parts[1] === 0) {
                        break;
                    }
                }
                $this->table[] = $tableKey;
                $this->‪setData($id, $tableKey, $depth, $filter);
            }
        }
        return $this;
    }
 
    public function ‪getTotalCount($id, ‪$table, $depth, $filter)
    {
        $deletedRecords = $this->‪loadData($id, ‪$table, $depth, '', $filter)->‪getDeletedRows();
        $countTotal = 0;
        foreach ($this->table as $tableName) {
            $countTotal += count($deletedRecords[$tableName] ?? []);
        }
        return $countTotal;
    }
 
    protected function ‪setData($id, ‪$table, $depth, $filter)
    {
        $deletedField = ‪RecyclerUtility::getDeletedField(‪$table);
        if (!$deletedField) {
            return;
        }
 
        $id = (int)$id;
        $tcaCtrl = ‪$GLOBALS['TCA'][‪$table]['ctrl'];
        $firstResult = 0;
        $maxResults = 0;
 
        // get the limit
        if (!empty($this->limit)) {
            // count the number of deleted records for this pid
            $queryBuilder = $this->‪getFilteredQueryBuilder($table, $id, $depth, $filter);
 
            $deletedCount = (int)$queryBuilder
                ->count('*')
                ->from(‪$table)
                ->andWhere(
                    $queryBuilder->expr()->neq(
                        $deletedField,
                        $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)
                    )
                )
                ->execute()
                ->fetchColumn(0);
 
            // split the limit
            [$offset, $rowCount] = ‪GeneralUtility::intExplode(',', $this->limit, true);
            // subtract the number of deleted records from the limit's offset
            $result = $offset - $deletedCount;
            // if the result is >= 0
            if ($result >= 0) {
                // store the new offset in the limit and go into the next depth
                $offset = $result;
                $this->limit = implode(',', [$offset, $rowCount]);
                // do NOT query this depth; limit also does not need to be set, we set it anyways
                $allowQuery = false;
            } else {
                // the offset for the temporary limit has to remain like the original offset
                // in case the original offset was just crossed by the amount of deleted records
                $tempOffset = 0;
                if ($offset !== 0) {
                    $tempOffset = $offset;
                }
                // set the offset in the limit to 0
                $newOffset = 0;
                // convert to negative result to the positive equivalent
                $absResult = abs($result);
                // if the result now is > limit's row count
                if ($absResult > $rowCount) {
                    // use the limit's row count as the temporary limit
                    $firstResult = $tempOffset;
                    $maxResults = $rowCount;
                    // set the limit's row count to 0
                    $this->limit = implode(',', [$newOffset, 0]);
                } else {
                    // if the result now is <= limit's row count
                    // use the result as the temporary limit
                    $firstResult = $tempOffset;
                    $maxResults = $absResult;
                    // subtract the result from the row count
                    $newCount = $rowCount - $absResult;
                    // store the new result in the limit's row count
                    $this->limit = implode(',', [$newOffset, $newCount]);
                }
                // allow query for this depth
                $allowQuery = true;
            }
        } else {
            $allowQuery = true;
        }
        // query for actual deleted records
        if ($allowQuery) {
            $queryBuilder = $this->‪getFilteredQueryBuilder($table, $id, $depth, $filter);
            if ($firstResult) {
                $queryBuilder->setFirstResult($firstResult);
            }
            if ($maxResults) {
                $queryBuilder->setMaxResults($maxResults);
            }
            $recordsToCheck = $queryBuilder->select('*')
                ->from(‪$table)
                ->andWhere(
                    $queryBuilder->expr()->eq(
                        $deletedField,
                        $queryBuilder->createNamedParameter(1, \PDO::PARAM_INT)
                    )
                )
                ->orderBy('uid')
                ->execute()
                ->fetchAll();
 
            if ($recordsToCheck !== false) {
                $this->‪checkRecordAccess($table, $recordsToCheck);
            }
        }
        $this->label[‪$table] = $tcaCtrl['label'];
        $this->title[‪$table] = $tcaCtrl['title'];
    }
 
    protected function ‪getFilteredQueryBuilder(string ‪$table, int $pid, int $depth, string $filter): QueryBuilder
    {
        $pidList = $this->‪getTreeList($pid, $depth);
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(‪$table);
        $queryBuilder->getRestrictions()->removeAll()
            ->add(GeneralUtility::makeInstance(WorkspaceRestriction::class, $this->‪getBackendUser()->workspace));
 
        // create the filter WHERE-clause
        $filterConstraint = null;
        if (trim($filter) !== '') {
            $filterConstraint = $queryBuilder->expr()->comparison(
                $queryBuilder->castFieldToTextType(‪$GLOBALS['TCA'][‪$table]['ctrl']['label']),
                'LIKE',
                $queryBuilder->createNamedParameter(
                    '%' . $queryBuilder->escapeLikeWildcards($filter) . '%',
                    \PDO::PARAM_STR
                )
            );
            if (‪MathUtility::canBeInterpretedAsInteger($filter)) {
                $filterConstraint = $queryBuilder->expr()->orX(
                    $queryBuilder->expr()->eq(
                        'uid',
                        $queryBuilder->createNamedParameter($filter, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        'pid',
                        $queryBuilder->createNamedParameter($filter, \PDO::PARAM_INT)
                    ),
                    $filterConstraint
                );
            }
        }
 
        $maxBindParameters = ‪PlatformInformation::getMaxBindParameters($queryBuilder->getConnection()->getDatabasePlatform());
        $pidConstraints = [];
        foreach (array_chunk($pidList, $maxBindParameters - 10) as $chunk) {
            $pidConstraints[] = $queryBuilder->expr()->in(
                'pid',
                $queryBuilder->createNamedParameter($chunk, Connection::PARAM_INT_ARRAY)
            );
        }
        $queryBuilder->where(
            $queryBuilder->expr()->andX(
                $filterConstraint,
                $queryBuilder->expr()->orX(...$pidConstraints)
            )
        );
 
        return $queryBuilder;
    }
 
    protected function ‪checkRecordAccess(‪$table, array $rows)
    {
        $deleteField = '';
        if (‪$table === 'pages') {
            // The "checkAccess" method validates access to the passed table/rows. When access to
            // a page record gets validated it is necessary to disable the "delete" field temporarily
            // for the recycler.
            // Else it wouldn't be possible to perform the check as many methods of BackendUtility
            // like "BEgetRootLine", etc. will only work on non-deleted records.
            $deleteField = ‪$GLOBALS['TCA'][‪$table]['ctrl']['delete'];
            unset(‪$GLOBALS['TCA'][‪$table]['ctrl']['delete']);
        }
 
        foreach ($rows as $row) {
            if (‪RecyclerUtility::checkAccess(‪$table, $row)) {
                $this->‪setDeletedRows($table, $row);
            }
        }
 
        if (‪$table === 'pages') {
            ‪$GLOBALS['TCA'][‪$table]['ctrl']['delete'] = $deleteField;
        }
    }
 
    /************************************************************
     * DELETE FUNCTIONS
     ************************************************************/
    public function deleteData($recordsArray)
    {
        if (is_array($recordsArray)) {
            $tce = GeneralUtility::makeInstance(DataHandler::class);
            $tce->start([], []);
            $tce->disableDeleteClause();
            foreach ($recordsArray as $record) {
                [‪$table, $uid] = explode(':', $record);
                $tce->deleteEl(‪$table, (int)$uid, true, true);
            }
            return true;
        }
        return false;
    }
 
    /************************************************************
     * UNDELETE FUNCTIONS
     ************************************************************/
    public function ‪undeleteData($recordsArray, $recursive = false)
    {
        $result = false;
        $affectedRecords = 0;
        $depth = 999;
        if (is_array($recordsArray)) {
            $this->deletedRows = [];
            $cmd = [];
            foreach ($recordsArray as $record) {
                [‪$table, $uid] = explode(':', $record);
                $uid = (int)$uid;
                // get all parent pages and cover them
                $pid = ‪RecyclerUtility::getPidOfUid($uid, ‪$table);
                if ($pid > 0) {
                    $parentUidsToRecover = $this->‪getDeletedParentPages($pid);
                    $count = count($parentUidsToRecover);
                    for ($i = 0; $i < $count; ++$i) {
                        $parentUid = $parentUidsToRecover[$i];
                        $cmd['pages'][$parentUid]['undelete'] = 1;
                        $affectedRecords++;
                    }
                    if (isset($cmd['pages'])) {
                        // reverse the page list to recover it from top to bottom
                        $cmd['pages'] = array_reverse($cmd['pages'], true);
                    }
                }
                $cmd[‪$table][$uid]['undelete'] = 1;
                $affectedRecords++;
                if (‪$table === 'pages' && $recursive) {
                    $this->‪loadData($uid, '', $depth, '');
                    $childRecords = $this->‪getDeletedRows();
                    if (!empty($childRecords)) {
                        foreach ($childRecords as $childTable => $childRows) {
                            foreach ($childRows as $childRow) {
                                $cmd[$childTable][$childRow['uid']]['undelete'] = 1;
                            }
                        }
                    }
                }
            }
            if ($cmd) {
                $tce = GeneralUtility::makeInstance(DataHandler::class);
                $tce->start([], $cmd);
                $tce->process_cmdmap();
                $result = $affectedRecords;
            }
        }
        return $result;
    }
 
    protected function ‪getDeletedParentPages($uid, &$pages = [])
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('pages');
        $queryBuilder->getRestrictions()->removeAll()
            ->add(GeneralUtility::makeInstance(WorkspaceRestriction::class, $this->‪getBackendUser()->workspace));
        $record = $queryBuilder
            ->select('uid', 'pid')
            ->from('pages')
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)),
                $queryBuilder->expr()->eq(‪$GLOBALS['TCA']['pages']['ctrl']['delete'], 1)
            )
            ->execute()
            ->fetch();
        if ($record) {
            $pages[] = $record['uid'];
            if ((int)$record['pid'] !== 0) {
                $this->‪getDeletedParentPages($record['pid'], $pages);
            }
        }
 
        return $pages;
    }
 
    /************************************************************
     * SETTER FUNCTIONS
     ************************************************************/
    public function ‪setDeletedRows(‪$table, array $row)
    {
        $this->deletedRows[‪$table][] = $row;
    }
 
    /************************************************************
     * GETTER FUNCTIONS
     ************************************************************/
    public function ‪getDeletedRows()
    {
        return ‪$this->deletedRows;
    }
 
    public function ‪getTable()
    {
        return ‪$this->table;
    }
 
    protected function ‪getTreeList(int $id, int $depth, int $begin = 0): array
    {
        $cache = $this->‪getCache();
        $identifier = md5($id . '_' . $depth . '_' . $begin);
        $pageTree = $cache->get($identifier);
        if ($pageTree === false) {
            $pageTree = $this->‪resolveTree($id, $depth, $begin, $this->‪getBackendUser()->getPagePermsClause(‪Permission::PAGE_SHOW));
            $cache->set($identifier, $pageTree);
        }
 
        return $pageTree;
    }
 
    protected function ‪resolveTree(int $id, int $depth, int $begin = 0, string $permsClause = ''): array
    {
        $depth = (int)$depth;
        $begin = (int)$begin;
        $id = abs((int)$id);
        $theList = [];
        if ($begin === 0) {
            $theList[] = $id;
        }
        if ($depth > 0) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('pages');
            $queryBuilder->getRestrictions()->removeAll()
                ->add(GeneralUtility::makeInstance(WorkspaceRestriction::class, $this->‪getBackendUser()->workspace));
            $statement = $queryBuilder->select('uid')
                ->from('pages')
                ->where(
                    $queryBuilder->expr()->eq('pid', $queryBuilder->createNamedParameter($id, \PDO::PARAM_INT)),
                    ‪QueryHelper::stripLogicalOperatorPrefix($permsClause)
                )
                ->execute();
            while ($row = $statement->fetch()) {
                if ($begin <= 0) {
                    $theList[] = $row['uid'];
                }
                if ($depth > 1) {
                    $theList = array_merge($theList, $this->‪resolveTree($row['uid'], $depth - 1, $begin - 1, $permsClause));
                }
            }
        }
        return $theList;
    }
 
    protected function ‪getCache(): ‪FrontendInterface
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('runtime');
    }
 
    protected function ‪getBackendUser(): ‪BackendUserAuthentication
    {
        return ‪$GLOBALS['BE_USER'];
    }
}