AbstractUpdateHandler::isRecursiveUpdateRequired() - Code Metrics - Inspection of "[P:11.5:FEATURE] Improve data update handling" - TYPO3-Solr/ext-solr - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — release-11.5.x (#3193)

by Markus
created 2022-02-07 09:16 UTC
AbstractUpdateHandler::isRecursiveUpdateRequired() A

↳ Parent: AbstractUpdateHandler
Complexity

Conditions	4
Paths	5
Size

Total Lines	16
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	10
dl	0
loc	16
rs	9.9332
c	0
b	0
f	0
cc	4
nc	5
nop	2
<?php declare(strict_types = 1);
namespace ApacheSolrForTypo3\Solr\Domain\Index\Queue\UpdateHandler;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2021 Markus Friedrich <[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 3 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\Driver\Exception as DBALDriverException;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Database\QueryGenerator;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ApacheSolrForTypo3\Solr\IndexQueue\Queue;
use ApacheSolrForTypo3\Solr\Domain\Index\Queue\RecordMonitor\Helper\ConfigurationAwareRecordService;
use ApacheSolrForTypo3\Solr\FrontendEnvironment;
use ApacheSolrForTypo3\Solr\System\TCA\TCAService;

/**
 * Abstract update handler
 *
 * Base class for Handling updates or deletions on potential
 * relevant records
 */
abstract class AbstractUpdateHandler
{
    /**
     * List of fields in the update field array that
     * are required for processing
     *
     * Note: For pages all fields except l10n_diffsource are
     *       kept, as additional fields can be configured in
     *       TypoScript, see AbstractDataUpdateEvent->__sleep.
     *
     * @var array
     */
    protected static $requiredUpdatedFields = [];

    /**
     * Configuration used to check if recursive updates are required
     *
     * Update handlers may need to determine which update combination
     * require a recursive change.
     *
     * The structure needs to be:
     *
     * [
     *      [
     *           'currentState' => ['fieldName1' => 'value1'],
     *           'changeSet' => ['fieldName1' => 'value1']
     *      ]
     * ]
     *
     * When the all values of the currentState AND all values of the changeSet match, a recursive update
     * will be triggered.
     *
     * @var array
     */
    protected $updateSubPagesRecursiveTriggerConfiguration = [];
    /**
     * @var ConfigurationAwareRecordService
     */
    protected $configurationAwareRecordService = null;

    /**
     * @var FrontendEnvironment
     */
    protected $frontendEnvironment = null;

    /**
     * @var TCAService
     */
    protected $tcaService = null;

    /**
     * @var Queue
     */
    protected $indexQueue;

    /**
     * @param ConfigurationAwareRecordService $recordService
     * @param FrontendEnvironment $frontendEnvironment
     * @param TCAService $tcaService
     */
    public function __construct(
        ConfigurationAwareRecordService $recordService,
        FrontendEnvironment $frontendEnvironment,
        TCAService $tcaService,
        Queue $indexQueue
        ) {
            $this->configurationAwareRecordService = $recordService;
            $this->frontendEnvironment = $frontendEnvironment;
            $this->tcaService = $tcaService;
            $this->indexQueue = $indexQueue;
    }

    /**
     * Returns the required fields from the updated fields array
     *
     * @return array
     */
    public static function getRequiredUpdatedFields(): array
    {
        return static::$requiredUpdatedFields;
    }

    /**
     * Add required update field
     *
     * @param string $field
     */
    public static function addRequiredUpdatedField(string $field): void
    {
        static::$requiredUpdatedFields[] = $field;
    }

    /**
     * @return array
     */
    protected function getAllRelevantFieldsForCurrentState(): array
    {
        $allCurrentStateFieldnames = [];

        foreach ($this->getUpdateSubPagesRecursiveTriggerConfiguration() as $triggerConfiguration) {
            if (!isset($triggerConfiguration['currentState']) || !is_array($triggerConfiguration['currentState'])) {
                // when no "currentState" configuration for the trigger exists we can skip it
                continue;
            }

            // we collect the currentState fields to return a unique list of all fields
            $allCurrentStateFieldnames = array_merge(
                $allCurrentStateFieldnames,
                array_keys($triggerConfiguration['currentState'])
                );
        }

        return array_unique($allCurrentStateFieldnames);
    }

    /**
     * When the extend to subpages flag was set, we determine the affected subpages and return them.
     *
     * @param int $pageId
     * @return array
     */
    protected function getSubPageIds(int $pageId): array
    {
        // here we retrieve only the subpages of this page because the permission clause is not evaluated
        // on the root node.
        $permissionClause = ' 1 ' . BackendUtility::BEenableFields('pages');
        $treePageIdList = (string)$this->getQueryGenerator()->getTreeList($pageId, 20, 0, $permissionClause);
        $treePageIds = array_map('intval', explode(',', $treePageIdList));

        // the first one can be ignored because this is the page itself
        array_shift($treePageIds);

        return $treePageIds;
    }

    /**
     * Checks if a page update will trigger a recursive update of pages
     *
     * This can either be the case if some $changedFields are part of the RecursiveUpdateTriggerConfiguration or
     * columns have explicitly been configured via plugin.tx_solr.index.queue.recursiveUpdateFields
     *
     * @param int $pageId
     * @param array $updatedFields
     * @return bool
     * @throws DBALDriverException
     */
    protected function isRecursivePageUpdateRequired(int $pageId, array $updatedFields): bool
    {
        // First check RecursiveUpdateTriggerConfiguration
        $isRecursiveUpdateRequired = $this->isRecursiveUpdateRequired($pageId, $updatedFields);
        // If RecursiveUpdateTriggerConfiguration is false => check if changeFields are part of recursiveUpdateFields
        if ($isRecursiveUpdateRequired === false) {
            $solrConfiguration = $this->frontendEnvironment->getSolrConfigurationFromPageId($pageId);
            $indexQueueConfigurationName = $this->configurationAwareRecordService->getIndexingConfigurationName(
                'pages',
                $pageId,
                $solrConfiguration
                );
            if ($indexQueueConfigurationName === null) {
                return false;
            }
            $updateFields = $solrConfiguration->getIndexQueueConfigurationRecursiveUpdateFields(
                $indexQueueConfigurationName
                );

            // Check if no additional fields have been defined and then skip recursive update
            if (empty($updateFields)) {
                return false;
            }
            // If the recursiveUpdateFields configuration is not part of the $changedFields skip recursive update
            if (!array_intersect_key($updatedFields, $updateFields)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param int $pageId
     * @param array $updatedFields
     * @return bool
     */
    protected function isRecursiveUpdateRequired(int $pageId, array $updatedFields): bool
    {
        $fieldsForCurrentState = $this->getAllRelevantFieldsForCurrentState();
        $fieldListToRetrieve = implode(',', $fieldsForCurrentState);
        $page = BackendUtility::getRecord('pages', $pageId, $fieldListToRetrieve, '', false);
        foreach ($this->getUpdateSubPagesRecursiveTriggerConfiguration() as $triggerConfiguration) {
            $allCurrentStateFieldsMatch = $this->getAllCurrentStateFieldsMatch($triggerConfiguration, $page);
            $allCurrentStateFieldsMatch = $this->getAllCurrentStateFieldsMatch($triggerConfiguration, /** @scrutinizer ignore-type */ $page);
            $allChangeSetValuesMatch = $this->getAllChangeSetValuesMatch($triggerConfiguration, $updatedFields);

            $aMatchingTriggerHasBeenFound = $allCurrentStateFieldsMatch && $allChangeSetValuesMatch;
            if ($aMatchingTriggerHasBeenFound) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param array $triggerConfiguration
     * @param array $pageRecord
     * @return bool
     */
    protected function getAllCurrentStateFieldsMatch(array $triggerConfiguration, array $pageRecord): bool
    {
        $triggerConfigurationHasNoCurrentStateConfiguration = !array_key_exists('currentState', $triggerConfiguration);
        if ($triggerConfigurationHasNoCurrentStateConfiguration) {
            return true;
        }
        $diff = array_diff_assoc($triggerConfiguration['currentState'], $pageRecord);
        return empty($diff);
    }

    /**
     * @param array $triggerConfiguration
     * @param array $changedFields
     * @return bool
     */
    protected function getAllChangeSetValuesMatch(array $triggerConfiguration, array $changedFields): bool
    {
        $triggerConfigurationHasNoChangeSetStateConfiguration = !array_key_exists('changeSet', $triggerConfiguration);
        if ($triggerConfigurationHasNoChangeSetStateConfiguration) {
            return true;
        }

        $diff = array_diff_assoc($triggerConfiguration['changeSet'], $changedFields);
        return empty($diff);
    }

    /**
     * The implementation of this method need to retrieve a configuration to determine which record data
     * and change combination required a recursive change.
     *
     * The structure needs to be:
     *
     * [
     *      [
     *           'currentState' => ['fieldName1' => 'value1'],
     *           'changeSet' => ['fieldName1' => 'value1']
     *      ]
     * ]
     *
     * When the all values of the currentState AND all values of the changeSet match, a recursive update
     * will be triggered.
     *
     * @return array
     */
    protected function getUpdateSubPagesRecursiveTriggerConfiguration(): array
    {
        return $this->updateSubPagesRecursiveTriggerConfiguration;
    }

    /**
     * @return QueryGenerator
     */
    protected function getQueryGenerator(): QueryGenerator
    {
        return GeneralUtility::makeInstance(QueryGenerator::class);
    }
}

TYPO3-Solr / ext-solr

Pull Request — release-11.5.x (#3193)

AbstractUpdateHandler::isRecursiveUpdateRequired() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
