DataMapItem.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\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
 
class ‪DataMapItem
{
    const ‪TYPE_PARENT = 'parent';
    const ‪TYPE_DIRECT_CHILD = 'directChild';
    const ‪TYPE_GRAND_CHILD = 'grandChild';
 
    const ‪SCOPE_PARENT = ‪State::STATE_PARENT;
    const ‪SCOPE_SOURCE = ‪State::STATE_SOURCE;
    const ‪SCOPE_EXCLUDE = 'exclude';
 
    protected ‪$tableName;
 
    protected ‪$id;
 
    protected ‪$suggestedValues;
 
    protected ‪$persistedValues;
 
    protected ‪$configurationFieldNames;
 
    protected ‪$new;
 
    protected ‪$type;
 
    protected ‪$state;
 
    protected ‪$language;
 
    protected ‪$parent;
 
    protected ‪$source;
 
    protected ‪$dependencies = [];
 
    public static function ‪build(
        string ‪$tableName,
        ‪$id,
        array ‪$suggestedValues,
        array ‪$persistedValues,
        array ‪$configurationFieldNames
    ) {
        $item = GeneralUtility::makeInstance(
            static::class,
            ‪$tableName,
            ‪$id,
            ‪$suggestedValues,
            ‪$persistedValues,
            ‪$configurationFieldNames
        );
 
        $item->language = (int)(‪$suggestedValues[$item->getLanguageFieldName()] ?? ‪$persistedValues[$item->getLanguageFieldName()]);
        $item->setParent(‪$suggestedValues[$item->getParentFieldName()] ?? ‪$persistedValues[$item->getParentFieldName()]);
        if ($item->getSourceFieldName() !== null) {
            $item->setSource(‪$suggestedValues[$item->getSourceFieldName()] ?? ‪$persistedValues[$item->getSourceFieldName()]);
        }
 
        return $item;
    }
 
    public function ‪__construct(
        string ‪$tableName,
        ‪$id,
        array ‪$suggestedValues,
        array ‪$persistedValues,
        array ‪$configurationFieldNames
    ) {
        $this->tableName = ‪$tableName;
        $this->id = ‪$id;
 
        $this->suggestedValues = ‪$suggestedValues;
        $this->persistedValues = ‪$persistedValues;
        $this->configurationFieldNames = ‪$configurationFieldNames;
 
        $this->new = !‪MathUtility::canBeInterpretedAsInteger(‪$id);
    }
 
    public function ‪getTableName(): string
    {
        return ‪$this->tableName;
    }
 
    public function ‪getId()
    {
        return ‪$this->id;
    }
 
    public function ‪getSuggestedValues(): array
    {
        return ‪$this->suggestedValues;
    }
 
    public function ‪getPersistedValues(): array
    {
        return ‪$this->persistedValues;
    }
 
    public function ‪getConfigurationFieldNames(): array
    {
        return ‪$this->configurationFieldNames;
    }
 
    public function ‪getLanguageFieldName(): string
    {
        return $this->configurationFieldNames['language'];
    }
 
    public function ‪getParentFieldName(): string
    {
        return $this->configurationFieldNames['parent'];
    }
 
    public function ‪getSourceFieldName()
    {
        return $this->configurationFieldNames['source'];
    }
 
    public function ‪isNew(): bool
    {
        return ‪$this->new;
    }
 
    public function ‪getType(): string
    {
        if ($this->type === null) {
            // implicit: default language, it's a parent
            if ($this->language === 0) {
                $this->type = static::TYPE_PARENT;
            } elseif (
                // implicit: having source value different to parent value, it's a 2nd or higher level translation
                $this->source !== null
                && $this->source !== $this->parent
            ) {
                $this->type = static::TYPE_GRAND_CHILD;
            } else {
                // implicit: otherwise, it's a 1st level translation
                $this->type = static::TYPE_DIRECT_CHILD;
            }
        }
        return ‪$this->type;
    }
 
    public function ‪isParentType(): bool
    {
        return $this->‪getType() === static::TYPE_PARENT;
    }
 
    public function ‪isDirectChildType(): bool
    {
        return $this->‪getType() === static::TYPE_DIRECT_CHILD;
    }
 
    public function ‪isGrandChildType(): bool
    {
        return $this->‪getType() === static::TYPE_GRAND_CHILD;
    }
 
    public function ‪getState(): ‪State
    {
        if ($this->state === null && !$this->‪isParentType()) {
            $this->state = $this->‪buildState();
        }
        return ‪$this->state;
    }
 
    public function ‪getLanguage()
    {
        return ‪$this->language;
    }
 
    public function ‪setLanguage(‪$language)
    {
        $this->language = ‪$language;
    }
 
    public function ‪getParent()
    {
        return ‪$this->parent;
    }
 
    public function ‪setParent(‪$parent)
    {
        $this->parent = $this->‪extractId(‪$parent);
    }
 
    public function ‪getSource()
    {
        return ‪$this->source;
    }
 
    public function ‪setSource(‪$source)
    {
        $this->source = $this->‪extractId(‪$source);
    }
 
    public function ‪getIdForScope($scope)
    {
        if (
            $scope === static::SCOPE_PARENT
            || $scope === static::SCOPE_EXCLUDE
        ) {
            return $this->‪getParent();
        }
        if ($scope === static::SCOPE_SOURCE) {
            return $this->‪getSource();
        }
        throw new \RuntimeException('Invalid scope', 1486325248);
    }
 
    public function ‪getDependencies(): array
    {
        return ‪$this->dependencies;
    }
 
    public function ‪setDependencies(array ‪$dependencies)
    {
        $this->dependencies = ‪$dependencies;
    }
 
    public function ‪findDependencies(string $scope)
    {
        return $this->dependencies[$scope] ?? [];
    }
 
    public function ‪getApplicableScopes()
    {
        $scopes = [];
        if (!empty($this->‪getSourceFieldName())) {
            $scopes[] = static::SCOPE_SOURCE;
        }
        $scopes[] = static::SCOPE_PARENT;
        $scopes[] = static::SCOPE_EXCLUDE;
        return $scopes;
    }
 
    protected function ‪extractId($idValue)
    {
        if (‪MathUtility::canBeInterpretedAsInteger($idValue)) {
            return $idValue;
        }
        if (strpos($idValue, 'NEW') === 0) {
            return $idValue;
        }
        // @todo Handle if $tableName does not match $this->tableName
        [‪$tableName, ‪$id] = ‪BackendUtility::splitTable_Uid($idValue);
        return ‪$id;
    }
 
    protected function ‪buildState()
    {
        // build from persisted states
        if (!$this->‪isNew()) {
            ‪$state = ‪State::fromJSON(
                $this->tableName,
                $this->persistedValues['l10n_state'] ?? null
            );
        } elseif (is_string($this->suggestedValues['l10n_state'] ?? null)) {
            // use provided states for a new and copied element
            ‪$state = ‪State::fromJSON(
                $this->tableName,
                $this->suggestedValues['l10n_state']
            );
        } else {
            // provide the default states
            ‪$state = ‪State::create($this->tableName);
        }
        // switch "custom" to "source" state for 2nd level translations
        if ($this->‪isNew() && $this->‪isGrandChildType()) {
            ‪$state->‪updateStates(‪State::STATE_CUSTOM, ‪State::STATE_SOURCE);
        }
        // apply any provided updates to the states
        if (is_array($this->suggestedValues['l10n_state'] ?? null)) {
            ‪$state->‪update(
                $this->suggestedValues['l10n_state'] ?? []
            );
        }
        return ‪$state;
    }
}