DataMapProcessor.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\Core\DataHandling\Localization;
 
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
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\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\WorkspaceRestriction;
use ‪TYPO3\CMS\Core\Database\RelationHandler;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\DataHandling\ReferenceIndexUpdater;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\StringUtility;
use ‪TYPO3\CMS\Core\Versioning\VersionState;
 
class ‪DataMapProcessor
{
    protected ‪$allDataMap = [];
 
    protected $modifiedDataMap = [];
 
    protected $sanitizationMap = [];
 
    protected $backendUser;
 
    protected $referenceIndexUpdater;
 
    protected $allItems = [];
 
    protected $nextItems = [];
 
    public static function instance(
        array $dataMap,
        ‪BackendUserAuthentication $backendUser,
        ‪ReferenceIndexUpdater $referenceIndexUpdater = null
    ) {
        return GeneralUtility::makeInstance(
            static::class,
            $dataMap,
            $backendUser,
            $referenceIndexUpdater
        );
    }
 
    public function __construct(
        array $dataMap,
        ‪BackendUserAuthentication $backendUser,
        ‪ReferenceIndexUpdater $referenceIndexUpdater = null
    ) {
        $this->allDataMap = $dataMap;
        $this->‪modifiedDataMap = $dataMap;
        $this->‪backendUser = $backendUser;
        if ($referenceIndexUpdater === null) {
            $referenceIndexUpdater = GeneralUtility::makeInstance(ReferenceIndexUpdater::class);
        }
        $this->‪referenceIndexUpdater = $referenceIndexUpdater;
    }
 
    public function ‪process()
    {
        $iterations = 0;
 
        while (!empty($this->‪modifiedDataMap)) {
            $this->nextItems = [];
            foreach ($this->‪modifiedDataMap as $tableName => $idValues) {
                $this->‪collectItems($tableName, $idValues);
            }
 
            $this->‪modifiedDataMap = [];
            if (empty($this->nextItems)) {
                break;
            }
 
            if ($iterations++ === 0) {
                $this->‪sanitize($this->allItems);
            }
            $this->‪enrich($this->nextItems);
        }
 
        $this->allDataMap = $this->‪purgeDataMap($this->allDataMap);
        return ‪$this->allDataMap;
    }
 
    protected function ‪purgeDataMap(array $dataMap): array
    {
        foreach ($dataMap as $tableName => $idValues) {
            foreach ($idValues as $id => $values) {
                // `l10n_state` should be serialized JSON at this point,
                // in case it's not, it most probably was ignored in `collectItems()`
                if (is_array($values['l10n_state'] ?? null)) {
                    unset($dataMap[$tableName][$id]['l10n_state'], $values['l10n_state']);
                }
                if (empty($values)) {
                    unset($dataMap[$tableName][$id]);
                }
            }
            if (empty($dataMap[$tableName])) {
                unset($dataMap[$tableName]);
            }
        }
        return $dataMap;
    }
 
    protected function ‪collectItems(string $tableName, array $idValues)
    {
        if (!$this->‪isApplicable($tableName)) {
            return;
        }
 
        $fieldNames = [
            'uid' => 'uid',
            'l10n_state' => 'l10n_state',
            'language' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['languageField'],
            'parent' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'],
        ];
        if (!empty(‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'])) {
            $fieldNames['source'] = ‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'];
        }
 
        $translationValues = $this->‪fetchTranslationValues(
            $tableName,
            $fieldNames,
            $this->‪filterNewItemIds(
                $tableName,
                $this->‪filterNumericIds(array_keys($idValues))
            )
        );
 
        $dependencies = $this->‪fetchDependencies(
            $tableName,
            $this->‪filterNewItemIds($tableName, array_keys($idValues))
        );
 
        foreach ($idValues as $id => $values) {
            $item = $this->‪findItem($tableName, $id);
            // build item if it has not been created in a previous iteration
            if ($item === null) {
                $recordValues = $translationValues[$id] ?? [];
                $item = ‪DataMapItem::build(
                    $tableName,
                    $id,
                    $values,
                    $recordValues,
                    $fieldNames
                );
 
                // elements using "all language" cannot be localized
                if ($item->getLanguage() === -1) {
                    unset($item);
                    continue;
                }
                // must be any kind of localization and in connected mode
                if ($item->getLanguage() > 0 && empty($item->getParent())) {
                    unset($item);
                    continue;
                }
                // add dependencies
                if (!empty($dependencies[$id])) {
                    $item->setDependencies($dependencies[$id]);
                }
            }
            // add item to $this->allItems and $this->nextItems
            $this->‪addNextItem($item);
        }
    }
 
    protected function ‪sanitize(array $items)
    {
        foreach (['directChild', 'grandChild'] as $type) {
            foreach ($this->‪filterItemsByType($type, $items) as $item) {
                $this->‪sanitizeTranslationItem($item);
            }
        }
    }
 
    protected function ‪enrich(array $items)
    {
        foreach (['directChild', 'grandChild'] as $type) {
            foreach ($this->‪filterItemsByType($type, $items) as $item) {
                foreach ($item->getApplicableScopes() as $scope) {
                    $fromId = $item->getIdForScope($scope);
                    $fieldNames = $this->‪getFieldNamesForItemScope($item, $scope, !$item->isNew());
                    $this->‪synchronizeTranslationItem($item, $fieldNames, $fromId);
                }
                $this->‪populateTranslationItem($item);
                $this->‪finishTranslationItem($item);
            }
        }
        foreach ($this->‪filterItemsByType('parent', $items) as $item) {
            $this->‪populateTranslationItem($item);
        }
    }
 
    protected function ‪sanitizeTranslationItem(‪DataMapItem $item)
    {
        $fieldNames = [];
        foreach ($item->‪getApplicableScopes() as $scope) {
            $fieldNames = array_merge(
                $fieldNames,
                $this->‪getFieldNamesForItemScope($item, $scope, false)
            );
        }
 
        $fieldNameMap = array_combine($fieldNames, $fieldNames) ?: [];
        // separate fields, that are submitted in data-map, but not defined as custom
        $this->sanitizationMap[$item->‪getTableName()][$item->‪getId()] = array_intersect_key(
            $this->allDataMap[$item->‪getTableName()][$item->‪getId()],
            $fieldNameMap
        );
        // remove fields, that are submitted in data-map, but not defined as custom
        $this->allDataMap[$item->‪getTableName()][$item->‪getId()] = array_diff_key(
            $this->allDataMap[$item->‪getTableName()][$item->‪getId()],
            $fieldNameMap
        );
    }
 
    protected function ‪synchronizeTranslationItem(‪DataMapItem $item, array $fieldNames, $fromId)
    {
        if (empty($fieldNames)) {
            return;
        }
 
        $fieldNameList = 'uid,' . implode(',', $fieldNames);
 
        $fromRecord = ['uid' => $fromId];
        if (‪MathUtility::canBeInterpretedAsInteger($fromId)) {
            $fromRecord = BackendUtility::getRecordWSOL(
                $item->‪getTableName(),
                (int)$fromId,
                $fieldNameList
            );
        }
 
        $forRecord = [];
        if (!$item->‪isNew()) {
            $forRecord = BackendUtility::getRecordWSOL(
                $item->‪getTableName(),
                $item->‪getId(),
                $fieldNameList
            );
        }
 
        if (is_array($fromRecord) && is_array($forRecord)) {
            foreach ($fieldNames as $fieldName) {
                $this->‪synchronizeFieldValues(
                    $item,
                    $fieldName,
                    $fromRecord,
                    $forRecord
                );
            }
        }
    }
 
    protected function ‪populateTranslationItem(DataMapItem $item)
    {
        foreach ([‪DataMapItem::SCOPE_PARENT, ‪DataMapItem::SCOPE_SOURCE] as $scope) {
            foreach ($item->findDependencies($scope) as $dependentItem) {
                // use suggested item, if it was submitted in data-map
                $suggestedDependentItem = $this->‪findItem(
                    $dependentItem->getTableName(),
                    $dependentItem->getId()
                );
                if ($suggestedDependentItem !== null) {
                    $dependentItem = $suggestedDependentItem;
                }
                foreach ([$scope, ‪DataMapItem::SCOPE_EXCLUDE] as $dependentScope) {
                    $fieldNames = $this->‪getFieldNamesForItemScope(
                        $dependentItem,
                        $dependentScope,
                        false
                    );
                    $this->‪synchronizeTranslationItem(
                        $dependentItem,
                        $fieldNames,
                        $item->getId()
                    );
                }
            }
        }
    }
 
    protected function ‪finishTranslationItem(DataMapItem $item)
    {
        if (
            $item->isParentType()
            || !‪State::isApplicable($item->getTableName())
        ) {
            return;
        }
 
        $this->allDataMap[$item->getTableName()][$item->getId()]['l10n_state'] = $item->getState()->export();
    }
 
    protected function ‪synchronizeFieldValues(‪DataMapItem $item, string $fieldName, array $fromRecord, array $forRecord)
    {
        // skip if this field has been processed already, assumed that proper sanitation happened
        if ($this->‪isSetInDataMap($item->‪getTableName(), $item->‪getId(), $fieldName)) {
            return;
        }
 
        $fromId = $fromRecord['uid'];
        // retrieve value from in-memory data-map
        if ($this->‪isSetInDataMap($item->‪getTableName(), $fromId, $fieldName)) {
            $fromValue = $this->allDataMap[$item->‪getTableName()][$fromId][$fieldName];
        } elseif (array_key_exists($fieldName, $fromRecord)) {
            // retrieve value from record
            $fromValue = $fromRecord[$fieldName];
        } else {
            // otherwise abort synchronization
            return;
        }
 
        // plain values
        if (!$this->‪isRelationField($item->‪getTableName(), $fieldName)) {
            $this->‪modifyDataMap(
                $item->‪getTableName(),
                $item->‪getId(),
                [$fieldName => $fromValue]
            );
        } elseif (!$this->‪isReferenceField($item->‪getTableName(), $fieldName)) {
            // direct relational values
            $this->‪synchronizeDirectRelations($item, $fieldName, $fromRecord);
        } else {
            // reference values
            $this->‪synchronizeReferences($item, $fieldName, $fromRecord, $forRecord);
        }
    }
 
    protected function ‪synchronizeDirectRelations(DataMapItem $item, string $fieldName, array $fromRecord)
    {
        $configuration = ‪$GLOBALS['TCA'][$item->getTableName()]['columns'][$fieldName];
        $fromId = $fromRecord['uid'];
        if ($this->‪isSetInDataMap($item->getTableName(), $fromId, $fieldName)) {
            $fromValue = $this->allDataMap[$item->getTableName()][$fromId][$fieldName];
        } else {
            $fromValue = $fromRecord[$fieldName];
        }
 
        // non-MM relations are stored as comma separated values, just use them
        // if values are available in data-map already, just use them as well
        if (
            empty($configuration['config']['MM'])
            || $this->‪isSetInDataMap($item->getTableName(), $fromId, $fieldName)
        ) {
            $this->‪modifyDataMap(
                $item->getTableName(),
                $item->getId(),
                [$fieldName => $fromValue]
            );
            return;
        }
        // fetch MM relations from storage
        $type = $configuration['config']['type'];
        $manyToManyTable = $configuration['config']['MM'];
        if ($type === 'group' && !empty(trim($configuration['config']['allowed'] ?? ''))) {
            $tableNames = trim($configuration['config']['allowed']);
        } elseif ($configuration['config']['type'] === 'select' || $configuration['config']['type'] === 'category') {
            $tableNames = $configuration['config']['foreign_table'] ?? '';
        } else {
            return;
        }
 
        $relationHandler = $this->‪createRelationHandler();
        $relationHandler->start(
            '',
            $tableNames,
            $manyToManyTable,
            $fromId,
            $item->getTableName(),
            $configuration['config']
        );
 
        // provide list of relations, optionally prepended with table name
        // e.g. "13,19,23" or "tt_content_27,tx_extension_items_28"
        $this->‪modifyDataMap(
            $item->getTableName(),
            $item->getId(),
            [$fieldName => implode(',', $relationHandler->getValueArray())]
        );
    }
 
    protected function ‪synchronizeReferences(DataMapItem $item, string $fieldName, array $fromRecord, array $forRecord)
    {
        $configuration = ‪$GLOBALS['TCA'][$item->getTableName()]['columns'][$fieldName];
        $isLocalizationModeExclude = ($configuration['l10n_mode'] ?? null) === 'exclude';
        $foreignTableName = $configuration['config']['foreign_table'];
 
        $fieldNames = [
            'language' => ‪$GLOBALS['TCA'][$foreignTableName]['ctrl']['languageField'] ?? null,
            'parent' => ‪$GLOBALS['TCA'][$foreignTableName]['ctrl']['transOrigPointerField'] ?? null,
            'source' => ‪$GLOBALS['TCA'][$foreignTableName]['ctrl']['translationSource'] ?? null,
        ];
        $isTranslatable = (!empty($fieldNames['language']) && !empty($fieldNames['parent']));
        $isLocalized = !empty($item->getLanguage());
 
        $suggestedAncestorIds = $this->‪resolveSuggestedInlineRelations(
            $item,
            $fieldName,
            $fromRecord
        );
        $persistedIds = $this->‪resolvePersistedInlineRelations(
            $item,
            $fieldName,
            $forRecord
        );
 
        // The dependent ID map points from language parent/source record to
        // localization, thus keys: parents/sources & values: localizations
        $dependentIdMap = $this->‪fetchDependentIdMap($foreignTableName, $suggestedAncestorIds, (int)$item->getLanguage());
        // filter incomplete structures - this is a drawback of DataHandler's remap stack, since
        // just created IRRE translations still belong to the language parent - filter them out
        $suggestedAncestorIds = array_diff($suggestedAncestorIds, array_values($dependentIdMap));
        // compile element differences to be resolved
        // remove elements that are persisted at the language translation, but not required anymore
        $removeIds = array_diff($persistedIds, array_values($dependentIdMap));
        // remove elements that are persisted at the language parent/source, but not required anymore
        $removeAncestorIds = array_diff(array_keys($dependentIdMap), $suggestedAncestorIds);
        // missing elements that are persisted at the language parent/source, but not translated yet
        $missingAncestorIds = array_diff($suggestedAncestorIds, array_keys($dependentIdMap));
        // persisted elements that should be copied or localized
        $createAncestorIds = $this->‪filterNumericIds($missingAncestorIds);
        // non-persisted elements that should be duplicated in data-map directly
        $populateAncestorIds = array_diff($missingAncestorIds, $createAncestorIds);
        // this desired state map defines the final result of child elements in their parent translation
        $desiredIdMap = array_combine($suggestedAncestorIds, $suggestedAncestorIds) ?: [];
        // update existing translations in the desired state map
        foreach ($dependentIdMap as $ancestorId => $translationId) {
            if (isset($desiredIdMap[$ancestorId])) {
                $desiredIdMap[$ancestorId] = $translationId;
            }
        }
        // no children to be synchronized, but element order could have been changed
        if (empty($removeAncestorIds) && empty($missingAncestorIds)) {
            $this->‪modifyDataMap(
                $item->getTableName(),
                $item->getId(),
                [$fieldName => implode(',', array_values($desiredIdMap))]
            );
            return;
        }
        // In case only missing elements shall be created, re-use previously sanitized
        // values IF the relation parent item is new and the count of missing relations
        // equals the count of previously sanitized relations.
        // This is caused during copy processes, when the child relations
        // already have been cloned in DataHandler::copyRecord_procBasedOnFieldType()
        // without the possibility to resolve the initial connections at this point.
        // Otherwise child relations would superfluously be duplicated again here.
        // @todo Invalid manually injected child relations cannot be determined here
        $sanitizedValue = $this->sanitizationMap[$item->getTableName()][$item->getId()][$fieldName] ?? null;
        if (
            !empty($missingAncestorIds) && $item->isNew() && $sanitizedValue !== null
            && count(‪GeneralUtility::trimExplode(',', $sanitizedValue, true)) === count($missingAncestorIds)
        ) {
            $this->‪modifyDataMap(
                $item->getTableName(),
                $item->getId(),
                [$fieldName => $sanitizedValue]
            );
            return;
        }
 
        $localCommandMap = [];
        foreach ($removeIds as $removeId) {
            $localCommandMap[$foreignTableName][$removeId]['delete'] = true;
        }
        foreach ($removeAncestorIds as $removeAncestorId) {
            $removeId = $dependentIdMap[$removeAncestorId];
            $localCommandMap[$foreignTableName][$removeId]['delete'] = true;
        }
        foreach ($createAncestorIds as $createAncestorId) {
            // if child table is not aware of localization, just copy
            if ($isLocalizationModeExclude || !$isTranslatable) {
                $localCommandMap[$foreignTableName][$createAncestorId]['copy'] = [
                    'target' => -$createAncestorId,
                    'ignoreLocalization' => true,
                ];
            } else {
                // otherwise, trigger the localization process
                $localCommandMap[$foreignTableName][$createAncestorId]['localize'] = $item->getLanguage();
            }
        }
        // execute copy, localize and delete actions on persisted child records
        if (!empty($localCommandMap)) {
            $localDataHandler = GeneralUtility::makeInstance(DataHandler::class, $this->‪referenceIndexUpdater);
            $localDataHandler->start([], $localCommandMap, $this->‪backendUser);
            $localDataHandler->process_cmdmap();
            // update copied or localized ids
            foreach ($createAncestorIds as $createAncestorId) {
                if (empty($localDataHandler->copyMappingArray_merged[$foreignTableName][$createAncestorId])) {
                    $additionalInformation = '';
                    if (!empty($localDataHandler->errorLog)) {
                        $additionalInformation = ', reason "'
                        . implode(', ', $localDataHandler->errorLog) . '"';
                    }
                    throw new \RuntimeException(
                        'Child record was not processed' . $additionalInformation,
                        1486233164
                    );
                }
                $newLocalizationId = $localDataHandler->copyMappingArray_merged[$foreignTableName][$createAncestorId];
                $newLocalizationId = $localDataHandler->getAutoVersionId($foreignTableName, $newLocalizationId) ?? $newLocalizationId;
                $desiredIdMap[$createAncestorId] = $newLocalizationId;
                // apply localization references to l10n_mode=exclude children
                // (without keeping their reference to their origin, synchronization is not possible)
                if ($isLocalizationModeExclude && $isTranslatable && $isLocalized) {
                    $adjustCopiedValues = $this->‪applyLocalizationReferences(
                        $foreignTableName,
                        $createAncestorId,
                        (int)$item->getLanguage(),
                        $fieldNames,
                        []
                    );
                    $this->‪modifyDataMap(
                        $foreignTableName,
                        $newLocalizationId,
                        $adjustCopiedValues
                    );
                }
            }
        }
        // populate new child records in data-map
        if (!empty($populateAncestorIds)) {
            foreach ($populateAncestorIds as $populateAncestorId) {
                $newLocalizationId = ‪StringUtility::getUniqueId('NEW');
                $desiredIdMap[$populateAncestorId] = $newLocalizationId;
                $duplicatedValues = $this->allDataMap[$foreignTableName][$populateAncestorId] ?? [];
                // applies localization references to given raw data-map item
                if ($isTranslatable && $isLocalized) {
                    $duplicatedValues = $this->‪applyLocalizationReferences(
                        $foreignTableName,
                        $populateAncestorId,
                        (int)$item->getLanguage(),
                        $fieldNames,
                        $duplicatedValues
                    );
                }
                // prefixes language title if applicable for the accordant field name in raw data-map item
                if ($isTranslatable && $isLocalized && !$isLocalizationModeExclude) {
                    $duplicatedValues = $this->‪prefixLanguageTitle(
                        $foreignTableName,
                        $populateAncestorId,
                        (int)$item->getLanguage(),
                        $duplicatedValues
                    );
                }
                $this->‪modifyDataMap(
                    $foreignTableName,
                    $newLocalizationId,
                    $duplicatedValues
                );
            }
        }
        // update inline parent field references - required to update pointer fields
        $this->‪modifyDataMap(
            $item->getTableName(),
            $item->getId(),
            [$fieldName => implode(',', array_values($desiredIdMap))]
        );
    }
 
    protected function ‪resolveSuggestedInlineRelations(DataMapItem $item, string $fieldName, array $fromRecord): array
    {
        $suggestedAncestorIds = [];
        $fromId = $fromRecord['uid'];
        $configuration = ‪$GLOBALS['TCA'][$item->getTableName()]['columns'][$fieldName];
        $foreignTableName = $configuration['config']['foreign_table'];
        $manyToManyTable = ($configuration['config']['MM'] ?? '');
 
        // determine suggested elements of either translation parent or source record
        // from data-map, in case the accordant language parent/source record was modified
        if ($this->‪isSetInDataMap($item->getTableName(), $fromId, $fieldName)) {
            $suggestedAncestorIds = ‪GeneralUtility::trimExplode(
                ',',
                $this->allDataMap[$item->getTableName()][$fromId][$fieldName],
                true
            );
        } elseif (‪MathUtility::canBeInterpretedAsInteger($fromId)) {
            // determine suggested elements of either translation parent or source record from storage
            $relationHandler = $this->‪createRelationHandler();
            $relationHandler->start(
                $fromRecord[$fieldName],
                $foreignTableName,
                $manyToManyTable,
                $fromId,
                $item->getTableName(),
                $configuration['config']
            );
            $suggestedAncestorIds = $this->‪mapRelationItemId($relationHandler->itemArray);
        }
 
        return array_filter($suggestedAncestorIds);
    }
 
    private function ‪resolvePersistedInlineRelations(‪DataMapItem $item, string $fieldName, array $forRecord): array
    {
        $persistedIds = [];
        $configuration = ‪$GLOBALS['TCA'][$item->‪getTableName()]['columns'][$fieldName];
        $foreignTableName = $configuration['config']['foreign_table'];
        $manyToManyTable = ($configuration['config']['MM'] ?? '');
 
        // determine persisted elements for the current data-map item
        if (!$item->‪isNew()) {
            $relationHandler = $this->‪createRelationHandler();
            $relationHandler->start(
                $forRecord[$fieldName] ?? '',
                $foreignTableName,
                $manyToManyTable,
                $item->‪getId(),
                $item->‪getTableName(),
                $configuration['config']
            );
            $persistedIds = $this->‪mapRelationItemId($relationHandler->itemArray);
        }
 
        return array_filter($persistedIds);
    }
 
    protected function ‪isSetInDataMap(string $tableName, $id, string $fieldName)
    {
        return
            // directly look-up field name
            isset($this->allDataMap[$tableName][$id][$fieldName])
            // check existence of field name as key for null values
            || isset($this->allDataMap[$tableName][$id])
            && is_array($this->allDataMap[$tableName][$id])
            && array_key_exists($fieldName, $this->allDataMap[$tableName][$id]);
    }
 
    protected function ‪modifyDataMap(string $tableName, $id, array $values)
    {
        // avoid superfluous iterations by data-map changes with values
        // that actually have not been changed and were available already
        $sameValues = array_intersect_assoc(
            $this->allDataMap[$tableName][$id] ?? [],
            $values
        );
        if (!empty($sameValues)) {
            $fieldNames = implode(', ', array_keys($sameValues));
            throw new \RuntimeException(
                sprintf(
                    'Issued data-map change for table %s with same values '
                    . 'for these fields names %s',
                    $tableName,
                    $fieldNames
                ),
                1488634845
            );
        }
 
        $this->‪modifiedDataMap[$tableName][$id] = array_merge(
            $this->‪modifiedDataMap[$tableName][$id] ?? [],
            $values
        );
        $this->allDataMap[$tableName][$id] = array_merge(
            $this->allDataMap[$tableName][$id] ?? [],
            $values
        );
    }
 
    protected function ‪addNextItem(‪DataMapItem $item)
    {
        ‪$identifier = $item->‪getTableName() . ':' . $item->‪getId();
        if (!isset($this->allItems[‪$identifier])) {
            $this->allItems[‪$identifier] = $item;
        }
        $this->nextItems[‪$identifier] = $item;
    }
 
    protected function ‪fetchTranslationValues(string $tableName, array $fieldNames, array $ids)
    {
        if (empty($ids)) {
            return [];
        }
 
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($tableName);
        $queryBuilder = $connection->createQueryBuilder();
        $queryBuilder->getRestrictions()->removeAll()
            // NOT using WorkspaceRestriction here since it's wrong in this case. See ws OR restriction below.
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
        $expressions = [];
        if (BackendUtility::isTableWorkspaceEnabled($tableName)) {
            $expressions[] = $queryBuilder->expr()->eq('t3ver_wsid', 0);
        }
        if ($this->‪backendUser->workspace > 0 && BackendUtility::isTableWorkspaceEnabled($tableName)) {
            // If this is a workspace record (t3ver_wsid = be-user-workspace), then fetch this one
            // if it is NOT a deleted placeholder (t3ver_state=2), but ok with casual overlay (t3ver_state=0),
            // new ws-record (t3ver_state=1), or moved record (t3ver_state=4).
            // It *might* be possible to simplify this since it may be the case that ws-deleted records are
            // impossible to be incoming here at all? But this query is a safe thing, so we go with it for now.
            $expressions[] = $queryBuilder->expr()->and(
                $queryBuilder->expr()->eq('t3ver_wsid', $queryBuilder->createNamedParameter($this->backendUser->workspace, ‪Connection::PARAM_INT)),
                $queryBuilder->expr()->in(
                    't3ver_state',
                    $queryBuilder->createNamedParameter(
                        [VersionState::DEFAULT_STATE->value, VersionState::NEW_PLACEHOLDER->value, VersionState::MOVE_POINTER->value],
                        ‪Connection::PARAM_INT_ARRAY
                    )
                ),
            );
        }
 
        $translationValues = [];
        $maxBindParameters = ‪PlatformInformation::getMaxBindParameters($connection->getDatabasePlatform());
        // We are using the max bind parameter value as way to retrieve the data in chunks. However, we are not
        // using up the placeholders by providing the id list directly, we keep this calculation to avoid hitting
        // max query size limitation in most cases. If that is hit, it can be increased by adjusting the dbms setting.
        foreach (array_chunk($ids, $maxBindParameters, true) as $chunk) {
            $result = $queryBuilder
                ->select(...array_values($fieldNames))
                ->from($tableName)
                ->where(
                    $queryBuilder->expr()->in(
                        'uid',
                        $queryBuilder->quoteArrayBasedValueListToIntegerList($chunk)
                    ),
                    $queryBuilder->expr()->or(...$expressions)
                )
                ->executeQuery();
            while (‪$record = $result->fetchAssociative()) {
                $translationValues[‪$record['uid']] = ‪$record;
            }
        }
        return $translationValues;
    }
 
    protected function ‪fetchDependencies(string $tableName, array $ids)
    {
        if (empty($ids) || !BackendUtility::isTableLocalizable($tableName)) {
            return [];
        }
 
        $fieldNames = [
            'uid' => 'uid',
            'l10n_state' => 'l10n_state',
            'language' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['languageField'],
            'parent' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'],
        ];
        if (!empty(‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'])) {
            $fieldNames['source'] = ‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'];
        }
        $fieldNamesMap = array_combine($fieldNames, $fieldNames);
 
        $persistedIds = $this->‪filterNumericIds($ids);
        $createdIds = array_diff($ids, $persistedIds);
        $dependentElements = $this->‪fetchDependentElements($tableName, $persistedIds, $fieldNames);
 
        foreach ($createdIds as $createdId) {
            $data = $this->allDataMap[$tableName][$createdId] ?? null;
            if ($data === null) {
                continue;
            }
            $dependentElements[] = array_merge(
                ['uid' => $createdId],
                array_intersect_key($data, $fieldNamesMap)
            );
        }
 
        $dependencyMap = [];
        foreach ($dependentElements as $dependentElement) {
            $dependentItem = ‪DataMapItem::build(
                $tableName,
                $dependentElement['uid'],
                [],
                $dependentElement,
                $fieldNames
            );
 
            if ($dependentItem->isDirectChildType()) {
                $dependencyMap[$dependentItem->getParent()][‪State::STATE_PARENT][] = $dependentItem;
            }
            if ($dependentItem->isGrandChildType()) {
                $dependencyMap[$dependentItem->getParent()][‪State::STATE_PARENT][] = $dependentItem;
                $dependencyMap[$dependentItem->getSource()][‪State::STATE_SOURCE][] = $dependentItem;
            }
        }
        return $dependencyMap;
    }
 
    protected function ‪fetchDependentIdMap(string $tableName, array $ids, int $desiredLanguage)
    {
        $ancestorIdMap = [];
        if (empty($ids)) {
            return [];
        }
 
        $ids = $this->‪filterNumericIds($ids);
        $isTranslatable = BackendUtility::isTableLocalizable($tableName);
        $originFieldName = (‪$GLOBALS['TCA'][$tableName]['ctrl']['origUid'] ?? null);
 
        if (!$isTranslatable && $originFieldName === null) {
            // @todo Possibly throw an error, since pointing to original entity is not possible (via origin/parent)
            return [];
        }
 
        if ($isTranslatable) {
            $fieldNames = [
                'uid' => 'uid',
                'l10n_state' => 'l10n_state',
                'language' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['languageField'],
                'parent' => ‪$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'],
            ];
            if (!empty(‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'])) {
                $fieldNames['source'] = ‪$GLOBALS['TCA'][$tableName]['ctrl']['translationSource'];
            }
        } else {
            $fieldNames = [
                'uid' => 'uid',
                'origin' => $originFieldName,
            ];
        }
 
        $fetchIds = $ids;
        if ($isTranslatable) {
            // expand search criteria via parent and source elements
            $translationValues = $this->‪fetchTranslationValues($tableName, $fieldNames, $ids);
            $ancestorIdMap = $this->‪buildElementAncestorIdMap($fieldNames, $translationValues);
            $fetchIds = array_unique(array_merge($ids, array_keys($ancestorIdMap)));
        }
 
        $dependentElements = $this->‪fetchDependentElements($tableName, $fetchIds, $fieldNames);
 
        $dependentIdMap = [];
        foreach ($dependentElements as $dependentElement) {
            $dependentId = $dependentElement['uid'];
            // implicit: use origin pointer if table cannot be translated
            if (!$isTranslatable) {
                $ancestorId = (int)$dependentElement[$fieldNames['origin']];
                // only consider element if it reflects the desired language
            } elseif ((int)$dependentElement[$fieldNames['language']] === $desiredLanguage) {
                $ancestorId = $this->‪resolveAncestorId($fieldNames, $dependentElement);
            } else {
                // otherwise skip the element completely
                continue;
            }
            // only keep ancestors that were initially requested before expanding
            if (in_array($ancestorId, $ids, true)) {
                $dependentIdMap[$ancestorId] = $dependentId;
            } elseif (!empty($ancestorIdMap[$ancestorId])) {
                // resolve from previously expanded search criteria
                $possibleChainedIds = array_intersect(
                    $ids,
                    $ancestorIdMap[$ancestorId]
                );
                if (!empty($possibleChainedIds)) {
                    // use the first found id from `$possibleChainedIds`
                    $ancestorId = reset($possibleChainedIds);
                    $dependentIdMap[$ancestorId] = $dependentId;
                }
            }
        }
        return $dependentIdMap;
    }
 
    protected function ‪fetchDependentElements(string $tableName, array $ids, array $fieldNames)
    {
        if (empty($ids)) {
            return [];
        }
 
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable($tableName);
        $ids = $this->‪filterNumericIds($ids);
        $maxBindParameters = ‪PlatformInformation::getMaxBindParameters($connection->getDatabasePlatform());
        $dependentElements = [];
        foreach (array_chunk($ids, $maxBindParameters, true) as $idsChunked) {
            $queryBuilder = $connection->createQueryBuilder();
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
                ->add(GeneralUtility::makeInstance(WorkspaceRestriction::class, $this->‪backendUser->workspace));
 
            $zeroParameter = $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT);
            $idsParameter = $queryBuilder->quoteArrayBasedValueListToIntegerList($idsChunked);
 
            // fetch by language dependency
            if (!empty($fieldNames['language']) && !empty($fieldNames['parent'])) {
                $ancestorPredicates = [
                    $queryBuilder->expr()->in(
                        $fieldNames['parent'],
                        $idsParameter
                    ),
                ];
                if (!empty($fieldNames['source'])) {
                    $ancestorPredicates[] = $queryBuilder->expr()->in(
                        $fieldNames['source'],
                        $idsParameter
                    );
                }
                $predicates = [
                    // must be any kind of localization
                    $queryBuilder->expr()->gt(
                        $fieldNames['language'],
                        $zeroParameter
                    ),
                    // must be in connected mode
                    $queryBuilder->expr()->gt(
                        $fieldNames['parent'],
                        $zeroParameter
                    ),
                    // any parent or source pointers
                    $queryBuilder->expr()->or(...$ancestorPredicates),
                ];
            } elseif (!empty($fieldNames['origin'])) {
                // fetch by origin dependency ("copied from")
                $predicates = [
                    $queryBuilder->expr()->in(
                        $fieldNames['origin'],
                        $idsParameter
                    ),
                ];
            } else {
                // otherwise: stop execution
                throw new \InvalidArgumentException(
                    'Invalid combination of query field names given',
                    1487192370
                );
            }
 
            $statement = $queryBuilder
                ->select(...array_values($fieldNames))
                ->from($tableName)
                ->andWhere(...$predicates)
                ->executeQuery();
 
            while (‪$record = $statement->fetchAssociative()) {
                $dependentElements[] = ‪$record;
            }
        }
        return $dependentElements;
    }
 
    protected function ‪filterItemsByType(string $type, array $items)
    {
        return array_filter(
            $items,
            static function (‪DataMapItem $item) use ($type): bool {
                return $item->‪getType() === $type;
            }
        );
    }
 
    protected function ‪filterNumericIds(array $ids)
    {
        $ids = array_filter(
            $ids,
            ‪MathUtility::canBeInterpretedAsInteger(...)
        );
        return array_map(intval(...), $ids);
    }
 
    protected function ‪filterNewItemIds(string $tableName, array $ids)
    {
        return array_filter(
            $ids,
            function (string|int $id) use ($tableName): bool {
                return $this->‪findItem($tableName, $id) === null;
            }
        );
    }
 
    protected function ‪mapRelationItemId(array $relationItems): array
    {
        return array_map(
            static function (array $relationItem): int {
                return (int)$relationItem['id'];
            },
            $relationItems
        );
    }
 
    protected function ‪resolveAncestorId(array $fieldNames, array $element)
    {
        $sourceName = $fieldNames['source'] ?? null;
        if ($sourceName !== null && !empty($element[$sourceName])) {
            // implicit: use source pointer if given (not empty)
            return (int)$element[$sourceName];
        }
        $parentName = $fieldNames['parent'] ?? null;
        if ($parentName !== null && !empty($element[$parentName])) {
            // implicit: use parent pointer if given (not empty)
            return (int)$element[$parentName];
        }
        return null;
    }
 
    protected function ‪buildElementAncestorIdMap(array $fieldNames, array $elements)
    {
        $ancestorIdMap = [];
        foreach ($elements as $element) {
            $ancestorId = $this->‪resolveAncestorId($fieldNames, $element);
            if ($ancestorId !== null) {
                $ancestorIdMap[$ancestorId][] = (int)$element['uid'];
            }
        }
        return $ancestorIdMap;
    }
 
    protected function ‪findItem(string $tableName, $id)
    {
        return $this->allItems[$tableName . ':' . $id] ?? null;
    }
 
    protected function ‪applyLocalizationReferences(string $tableName, $fromId, int $language, array $fieldNames, array $data): array
    {
        // just return if localization cannot be applied
        if (empty($language)) {
            return $data;
        }
 
        // apply `languageField`, e.g. `sys_language_uid`
        $data[$fieldNames['language']] = $language;
        // apply `transOrigPointerField`, e.g. `l10n_parent`
        if (empty($data[$fieldNames['parent']])) {
            // @todo Only $id used in TCA type 'select' is resolved in DataHandler's remapStack
            $data[$fieldNames['parent']] = $fromId;
        }
        // apply `translationSource`, e.g. `l10n_source`
        if (!empty($fieldNames['source'])) {
            // @todo Not sure, whether $id is resolved in DataHandler's remapStack
            $data[$fieldNames['source']] = $fromId;
        }
        // unset field names that are expected to be handled in this processor
        foreach ($this->‪getFieldNamesToBeHandled($tableName) as $fieldName) {
            unset($data[$fieldName]);
        }
 
        return $data;
    }
 
    protected function ‪prefixLanguageTitle(string $tableName, $fromId, int $language, array $data): array
    {
        $prefixFieldNames = array_intersect(
            array_keys($data),
            $this->‪getPrefixLanguageTitleFieldNames($tableName)
        );
        if (empty($prefixFieldNames)) {
            return $data;
        }
 
        [$pageId] = BackendUtility::getTSCpid($tableName, (int)$fromId, $data['pid'] ?? null);
        $tsConfig = BackendUtility::getPagesTSconfig($pageId)['TCEMAIN.'] ?? [];
        if (($translateToMessage = (string)($tsConfig['translateToMessage'] ?? '')) === '') {
            // Return in case translateToMessage had been unset
            return $data;
        }
 
        $tableRelatedConfig = $tsConfig['default.'] ?? [];
        ArrayUtility::mergeRecursiveWithOverrule(
            $tableRelatedConfig,
            $tsConfig['table.'][$tableName . '.'] ?? []
        );
        if ($tableRelatedConfig['disablePrependAtCopy'] ?? false) {
            // Return in case "disablePrependAtCopy" is set for this table
            return $data;
        }
 
        try {
            $site = GeneralUtility::makeInstance(SiteFinder::class)->getSiteByPageId($pageId);
            $siteLanguage = $site->getLanguageById($language);
            $languageTitle = $siteLanguage->getTitle();
        } catch (SiteNotFoundException | \InvalidArgumentException $e) {
            $languageTitle = '';
        }
 
        $languageService = $this->‪getLanguageService();
        if ($languageService !== null) {
            $translateToMessage = $languageService->sL($translateToMessage);
        }
        $translateToMessage = sprintf($translateToMessage, $languageTitle);
 
        if ($translateToMessage === '') {
            // Return for edge cases when the translateToMessage got empty, e.g. because the referenced LLL
            // label is empty or only contained a placeholder which is replaced by an empty language title.
            return $data;
        }
 
        foreach ($prefixFieldNames as $prefixFieldName) {
            // @todo The hook in DataHandler is not applied here
            $data[$prefixFieldName] = '[' . $translateToMessage . '] ' . $data[$prefixFieldName];
        }
 
        return $data;
    }
 
    protected function ‪getFieldNamesForItemScope(
        ‪DataMapItem $item,
        string $scope,
        bool $modified
    ) {
        if (
            $scope === ‪DataMapItem::SCOPE_PARENT
            || $scope === ‪DataMapItem::SCOPE_SOURCE
        ) {
            if (!‪State::isApplicable($item->‪getTableName())) {
                return [];
            }
            return $item->‪getState()->filterFieldNames($scope, $modified);
        }
        if ($scope === ‪DataMapItem::SCOPE_EXCLUDE) {
            return $this->‪getLocalizationModeExcludeFieldNames(
                $item->‪getTableName()
            );
        }
        return [];
    }
 
    protected function ‪getLocalizationModeExcludeFieldNames(string $tableName)
    {
        $localizationExcludeFieldNames = [];
        if (empty(‪$GLOBALS['TCA'][$tableName]['columns'])) {
            return $localizationExcludeFieldNames;
        }
 
        foreach (‪$GLOBALS['TCA'][$tableName]['columns'] as $fieldName => $configuration) {
            if (($configuration['l10n_mode'] ?? null) === 'exclude'
                && ($configuration['config']['type'] ?? null) !== 'none'
            ) {
                $localizationExcludeFieldNames[] = $fieldName;
            }
        }
 
        return $localizationExcludeFieldNames;
    }
 
    protected function ‪getFieldNamesToBeHandled(string $tableName)
    {
        return array_merge(
            ‪State::getFieldNames($tableName),
            $this->‪getLocalizationModeExcludeFieldNames($tableName)
        );
    }
 
    protected function ‪getPrefixLanguageTitleFieldNames(string $tableName)
    {
        $prefixLanguageTitleFieldNames = [];
        if (empty(‪$GLOBALS['TCA'][$tableName]['columns'])) {
            return $prefixLanguageTitleFieldNames;
        }
 
        foreach (‪$GLOBALS['TCA'][$tableName]['columns'] as $fieldName => $configuration) {
            $type = $configuration['config']['type'] ?? null;
            if (
                ($configuration['l10n_mode'] ?? null) === 'prefixLangTitle'
                && ($type === 'input' || $type === 'text' || $type === 'email')
            ) {
                $prefixLanguageTitleFieldNames[] = $fieldName;
            }
        }
 
        return $prefixLanguageTitleFieldNames;
    }
 
    protected function ‪isRelationField(string $tableName, string $fieldName): bool
    {
        if (empty(‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config']['type'])) {
            return false;
        }
 
        $configuration = ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'];
 
        return ($configuration['type'] === 'group' && !empty($configuration['allowed']))
            || (
                ($configuration['type'] === 'select' || $configuration['type'] === 'category')
                && !empty($configuration['foreign_table'])
                && !empty(‪$GLOBALS['TCA'][$configuration['foreign_table']])
            )
            || $this->‪isReferenceField($tableName, $fieldName)
        ;
    }
 
    protected function ‪isReferenceField(string $tableName, string $fieldName): bool
    {
        if (empty(‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config']['type'])) {
            return false;
        }
 
        $configuration = ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'];
 
        return
            ($configuration['type'] === 'inline' || $configuration['type'] === 'file')
            && !empty($configuration['foreign_table'])
            && !empty(‪$GLOBALS['TCA'][$configuration['foreign_table']])
        ;
    }
 
    protected function ‪isApplicable(string $tableName): bool
    {
        return
            ‪State::isApplicable($tableName)
            || BackendUtility::isTableLocalizable($tableName)
                && count($this->‪getLocalizationModeExcludeFieldNames($tableName)) > 0
        ;
    }
 
    protected function ‪createRelationHandler()
    {
        $relationHandler = GeneralUtility::makeInstance(RelationHandler::class);
        $relationHandler->setWorkspaceId($this->‪backendUser->workspace);
        return $relationHandler;
    }
 
    protected function ‪getLanguageService(): ?‪LanguageService
    {
        return ‪$GLOBALS['LANG'] ?? null;
    }
}