9.5/_abstract_renderable_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Form\Domain\Model\Renderable;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It originated from the Neos.Form package (www.neos.io)

 *

 * 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\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('cache_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 ‪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();

    }

}