CommandMap.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\Workspaces\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;
 
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 array ‪$commandMap = [];
    protected int ‪$workspace;
    protected array ‪$scopes = [];
    protected ?‪ElementEntityProcessor ‪$elementEntityProcessor;
 
    public function ‪__construct(array ‪$commandMap, int ‪$workspace)
    {
        $this->set(‪$commandMap);
        $this->‪setWorkspace($workspace);
        $this->‪constructScopes();
    }
 
    public function get(): array
    {
        return ‪$this->commandMap;
    }
 
    public function set(array ‪$commandMap): self
    {
        $this->commandMap = ‪$commandMap;
        return $this;
    }
 
    public function ‪setWorkspace(int ‪$workspace): void
    {
        $this->workspace = ‪$workspace;
    }
 
    public function ‪getWorkspace(): int
    {
        return ‪$this->workspace;
    }
 
    protected function ‪getElementEntityProcessor(): ‪ElementEntityProcessor
    {
        if (!isset($this->elementEntityProcessor)) {
            $this->elementEntityProcessor = GeneralUtility::makeInstance(ElementEntityProcessor::class);
            $this->elementEntityProcessor->setWorkspace($this->‪getWorkspace());
        }
        return ‪$this->elementEntityProcessor;
    }
 
    public function ‪process(): self
    {
        $this->‪resolveWorkspacesSwapDependencies();
        $this->‪resolveWorkspacesSetStageDependencies();
        $this->‪resolveWorkspacesClearDependencies();
        return $this;
    }
 
    protected function ‪resolveWorkspacesSwapDependencies(): void
    {
        $scope = ‪self::SCOPE_WorkspacesSwap;
        $dependency = $this->‪getDependencyUtility($scope);
        $arguments = [$dependency];
        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->‪addWorkspacesSwapElements(...array_merge($arguments, [$table, $liveId, $properties]));
                        }
                    }
                }
            }
        }
        $this->‪applyWorkspacesDependencies($dependency, $scope);
    }
 
    protected function ‪addWorkspacesSwapElements(‪DependencyResolver $dependency, string $table, int $liveId, array $properties): void
    {
        $dependency->‪addElement($table, (int)$properties['swapWith'], ['liveId' => $liveId, 'properties' => $properties]);
    }
 
    protected function ‪invokeWorkspacesSetStageItems(string $callbackMethod, array $arguments = []): void
    {
        // 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(): void
    {
        $scope = ‪self::SCOPE_WorkspacesSetStage;
        $dependency = $this->‪getDependencyUtility($scope);
        $this->‪invokeWorkspacesSetStageItems('explodeSetStage');
        $this->‪invokeWorkspacesSetStageItems('addWorkspacesSetStageElements', [$dependency]);
        $this->‪applyWorkspacesDependencies($dependency, $scope);
    }
 
    protected function ‪addWorkspacesSetStageElements(‪DependencyResolver $dependency, string $table, int $versionId, array $properties): void
    {
        $dependency->‪addElement($table, $versionId, ['versionId' => $versionId, 'properties' => $properties]);
    }
 
    protected function ‪resolveWorkspacesClearDependencies(): void
    {
        $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(string $table, string|int $versionIdList, array $properties): void
    {
        $extractedCommandMap = [];
        $versionIds = ‪GeneralUtility::trimExplode(',', (string)$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, string $scope): void
    {
        $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, string $scope): void
    {
        $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): void
    {
        ArrayUtility::mergeRecursiveWithOverrule(‪$commandMap, $this->commandMap);
        $this->commandMap = ‪$commandMap;
    }
 
    protected function ‪mergeToBottom(array ‪$commandMap): void
    {
        ArrayUtility::mergeRecursiveWithOverrule($this->commandMap, ‪$commandMap);
    }
 
    protected function remove(string $table, int|string $id, string $command = null): void
    {
        if (is_string($command)) {
            unset($this->commandMap[$table][$id][$command]);
        } else {
            unset($this->commandMap[$table][$id]);
        }
    }
 
    protected function ‪getElementLiveIdCallback(‪ElementEntity $element): int
    {
        return $element->‪getDataValue('liveId');
    }
 
    protected function ‪getElementIdCallback(‪ElementEntity $element): int
    {
        return $element->‪getId();
    }
 
    protected function ‪getElementSwapPropertiesCallback(‪ElementEntity $element): array
    {
        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): array
    {
        $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): array
    {
        return $this->‪getCommonSetStagePropertiesCallback($element);
    }
 
    protected function ‪getCommonSetStagePropertiesCallback(‪ElementEntity $element): array
    {
        $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(string $scope): ‪DependencyResolver
    {
        $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(): void
    {
        $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(string $scope, string $key): null|bool|string
    {
        if (!isset($this->scopes[$scope])) {
            throw new \RuntimeException('Scope "' . $scope . '" is not defined.', 1289342187);
        }
        return $this->scopes[$scope][$key];
    }
 
    protected function ‪getDependencyCallback(string $method, array $targetArguments = []): ‪EventCallback
    {
        return GeneralUtility::makeInstance(
            EventCallback::class,
            $this->‪getElementEntityProcessor(),
            $method,
            $targetArguments
        );
    }
 
    protected function ‪processCallback(string $method, array $callbackArguments): mixed
    {
        return $this->$method(...$callbackArguments);
    }
}