9.5/_command_map_8php_source.html

<?php

namespace ‪TYPO3\CMS\Workspaces\DataHandler;


/*

 * 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!

 */


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

{

    const ‪SCOPE_WorkspacesSwap = 'SCOPE_WorkspacesSwap';

    const ‪SCOPE_WorkspacesSetStage = 'SCOPE_WorkspacesSetStage';

    const ‪SCOPE_WorkspacesClear = 'SCOPE_WorkspacesClear';

    const ‪KEY_GetElementPropertiesCallback = 'KEY_GetElementPropertiesCallback';

    const ‪KEY_GetCommonPropertiesCallback = 'KEY_GetCommonPropertiesCallback';

    const ‪KEY_ElementConstructCallback = 'KEY_EventConstructCallback';

    const ‪KEY_ElementCreateChildReferenceCallback = 'KEY_ElementCreateChildReferenceCallback';

    const ‪KEY_ElementCreateParentReferenceCallback = 'KEY_ElementCreateParentReferenceCallback';

    const ‪KEY_UpdateGetIdCallback = 'KEY_UpdateGetIdCallback';

    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']) && $properties['action'] === 'swap') {

                        if (isset($properties['swapWith']) && ‪MathUtility::canBeInterpretedAsInteger($properties['swapWith'])) {

                            call_user_func_array([$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, $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'])) {

                            call_user_func_array([$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) {

                $workspaceRecord = ‪BackendUtility::getRecord($table, $versionIds[0], '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['swapIntoWS'])) {

            $commonSwapProperties['swapIntoWS'] = $elementProperties['swapIntoWS'];

        }

        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 functons 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 functons 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 functons 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 call_user_func_array([$this, $method], $callbackArguments);

    }

}