CommandMap.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\Workspaces\DataHandler;
 
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Workspaces\Dependency\DependencyResolver;
use ‪TYPO3\CMS\Workspaces\Dependency\ElementEntity;
use ‪TYPO3\CMS\Workspaces\Dependency\ElementEntityProcessor;
use ‪TYPO3\CMS\Workspaces\Dependency\EventCallback;
use ‪TYPO3\CMS\Workspaces\Hook\DataHandlerHook;
 
class ‪CommandMap
{
    public const ‪SCOPE_WorkspacesSwap = 'SCOPE_WorkspacesSwap';
    public const ‪SCOPE_WorkspacesSetStage = 'SCOPE_WorkspacesSetStage';
    public const ‪SCOPE_WorkspacesClear = 'SCOPE_WorkspacesClear';
    public const ‪KEY_GetElementPropertiesCallback = 'KEY_GetElementPropertiesCallback';
    public const ‪KEY_GetCommonPropertiesCallback = 'KEY_GetCommonPropertiesCallback';
    public const ‪KEY_ElementConstructCallback = 'KEY_EventConstructCallback';
    public const ‪KEY_ElementCreateChildReferenceCallback = 'KEY_ElementCreateChildReferenceCallback';
    public const ‪KEY_ElementCreateParentReferenceCallback = 'KEY_ElementCreateParentReferenceCallback';
    public const ‪KEY_UpdateGetIdCallback = 'KEY_UpdateGetIdCallback';
    public const ‪KEY_TransformDependentElementsToUseLiveId = 'KEY_TransformDependentElementsToUseLiveId';
 
    protected ‪$parent;
 
    protected ‪$tceMain;
 
    protected ‪$commandMap = [];
 
    protected ‪$workspace;
 
    protected ‪$workspacesSwapMode;
 
    protected ‪$workspacesChangeStageMode;
 
    protected ‪$scopes;
 
    protected ‪$elementEntityProcessor;
 
    public function ‪__construct(‪DataHandlerHook ‪$parent, ‪DataHandler ‪$tceMain, array ‪$commandMap, ‪$workspace)
    {
        $this->‪setParent($parent);
        $this->‪setTceMain($tceMain);
        $this->set(‪$commandMap);
        $this->‪setWorkspace(‪$workspace);
        $this->‪setWorkspacesSwapMode($this->‪getTceMain()->BE_USER->getTSConfig()['options.']['workspaces.']['swapMode'] ?? '');
        $this->‪setWorkspacesChangeStageMode($this->‪getTceMain()->BE_USER->getTSConfig()['options.']['workspaces.']['changeStageMode'] ?? '');
        $this->‪constructScopes();
    }
 
    public function get()
    {
        return ‪$this->commandMap;
    }
 
    public function set(array ‪$commandMap)
    {
        $this->commandMap = ‪$commandMap;
        return $this;
    }
 
    public function ‪getParent()
    {
        return ‪$this->parent;
    }
 
    public function ‪setParent(‪DataHandlerHook ‪$parent)
    {
        $this->parent = ‪$parent;
        return $this;
    }
 
    public function ‪getTceMain()
    {
        return ‪$this->tceMain;
    }
 
    public function ‪setTceMain(‪DataHandler ‪$tceMain)
    {
        $this->tceMain = ‪$tceMain;
        return $this;
    }
 
    public function ‪setWorkspace(‪$workspace)
    {
        $this->workspace = (int)‪$workspace;
    }
 
    public function ‪getWorkspace()
    {
        return ‪$this->workspace;
    }
 
    public function ‪setWorkspacesSwapMode(‪$workspacesSwapMode)
    {
        $this->workspacesSwapMode = (string)‪$workspacesSwapMode;
        return $this;
    }
 
    public function ‪setWorkspacesChangeStageMode(‪$workspacesChangeStageMode)
    {
        $this->workspacesChangeStageMode = (string)‪$workspacesChangeStageMode;
        return $this;
    }
 
    protected function ‪getElementEntityProcessor()
    {
        if (!isset($this->elementEntityProcessor)) {
            $this->elementEntityProcessor = GeneralUtility::makeInstance(ElementEntityProcessor::class);
            $this->elementEntityProcessor->setWorkspace($this->‪getWorkspace());
        }
        return ‪$this->elementEntityProcessor;
    }
 
    public function ‪process()
    {
        $this->‪resolveWorkspacesSwapDependencies();
        $this->‪resolveWorkspacesSetStageDependencies();
        $this->‪resolveWorkspacesClearDependencies();
        return $this;
    }
 
    protected function ‪invokeWorkspacesSwapItems($callbackMethod, array $arguments = [])
    {
        // Traverses the cmd[] array and fetches the accordant actions:
        foreach ($this->commandMap as $table => $liveIdCollection) {
            foreach ($liveIdCollection as $liveId => $commandCollection) {
                foreach ($commandCollection as $command => $properties) {
                    if ($command === 'version' && isset($properties['action']) && in_array($properties['action'], ['publish', 'swap'], true)) {
                        if (isset($properties['swapWith']) && ‪MathUtility::canBeInterpretedAsInteger($properties['swapWith'])) {
                            $this->$callbackMethod(...array_merge($arguments, [$table, $liveId, $properties]));
                        }
                    }
                }
            }
        }
    }
 
    protected function ‪resolveWorkspacesSwapDependencies()
    {
        $scope = ‪self::SCOPE_WorkspacesSwap;
        $dependency = $this->‪getDependencyUtility($scope);
        if ($this->workspacesSwapMode === 'any' || $this->workspacesSwapMode === 'pages') {
            $this->‪invokeWorkspacesSwapItems('applyWorkspacesSwapBehaviour');
        }
        $this->‪invokeWorkspacesSwapItems('addWorkspacesSwapElements', [$dependency]);
        $this->‪applyWorkspacesDependencies($dependency, $scope);
    }
 
    protected function ‪applyWorkspacesSwapBehaviour($table, $liveId, array $properties)
    {
        $extendedCommandMap = [];
        $elementList = [];
        // Fetch accordant elements if the swapMode is 'any' or 'pages':
        if ($this->workspacesSwapMode === 'any' || $this->workspacesSwapMode === 'pages' && $table === 'pages') {
            $elementList = $this->‪getParent()->‪findPageElementsForVersionSwap($table, $liveId, $properties['swapWith']);
        }
        foreach ($elementList as $elementTable => $elementIdArray) {
            foreach ($elementIdArray as $elementIds) {
                $extendedCommandMap[$elementTable][$elementIds[0]]['version'] = array_merge($properties, ['swapWith' => $elementIds[1]]);
            }
        }
        if (!empty($elementList)) {
            $this->remove($table, (string)$liveId, 'version');
            $this->‪mergeToBottom($extendedCommandMap);
        }
    }
 
    protected function ‪addWorkspacesSwapElements(‪DependencyResolver $dependency, $table, $liveId, array $properties)
    {
        $elementList = [];
        // Fetch accordant elements if the swapMode is 'any' or 'pages':
        if ($this->workspacesSwapMode === 'any' || $this->workspacesSwapMode === 'pages' && $table === 'pages') {
            $elementList = $this->‪getParent()->‪findPageElementsForVersionSwap($table, $liveId, $properties['swapWith']);
        }
        foreach ($elementList as $elementTable => $elementIdArray) {
            foreach ($elementIdArray as $elementIds) {
                $dependency->‪addElement($elementTable, $elementIds[1], ['liveId' => $elementIds[0], 'properties' => array_merge($properties, ['swapWith' => $elementIds[1]])]);
            }
        }
        if (empty($elementList)) {
            $dependency->‪addElement($table, $properties['swapWith'], ['liveId' => $liveId, 'properties' => $properties]);
        }
    }
 
    protected function ‪invokeWorkspacesSetStageItems($callbackMethod, array $arguments = [])
    {
        // Traverses the cmd[] array and fetches the accordant actions:
        foreach ($this->commandMap as $table => $versionIdCollection) {
            foreach ($versionIdCollection as $versionIdList => $commandCollection) {
                foreach ($commandCollection as $command => $properties) {
                    if ($command === 'version' && isset($properties['action']) && $properties['action'] === 'setStage') {
                        if (isset($properties['stageId']) && ‪MathUtility::canBeInterpretedAsInteger($properties['stageId'])) {
                            $this->$callbackMethod(...array_merge($arguments, [$table, $versionIdList, $properties]));
                        }
                    }
                }
            }
        }
    }
 
    protected function ‪resolveWorkspacesSetStageDependencies()
    {
        $scope = ‪self::SCOPE_WorkspacesSetStage;
        $dependency = $this->‪getDependencyUtility($scope);
        if ($this->workspacesChangeStageMode === 'any' || $this->workspacesChangeStageMode === 'pages') {
            $this->‪invokeWorkspacesSetStageItems('applyWorkspacesSetStageBehaviour');
        }
        $this->‪invokeWorkspacesSetStageItems('explodeSetStage');
        $this->‪invokeWorkspacesSetStageItems('addWorkspacesSetStageElements', [$dependency]);
        $this->‪applyWorkspacesDependencies($dependency, $scope);
    }
 
    protected function ‪applyWorkspacesSetStageBehaviour($table, $versionIdList, array $properties)
    {
        $extendedCommandMap = [];
        $versionIds = ‪GeneralUtility::trimExplode(',', $versionIdList, true);
        $elementList = [$table => $versionIds];
        if ($this->workspacesChangeStageMode === 'any' || $this->workspacesChangeStageMode === 'pages') {
            if (count($versionIds) === 1) {
                $uid = (int)$versionIds[0];
                $workspaceRecord = BackendUtility::getRecord($table, $uid, 't3ver_wsid');
                $workspaceId = $workspaceRecord['t3ver_wsid'];
            } else {
                $workspaceId = $this->‪getWorkspace();
            }
            if ($table === 'pages') {
                // Find all elements from the same ws to change stage
                $livePageIds = $versionIds;
                $this->‪getParent()->‪findRealPageIds($livePageIds);
                $this->‪getParent()->‪findPageElementsForVersionStageChange($livePageIds, $workspaceId, $elementList);
            } elseif ($this->workspacesChangeStageMode === 'any') {
                // Find page to change stage:
                $pageIdList = [];
                $this->‪getParent()->‪findPageIdsForVersionStateChange($table, $versionIds, $workspaceId, $pageIdList, $elementList);
                // Find other elements from the same ws to change stage:
                $this->‪getParent()->‪findPageElementsForVersionStageChange($pageIdList, $workspaceId, $elementList);
            }
        }
        foreach ($elementList as $elementTable => $elementIds) {
            foreach ($elementIds as $elementId) {
                $extendedCommandMap[$elementTable][$elementId]['version'] = $properties;
            }
        }
        foreach ($versionIds as $versionId) {
            $this->remove($table, $versionId, 'version');
        }
        $this->‪mergeToBottom($extendedCommandMap);
    }
 
    protected function ‪addWorkspacesSetStageElements(‪DependencyResolver $dependency, $table, $versionId, array $properties)
    {
        $dependency->‪addElement($table, $versionId, ['versionId' => $versionId, 'properties' => $properties]);
    }
 
    protected function ‪resolveWorkspacesClearDependencies()
    {
        $scope = ‪self::SCOPE_WorkspacesClear;
        $dependency = $this->‪getDependencyUtility($scope);
        // Traverses the cmd[] array and fetches the accordant actions:
        foreach ($this->commandMap as $table => $versionIdCollection) {
            foreach ($versionIdCollection as $versionId => $commandCollection) {
                foreach ($commandCollection as $command => $properties) {
                    if ($command === 'version' && isset($properties['action']) && ($properties['action'] === 'clearWSID' || $properties['action'] === 'flush')) {
                        $dependency->‪addElement($table, $versionId, ['versionId' => $versionId, 'properties' => $properties]);
                    }
                }
            }
        }
        $this->‪applyWorkspacesDependencies($dependency, $scope);
    }
 
    protected function ‪explodeSetStage($table, $versionIdList, array $properties)
    {
        $extractedCommandMap = [];
        $versionIds = ‪GeneralUtility::trimExplode(',', $versionIdList, true);
        if (count($versionIds) > 1) {
            foreach ($versionIds as $versionId) {
                if (isset($this->commandMap[$table][$versionId]['version'])) {
                    throw new \RuntimeException('Command map for [' . $table . '][' . $versionId . '][version] was already set.', 1289391048);
                }
                $extractedCommandMap[$table][$versionId]['version'] = $properties;
                $this->remove($table, $versionId, 'version');
            }
            $this->‪mergeToBottom($extractedCommandMap);
        }
    }
 
    protected function ‪applyWorkspacesDependencies(‪DependencyResolver $dependency, $scope)
    {
        $transformDependentElementsToUseLiveId = $this->‪getScopeData($scope, self::KEY_TransformDependentElementsToUseLiveId);
        $elementsToBeVersioned = $dependency->‪getElements();
        // Use the uid of the live record instead of the workspace record:
        if ($transformDependentElementsToUseLiveId) {
            $elementsToBeVersioned = $this->‪getElementEntityProcessor()->‪transformDependentElementsToUseLiveId($elementsToBeVersioned);
        }
        $outerMostParents = $dependency->‪getOuterMostParents();
        foreach ($outerMostParents as $outerMostParent) {
            $dependentElements = $dependency->‪getNestedElements($outerMostParent);
            if ($transformDependentElementsToUseLiveId) {
                $dependentElements = $this->‪getElementEntityProcessor()->‪transformDependentElementsToUseLiveId($dependentElements);
            }
            // Gets the difference (intersection) between elements that were submitted by the user
            // and the evaluation of all dependent records that should be used for this action instead:
            $intersectingElements = array_intersect_key($dependentElements, $elementsToBeVersioned);
            if (!empty($intersectingElements)) {
                $this->‪update(current($intersectingElements), $dependentElements, $scope);
            }
        }
    }
 
    protected function ‪update(‪ElementEntity $intersectingElement, array $elements, $scope)
    {
        $orderedCommandMap = [];
        $commonProperties = [];
        if ($this->‪getScopeData($scope, self::KEY_GetCommonPropertiesCallback)) {
            $commonProperties = $this->‪processCallback($this->‪getScopeData($scope, self::KEY_GetCommonPropertiesCallback), [$intersectingElement]);
        }
        foreach ($elements as $element) {
            $table = $element->getTable();
            $id = $this->‪processCallback($this->‪getScopeData($scope, self::KEY_UpdateGetIdCallback), [$element]);
            $this->remove($table, $id, 'version');
            if ($element->isInvalid()) {
                continue;
            }
            $orderedCommandMap[$table][$id]['version'] = $commonProperties;
            if ($this->‪getScopeData($scope, self::KEY_GetElementPropertiesCallback)) {
                $orderedCommandMap[$table][$id]['version'] = array_merge($commonProperties, $this->‪processCallback($this->‪getScopeData($scope, self::KEY_GetElementPropertiesCallback), [$element]));
            }
        }
        // Ensure that ordered command map is on top of the command map:
        $this->‪mergeToTop($orderedCommandMap);
    }
 
    protected function ‪mergeToTop(array ‪$commandMap)
    {
        ‪ArrayUtility::mergeRecursiveWithOverrule(‪$commandMap, $this->commandMap);
        $this->commandMap = ‪$commandMap;
    }
 
    protected function ‪mergeToBottom(array ‪$commandMap)
    {
        ‪ArrayUtility::mergeRecursiveWithOverrule($this->commandMap, ‪$commandMap);
    }
 
    protected function remove($table, $id, $command = null)
    {
        if (is_string($command)) {
            unset($this->commandMap[$table][$id][$command]);
        } else {
            unset($this->commandMap[$table][$id]);
        }
    }
 
    protected function ‪getElementLiveIdCallback(‪ElementEntity $element)
    {
        return $element->‪getDataValue('liveId');
    }
 
    protected function ‪getElementIdCallback(‪ElementEntity $element)
    {
        return $element->‪getId();
    }
 
    protected function ‪getElementSwapPropertiesCallback(‪ElementEntity $element)
    {
        return [
            'swapWith' => $element->‪getId(),
        ];
    }
 
    protected function ‪getCommonClearPropertiesCallback(‪ElementEntity $element)
    {
        $commonSwapProperties = [];
        $elementProperties = $element->‪getDataValue('properties');
        if (isset($elementProperties['action'])) {
            $commonSwapProperties['action'] = $elementProperties['action'];
        }
        return $commonSwapProperties;
    }
 
    protected function ‪getCommonSwapPropertiesCallback(‪ElementEntity $element)
    {
        $commonSwapProperties = [];
        $elementProperties = $element->‪getDataValue('properties');
        if (isset($elementProperties['action'])) {
            $commonSwapProperties['action'] = $elementProperties['action'];
        }
        if (isset($elementProperties['comment'])) {
            $commonSwapProperties['comment'] = $elementProperties['comment'];
        }
        if (isset($elementProperties['notificationAlternativeRecipients'])) {
            $commonSwapProperties['notificationAlternativeRecipients'] = $elementProperties['notificationAlternativeRecipients'];
        }
 
        return $commonSwapProperties;
    }
 
    protected function ‪getElementSetStagePropertiesCallback(‪ElementEntity $element)
    {
        return $this->‪getCommonSetStagePropertiesCallback($element);
    }
 
    protected function ‪getCommonSetStagePropertiesCallback(‪ElementEntity $element)
    {
        $commonSetStageProperties = [];
        $elementProperties = $element->‪getDataValue('properties');
        if (isset($elementProperties['stageId'])) {
            $commonSetStageProperties['stageId'] = $elementProperties['stageId'];
        }
        if (isset($elementProperties['comment'])) {
            $commonSetStageProperties['comment'] = $elementProperties['comment'];
        }
        if (isset($elementProperties['action'])) {
            $commonSetStageProperties['action'] = $elementProperties['action'];
        }
        if (isset($elementProperties['notificationAlternativeRecipients'])) {
            $commonSetStageProperties['notificationAlternativeRecipients'] = $elementProperties['notificationAlternativeRecipients'];
        }
        return $commonSetStageProperties;
    }
 
    protected function ‪getDependencyUtility($scope)
    {
        $dependency = GeneralUtility::makeInstance(DependencyResolver::class);
        $dependency->‪setWorkspace($this->‪getWorkspace());
        $dependency->‪setOuterMostParentsRequireReferences(true);
        if ($this->‪getScopeData($scope, self::KEY_ElementConstructCallback)) {
            $dependency->‪setEventCallback(‪ElementEntity::EVENT_Construct, $this->‪getDependencyCallback($this->‪getScopeData($scope, self::KEY_ElementConstructCallback)));
        }
        if ($this->‪getScopeData($scope, self::KEY_ElementCreateChildReferenceCallback)) {
            $dependency->‪setEventCallback(‪ElementEntity::EVENT_CreateChildReference, $this->‪getDependencyCallback($this->‪getScopeData($scope, self::KEY_ElementCreateChildReferenceCallback)));
        }
        if ($this->‪getScopeData($scope, self::KEY_ElementCreateParentReferenceCallback)) {
            $dependency->‪setEventCallback(‪ElementEntity::EVENT_CreateParentReference, $this->‪getDependencyCallback($this->‪getScopeData($scope, self::KEY_ElementCreateParentReferenceCallback)));
        }
        return $dependency;
    }
 
    protected function ‪constructScopes()
    {
        $this->scopes = [
            // settings for publishing and swapping:
            self::SCOPE_WorkspacesSwap => [
                // callback functions used to modify the commandMap
                // + element properties are specific for each element
                // + common properties are the same for all elements
                self::KEY_GetElementPropertiesCallback => 'getElementSwapPropertiesCallback',
                self::KEY_GetCommonPropertiesCallback => 'getCommonSwapPropertiesCallback',
                // callback function used, when a new element to be checked is added
                self::KEY_ElementConstructCallback => 'createNewDependentElementCallback',
                // callback function used to determine whether an element is a valid child or parent reference (e.g. IRRE)
                self::KEY_ElementCreateChildReferenceCallback => 'createNewDependentElementChildReferenceCallback',
                self::KEY_ElementCreateParentReferenceCallback => 'createNewDependentElementParentReferenceCallback',
                // callback function used to fetch the correct record uid on modifying the commandMap
                self::KEY_UpdateGetIdCallback => 'getElementLiveIdCallback',
                // setting whether to use the uid of the live record instead of the workspace record
                self::KEY_TransformDependentElementsToUseLiveId => true,
            ],
            // settings for modifying the stage:
            self::SCOPE_WorkspacesSetStage => [
                // callback functions used to modify the commandMap
                // + element properties are specific for each element
                // + common properties are the same for all elements
                self::KEY_GetElementPropertiesCallback => 'getElementSetStagePropertiesCallback',
                self::KEY_GetCommonPropertiesCallback => 'getCommonSetStagePropertiesCallback',
                // callback function used, when a new element to be checked is added
                self::KEY_ElementConstructCallback => null,
                // callback function used to determine whether an element is a valid child or parent reference (e.g. IRRE)
                self::KEY_ElementCreateChildReferenceCallback => 'createNewDependentElementChildReferenceCallback',
                self::KEY_ElementCreateParentReferenceCallback => 'createNewDependentElementParentReferenceCallback',
                // callback function used to fetch the correct record uid on modifying the commandMap
                self::KEY_UpdateGetIdCallback => 'getElementIdCallback',
                // setting whether to use the uid of the live record instead of the workspace record
                self::KEY_TransformDependentElementsToUseLiveId => false,
            ],
            // settings for clearing and flushing:
            self::SCOPE_WorkspacesClear => [
                // callback functions used to modify the commandMap
                // + element properties are specific for each element
                // + common properties are the same for all elements
                self::KEY_GetElementPropertiesCallback => null,
                self::KEY_GetCommonPropertiesCallback => 'getCommonClearPropertiesCallback',
                // callback function used, when a new element to be checked is added
                self::KEY_ElementConstructCallback => null,
                // callback function used to determine whether an element is a valid child or parent reference (e.g. IRRE)
                self::KEY_ElementCreateChildReferenceCallback => 'createClearDependentElementChildReferenceCallback',
                self::KEY_ElementCreateParentReferenceCallback => 'createClearDependentElementParentReferenceCallback',
                // callback function used to fetch the correct record uid on modifying the commandMap
                self::KEY_UpdateGetIdCallback => 'getElementIdCallback',
                // setting whether to use the uid of the live record instead of the workspace record
                self::KEY_TransformDependentElementsToUseLiveId => false,
            ],
        ];
    }
 
    protected function ‪getScopeData($scope, $key)
    {
        if (!isset($this->scopes[$scope])) {
            throw new \RuntimeException('Scope "' . $scope . '" is not defined.', 1289342187);
        }
        return $this->scopes[$scope][$key];
    }
 
    protected function ‪getDependencyCallback($method, array $targetArguments = [])
    {
        return GeneralUtility::makeInstance(
            EventCallback::class,
            $this->‪getElementEntityProcessor(),
            $method,
            $targetArguments
        );
    }
 
    protected function ‪processCallback($method, array $callbackArguments)
    {
        return $this->$method(...$callbackArguments);
    }
}