AbstractRenderable.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!
 */
 
/*
 * Inspired by and partially taken from the Neos.Form package (www.neos.io)
 */
 
namespace ‪TYPO3\CMS\Form\Domain\Model\Renderable;
 
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
use ‪TYPO3\CMS\Form\Domain\Model\Exception\FormDefinitionConsistencyException;
use ‪TYPO3\CMS\Form\Domain\Model\Exception\ValidatorPresetNotFoundException;
use ‪TYPO3\CMS\Form\Domain\Model\FormDefinition;
 
abstract class ‪AbstractRenderable implements ‪RenderableInterface, ‪VariableRenderableInterface
{
 
    protected ‪$type;
 
    protected ‪$identifier;
 
    protected ‪$parentRenderable;
 
    protected ‪$label = '';
 
    protected ‪$renderingOptions = [];
 
    protected ‪$index = 0;
 
    protected ‪$templateName = '';
 
    protected ‪$variants = [];
 
    public function ‪getType(): string
    {
        return ‪$this->type;
    }
 
    public function ‪getIdentifier(): string
    {
        return ‪$this->identifier;
    }
 
    public function ‪setIdentifier(string ‪$identifier)
    {
        $this->identifier = ‪$identifier;
    }
 
    public function ‪setOptions(array $options, bool $resetValidators = false)
    {
        if (isset($options['label'])) {
            $this->‪setLabel($options['label']);
        }
 
        if (isset($options['defaultValue'])) {
            $this->‪setDefaultValue($options['defaultValue']);
        }
 
        if (isset($options['properties'])) {
            foreach ($options['properties'] as $key => $value) {
                $this->‪setProperty($key, $value);
            }
        }
 
        if (isset($options['renderingOptions'])) {
            foreach ($options['renderingOptions'] as $key => $value) {
                $this->‪setRenderingOption($key, $value);
            }
        }
 
        if (isset($options['validators'])) {
            $runtimeCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('runtime');
            $configurationHashes = $runtimeCache->get('formAbstractRenderableConfigurationHashes') ?: [];
 
            if ($resetValidators) {
                $processingRule = $this->‪getRootForm()->‪getProcessingRule($this->‪getIdentifier());
                foreach ($this->‪getValidators() as ‪$validator) {
                    $processingRule->‪removeValidator(‪$validator);
                }
                $configurationHashes = [];
            }
 
            foreach ($options['validators'] as $validatorConfiguration) {
                $configurationHash = md5(
                    spl_object_hash($this) .
                    json_encode($validatorConfiguration)
                );
                if (in_array($configurationHash, $configurationHashes)) {
                    continue;
                }
                $this->‪createValidator($validatorConfiguration['identifier'], $validatorConfiguration['options'] ?? []);
                $configurationHashes[] = $configurationHash;
                $runtimeCache->set('formAbstractRenderableConfigurationHashes', $configurationHashes);
            }
        }
 
        if (isset($options['variants'])) {
            foreach ($options['variants'] as $variantConfiguration) {
                $this->‪createVariant($variantConfiguration);
            }
        }
 
        ‪ArrayUtility::assertAllArrayKeysAreValid(
            $options,
            ['label', 'defaultValue', 'properties', 'renderingOptions', 'validators', 'formEditor', 'variants']
        );
    }
 
    public function ‪createValidator(string $validatorIdentifier, array $options = [])
    {
        $validatorsDefinition = $this->‪getRootForm()->‪getValidatorsDefinition();
        if (isset($validatorsDefinition[$validatorIdentifier]) && is_array($validatorsDefinition[$validatorIdentifier]) && isset($validatorsDefinition[$validatorIdentifier]['implementationClassName'])) {
            $implementationClassName = $validatorsDefinition[$validatorIdentifier]['implementationClassName'];
            $defaultOptions = $validatorsDefinition[$validatorIdentifier]['options'] ?? [];
 
            ‪ArrayUtility::mergeRecursiveWithOverrule($defaultOptions, $options);
 
            ‪$validator = GeneralUtility::makeInstance(ObjectManager::class)
                ->get($implementationClassName, $defaultOptions);
            $this->‪addValidator($validator);
            return ‪$validator;
        }
        throw new ‪ValidatorPresetNotFoundException('The validator preset identified by "' . $validatorIdentifier . '" could not be found, or the implementationClassName was not specified.', 1328710202);
    }
 
    public function ‪addValidator(‪ValidatorInterface ‪$validator)
    {
        $formDefinition = $this->‪getRootForm();
        $formDefinition->getProcessingRule($this->‪getIdentifier())->addValidator($validator);
    }
 
    public function ‪getValidators(): \SplObjectStorage
    {
        $formDefinition = $this->‪getRootForm();
        return $formDefinition->getProcessingRule($this->‪getIdentifier())->getValidators();
    }
 
    public function ‪setDataType(string $dataType)
    {
        $formDefinition = $this->‪getRootForm();
        $formDefinition->getProcessingRule($this->‪getIdentifier())->setDataType($dataType);
    }
 
    public function ‪getRendererClassName(): string
    {
        return $this->‪getRootForm()->‪getRendererClassName();
    }
 
    public function ‪getRenderingOptions(): array
    {
        return ‪$this->renderingOptions;
    }
 
    public function ‪setRenderingOption(string $key, $value)
    {
        if (is_array($value) && isset($this->renderingOptions[$key]) && is_array($this->renderingOptions[$key])) {
            ‪ArrayUtility::mergeRecursiveWithOverrule($this->renderingOptions[$key], $value);
            $this->renderingOptions[$key] = ‪ArrayUtility::removeNullValuesRecursive($this->renderingOptions[$key]);
        } elseif ($value === null) {
            unset($this->renderingOptions[$key]);
        } else {
            $this->renderingOptions[$key] = $value;
        }
    }
 
    public function ‪getParentRenderable()
    {
        return ‪$this->parentRenderable;
    }
 
    public function ‪setParentRenderable(‪CompositeRenderableInterface ‪$parentRenderable)
    {
        $this->parentRenderable = ‪$parentRenderable;
        $this->‪registerInFormIfPossible();
    }
 
    public function ‪getRootForm(): ‪FormDefinition
    {
        $rootRenderable = ‪$this->parentRenderable;
        while ($rootRenderable !== null && !($rootRenderable instanceof ‪FormDefinition)) {
            $rootRenderable = $rootRenderable->‪getParentRenderable();
        }
        if ($rootRenderable === null) {
            throw new ‪FormDefinitionConsistencyException(sprintf('The form element "%s" is not attached to a parent form.', $this->identifier), 1326803398);
        }
 
        return $rootRenderable;
    }
 
    public function ‪registerInFormIfPossible()
    {
        try {
            $rootForm = $this->‪getRootForm();
            $rootForm->registerRenderable($this);
        } catch (‪FormDefinitionConsistencyException $exception) {
        }
    }
 
    public function ‪onRemoveFromParentRenderable()
    {
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['beforeRemoveFromParentRenderable'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'beforeRemoveFromParentRenderable')) {
                $hookObj->beforeRemoveFromParentRenderable(
                    $this
                );
            }
        }
 
        try {
            $rootForm = $this->‪getRootForm();
            $rootForm->unregisterRenderable($this);
        } catch (FormDefinitionConsistencyException $exception) {
        }
        $this->parentRenderable = null;
    }
 
    public function ‪getIndex(): int
    {
        return ‪$this->index;
    }
 
    public function ‪setIndex(int ‪$index)
    {
        $this->index = ‪$index;
    }
 
    public function ‪getLabel(): string
    {
        return ‪$this->label;
    }
 
    public function ‪setLabel(string ‪$label)
    {
        $this->label = ‪$label;
    }
 
    public function ‪setDefaultValue($defaultValue)
    {
        // todo: this method must either be abstract and implemented in sub classes or get a proper method body.
    }
 
    public function ‪setProperty(string $key, $value)
    {
        // todo: this method must either be abstract and implemented in sub classes or get a proper method body.
    }
 
    public function ‪getTemplateName(): string
    {
        return empty($this->renderingOptions['templateName'])
            ? $this->type
            : $this->renderingOptions['templateName'];
    }
 
    public function ‪isEnabled(): bool
    {
        return !isset($this->renderingOptions['enabled']) || (bool)$this->renderingOptions['enabled'] === true;
    }
 
    public function ‪getVariants(): array
    {
        return ‪$this->variants;
    }
 
    public function ‪createVariant(array $options): ‪RenderableVariantInterface
    {
        ‪$identifier = $options['identifier'] ?? '';
        unset($options['identifier']);
 
        $variant = GeneralUtility::makeInstance(ObjectManager::class)
            ->get(RenderableVariant::class, ‪$identifier, $options, $this);
 
        $this->‪addVariant($variant);
        return $variant;
    }
 
    public function ‪addVariant(‪RenderableVariantInterface $variant)
    {
        $this->variants[$variant->‪getIdentifier()] = $variant;
    }
 
    public function ‪applyVariant(‪RenderableVariantInterface $variant)
    {
        $variant->‪apply();
    }
}