State.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\Core\DataHandling\Localization;
 
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪State
{
    const ‪STATE_CUSTOM = 'custom';
    const ‪STATE_PARENT = 'parent';
    const ‪STATE_SOURCE = 'source';
 
    public static function ‪create(string ‪$tableName)
    {
        if (!static::isApplicable(‪$tableName)) {
            return null;
        }
 
        return GeneralUtility::makeInstance(
            static::class,
            ‪$tableName
        );
    }
 
    public static function ‪fromJSON(string ‪$tableName, string $json = null)
    {
        if (!static::isApplicable(‪$tableName)) {
            return null;
        }
 
        ‪$states = json_decode($json ?? '', true);
        return GeneralUtility::makeInstance(
            static::class,
            ‪$tableName,
            ‪$states ?? []
        );
    }
 
    public static function ‪isApplicable(string ‪$tableName)
    {
        return
            static::hasColumns(‪$tableName)
            && static::hasLanguageFieldName(‪$tableName)
            && static::hasTranslationParentFieldName(‪$tableName)
            && count(static::getFieldNames(‪$tableName)) > 0
        ;
    }
 
    public static function ‪getFieldNames(string ‪$tableName)
    {
        return array_keys(
            array_filter(
                ‪$GLOBALS['TCA'][‪$tableName]['columns'] ?? [],
                function (array $fieldConfiguration) {
                    return !empty(
                        $fieldConfiguration['config']
                            ['behaviour']['allowLanguageSynchronization']
                    );
                }
            )
        );
    }
 
    protected static function ‪hasColumns(string ‪$tableName)
    {
        return
            !empty(‪$GLOBALS['TCA'][‪$tableName]['columns'])
            && is_array(‪$GLOBALS['TCA'][‪$tableName]['columns'])
        ;
    }
 
    protected static function ‪hasLanguageFieldName(string ‪$tableName)
    {
        return !empty(‪$GLOBALS['TCA'][‪$tableName]['ctrl']['languageField']);
    }
 
    protected static function ‪hasTranslationParentFieldName(string ‪$tableName)
    {
        return !empty(‪$GLOBALS['TCA'][‪$tableName]['ctrl']['transOrigPointerField']);
    }
 
    protected ‪$tableName;
 
    protected ‪$states;
 
    protected ‪$originalStates;
 
    protected ‪$validStates = [
        ‪self::STATE_CUSTOM,
        ‪self::STATE_SOURCE,
        ‪self::STATE_PARENT,
    ];
 
    public function ‪__construct(string ‪$tableName, array ‪$states = [])
    {
        $this->tableName = ‪$tableName;
        $this->states = ‪$states;
        $this->originalStates = ‪$states;
 
        $this->states = $this->‪enrich(
            $this->‪sanitize(‪$states)
        );
    }
 
    public function ‪update(array ‪$states)
    {
        $this->states = array_merge(
            $this->states,
            $this->‪sanitize($states)
        );
    }
 
    public function ‪updateStates(string $currentState, string $targetState)
    {
        ‪$states = [];
        foreach ($this->‪filterFieldNames($currentState) as $fieldName) {
            ‪$states[$fieldName] = $targetState;
        }
        if (!empty(‪$states)) {
            $this->‪update(‪$states);
        }
    }
 
    public function ‪export()
    {
        if (empty($this->states)) {
            return null;
        }
        return json_encode($this->states);
    }
 
    public function ‪toArray(): array
    {
        return $this->states ?? [];
    }
 
    public function ‪getModifiedFieldNames()
    {
        return array_keys(
            array_diff_assoc(
                $this->states,
                $this->originalStates
            )
        );
    }
 
    public function ‪isModified()
    {
        return !empty($this->‪getModifiedFieldNames());
    }
 
    public function ‪isUndefined(string $fieldName)
    {
        return !isset($this->states[$fieldName]);
    }
 
    public function ‪isCustomState(string $fieldName)
    {
        return ($this->states[$fieldName] ?? null) === static::STATE_CUSTOM;
    }
 
    public function ‪isParentState(string $fieldName)
    {
        return ($this->states[$fieldName] ?? null) === static::STATE_PARENT;
    }
 
    public function ‪isSourceState(string $fieldName)
    {
        return ($this->states[$fieldName] ?? null) === static::STATE_SOURCE;
    }
 
    public function ‪getState(string $fieldName)
    {
        return $this->states[$fieldName] ?? null;
    }
 
    public function ‪filterFieldNames(string $desiredState, bool $modified = false)
    {
        if (!$modified) {
            $fieldNames = array_keys($this->states);
        } else {
            $fieldNames = $this->‪getModifiedFieldNames();
        }
        return array_filter(
            $fieldNames,
            function ($fieldName) use ($desiredState) {
                return $this->states[$fieldName] === $desiredState;
            }
        );
    }
 
    protected function ‪sanitize(array ‪$states)
    {
        $fieldNames = static::getFieldNames($this->tableName);
        return array_intersect_key(
            ‪$states,
            array_combine($fieldNames, $fieldNames)
        );
    }
 
    protected function ‪enrich(array ‪$states)
    {
        foreach (static::getFieldNames($this->tableName) as $fieldName) {
            $isValid = in_array(
                ‪$states[$fieldName] ?? null,
                $this->validStates,
                true
            );
            if ($isValid) {
                continue;
            }
            ‪$states[$fieldName] = static::STATE_PARENT;
        }
        return ‪$states;
    }
}