DataMapItem.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\DataHandling\Localization;

/*
 * 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\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 getFromTableName(): string
    {
        if ($this->tableName === 'pages_language_overlay') {
            return 'pages';
        }
        return $this->tableName;
    }

    public function getForTableName(): string
    {
        if ($this->tableName === 'pages') {
            return 'pages_language_overlay';
        }
        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
        list($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;
    }
}