RefIndex::getDeletableRecUidListFromTable() - Code Metrics - Inspection of "[REFACTORING] Minor changes and code-quality impro..." - AOEpeople/TYPO3-Update-Refindex - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( 3301a9...d2d929 )

by Felix
created 2022-06-17 12:40 UTC
RefIndex::getDeletableRecUidListFromTable() A

↳ Parent: RefIndex
Complexity

Conditions	2
Paths	2
Size

Total Lines	30
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	17
CRAP Score	2.0006
Importance

Changes
Metric	Value
cc	2
eloc	20
nc	2
nop	1
dl	0
loc	30
ccs	17
cts	18
cp	0.9444
crap	2.0006
rs	9.6
c	0
b	0
f	0
<?php

namespace Aoe\UpdateRefindex\Typo3;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2021 AOE GmbH <[email protected]>
 *
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use Doctrine\DBAL\FetchMode;
use PDO;
use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Database\Query\QueryBuilder;
use TYPO3\CMS\Core\Database\ReferenceIndex;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * scheduler-task to update refindex of TYPO3
 *
 * @package update_refindex
 * @subpackage Typo3
 */
class RefIndex
{
    public const ARRAY_CHUNK_SIZE = 100;

    /**
     * @var ConnectionPool
     */
    private $connectionPool;

    /**
     * @var array
     */
    private $existingTables;

    /**
     * @var array
     */
    private $selectedTables = [];

    /**
     * @var ReferenceIndex
     */
    private $referenceIndex;

    /**
     * @param array $selectedTables
     * @return RefIndex
     */
    public function setSelectedTables(array $selectedTables)
    {
        $this->selectedTables = $selectedTables;

        return $this;
    }

    /**
     * @return array
     */
    public function getSelectedTables()
    {
        return $this->selectedTables;
    }

    /**
     * @return array
     */
    public function getExistingTables()
    {
        if ($this->existingTables === null) {
            $this->existingTables = array_keys($GLOBALS['TCA']);
            sort($this->existingTables);
        }

        return $this->existingTables;
    }

    /**
     * update refIndex of selected tables
     */
    public function update()
    {
        // update index of selected tables
        foreach ($this->getSelectedTables() as $selectedTable) {
            if (in_array($selectedTable, $this->getExistingTables(), true)) {
                $this->updateTable($selectedTable);
            }
        }

        // delete lost indexes ONLY if index of ALL tables where updated
        if (count($this->getExistingTables()) === count($this->getSelectedTables())) {
            $this->deleteLostIndexes();
        }
    }

    /**
     * Searching lost indexes for non-existing tables
     * this code is inspired by the code of method 'updateIndex' in class '\TYPO3\CMS\Core\Database\ReferenceIndex'
     */
    protected function deleteLostIndexes()
    {
        $queryBuilder = $this->getQueryBuilderForTable('sys_refindex');
        $queryBuilder
            ->delete('sys_refindex')
            ->where(
                $queryBuilder->expr()
                /** @scrutinizer ignore-type */ $queryBuilder->expr()
                    ->notIn(
                        'tablename',
                        $queryBuilder->createNamedParameter($this->getExistingTables(), Connection::PARAM_STR_ARRAY)
                    )
            );
        $queryBuilder->execute();
    }

    /**
     * update table
     * this code is inspired by the code of method 'updateIndex' in class '\TYPO3\CMS\Core\Database\ReferenceIndex'
     *
     * @param string $tableName
     */
    protected function updateTable($tableName)
    {
        // Select all records from table, including deleted records
        $queryBuilder = $this->getQueryBuilderForTable($tableName);
        $allRecs = $queryBuilder
        $allRecs = /** @scrutinizer ignore-deprecated */ $queryBuilder
            ->select('uid')
            ->from($tableName)
            ->execute()
            ->fetchAll(FetchMode::ASSOCIATIVE);

        // Update refindex table for all records in table
        foreach ($allRecs as $recdat) {
            $this->getReferenceIndex()
                ->updateRefIndexTable($tableName, $recdat['uid']);
        }

        $recUidList = $this->getDeletableRecUidListFromTable($tableName);

        if (!empty($recUidList)) {
            // Searching lost indexes for this table:
            $queryBuilder = $this->getQueryBuilderForTable('sys_refindex');
            foreach (array_chunk($recUidList, self::ARRAY_CHUNK_SIZE) as $recUidChunk) {
                $queryBuilder
                    ->delete('sys_refindex')
                    ->where(
                        $queryBuilder->expr()
                        /** @scrutinizer ignore-type */ $queryBuilder->expr()
                            ->eq(
                                'tablename',
                                $queryBuilder->createNamedParameter($tableName, PDO::PARAM_STR)
                            )
                    )
                    ->andWhere(
                        $queryBuilder->expr()
                        /** @scrutinizer ignore-type */ $queryBuilder->expr()
                            ->in(
                                'recuid',
                                $queryBuilder->createNamedParameter($recUidChunk, Connection::PARAM_INT_ARRAY)
                            )
                    );
                $queryBuilder->execute();
            }
        }
    }

    /**
     * @param string $tableName
     *
     * @return int[]
     */
    protected function getDeletableRecUidListFromTable($tableName): array
    {
        // Select all records from table, including deleted records
        $subQueryBuilder = $this->getQueryBuilderForTable($tableName);
        $subQueryBuilder
            ->select('uid')
            ->from($tableName);

        // Select all records from sys_refindex which are not in $tableName, including deleted records
        $queryBuilder = $this->getQueryBuilderForTable('sys_refindex');
        $queryBuilder
            ->select('recuid')
            ->from('sys_refindex')
            ->where(
                $queryBuilder->expr()
                /** @scrutinizer ignore-type */ $queryBuilder->expr()
                    ->eq('tablename', $queryBuilder->createNamedParameter($tableName, PDO::PARAM_STR))
            )
            ->andWhere($queryBuilder->expr()->notIn('recuid', $subQueryBuilder->getSQL()))
            ->andWhere(/** @scrutinizer ignore-type */ $queryBuilder->expr()->notIn('recuid', $subQueryBuilder->getSQL()))
            ->groupBy('recuid');

        $allRecs = $queryBuilder
        $allRecs = /** @scrutinizer ignore-deprecated */ $queryBuilder
            ->execute()
            ->fetchAll(FetchMode::ASSOCIATIVE);

        $recUidList = [0];
        foreach ($allRecs as $recdat) {
            $recUidList[] = (int) $recdat['recuid'];
        }

        return $recUidList;
    }

    /**
     * @return ReferenceIndex
     */
    protected function getReferenceIndex(): ReferenceIndex
    {
        if ($this->referenceIndex === null) {
            $this->referenceIndex = GeneralUtility::makeInstance(ReferenceIndex::class);
        }

        return $this->referenceIndex;
    }

    /**
     * @param string $table
     * @param bool   $useEnableFields
     * @return QueryBuilder
     */
    private function getQueryBuilderForTable(string $table, bool $useEnableFields = false): QueryBuilder
    {
        $connectionPool = $this->getConnectionPool();
        $queryBuilder = $connectionPool->getQueryBuilderForTable($table);

        if ($useEnableFields === false) {
            $queryBuilder->getRestrictions()
                ->removeAll();
        }

        return $queryBuilder;
    }

    /**
     * @return ConnectionPool
     */
    private function getConnectionPool(): ConnectionPool
    {
        if ($this->connectionPool === null) {
            $this->connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
        }

        return $this->connectionPool;
    }
}

AOEpeople / TYPO3-Update-Refindex

Push — main ( 3301a9...d2d929 )

RefIndex::getDeletableRecUidListFromTable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
