AbstractFinisher.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\Finishers;
 
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\Exception\MissingArrayPathException;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Reflection\ObjectAccess;
use ‪TYPO3\CMS\Form\Domain\Finishers\Exception\FinisherException;
use ‪TYPO3\CMS\Form\Domain\Model\FormElements\StringableFormElementInterface;
use ‪TYPO3\CMS\Form\Domain\Runtime\FormRuntime;
use ‪TYPO3\CMS\Form\Service\TranslationService;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
 
abstract class ‪AbstractFinisher implements ‪FinisherInterface
{
 
    protected ‪$objectManager;
 
    protected ‪$finisherIdentifier = '';
 
    protected ‪$shortFinisherIdentifier = '';
 
    protected ‪$options = [];
 
    protected ‪$defaultOptions = [];
 
    protected ‪$finisherContext;
 
    public function ‪injectObjectManager(‪ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
    }
 
    public function ‪__construct(string ‪$finisherIdentifier = '')
    {
        if (empty(‪$finisherIdentifier)) {
            $this->finisherIdentifier = (new \ReflectionClass($this))->getShortName();
        } else {
            $this->finisherIdentifier = ‪$finisherIdentifier;
        }
 
        $this->shortFinisherIdentifier = preg_replace('/Finisher$/', '', $this->finisherIdentifier);
    }
 
    public function ‪getFinisherIdentifier(): string
    {
        return ‪$this->finisherIdentifier;
    }
 
    public function ‪setOptions(array ‪$options)
    {
        $this->options = ‪$options;
    }
 
    public function ‪setOption(string $optionName, $optionValue)
    {
        $this->options[$optionName] = $optionValue;
    }
 
    final public function ‪execute(FinisherContext ‪$finisherContext)
    {
        $this->finisherContext = ‪$finisherContext;
 
        if (!$this->‪isEnabled()) {
            return null;
        }
 
        return $this->‪executeInternal();
    }
 
    abstract protected function ‪executeInternal();
 
    protected function ‪parseOption(string $optionName)
    {
        if ($optionName === 'translation') {
            return null;
        }
 
        try {
            $optionValue = ‪ArrayUtility::getValueByPath($this->options, $optionName, '.');
        } catch (MissingArrayPathException $exception) {
            $optionValue = null;
        }
        try {
            $defaultValue = ‪ArrayUtility::getValueByPath($this->defaultOptions, $optionName, '.');
        } catch (MissingArrayPathException $exception) {
            $defaultValue = null;
        }
 
        if ($optionValue === null && $defaultValue !== null) {
            $optionValue = $defaultValue;
        }
 
        if ($optionValue === null) {
            return null;
        }
 
        if (!is_string($optionValue) && !is_array($optionValue)) {
            return $optionValue;
        }
 
        $formRuntime = $this->finisherContext->getFormRuntime();
        $optionValue = $this->‪substituteRuntimeReferences($optionValue, $formRuntime);
 
        if (is_string($optionValue)) {
            $translationOptions = isset($this->options['translation']) && \is_array($this->options['translation'])
                                ? $this->options['translation']
                                : [];
 
            $optionValue = $this->‪translateFinisherOption(
                $optionValue,
                $formRuntime,
                $optionName,
                $optionValue,
                $translationOptions
            );
 
            $optionValue = $this->‪substituteRuntimeReferences($optionValue, $formRuntime);
        }
 
        if (empty($optionValue)) {
            if ($defaultValue !== null) {
                $optionValue = $defaultValue;
            }
        }
        return $optionValue;
    }
 
    protected function ‪translateFinisherOption(
        $subject,
        FormRuntime $formRuntime,
        string $optionName,
        $optionValue,
        array $translationOptions
    ) {
        if (is_array($subject)) {
            foreach ($subject as $key => $value) {
                $subject[$key] = $this->‪translateFinisherOption(
                    $value,
                    $formRuntime,
                    $optionName . '.' . $value,
                    $value,
                    $translationOptions
                );
            }
            return $subject;
        }
 
        return ‪TranslationService::getInstance()->‪translateFinisherOption(
            $formRuntime,
            $this->finisherIdentifier,
            $optionName,
            $optionValue,
            $translationOptions
        );
    }
 
    protected function ‪substituteRuntimeReferences($needle, FormRuntime $formRuntime)
    {
        // neither array nor string, directly return
        if (!is_array($needle) && !is_string($needle)) {
            return $needle;
        }
 
        // resolve (recursively) all array items
        if (is_array($needle)) {
            $substitutedNeedle = [];
            foreach ($needle as $key => $item) {
                $key = $this->‪substituteRuntimeReferences($key, $formRuntime);
                $item = $this->‪substituteRuntimeReferences($item, $formRuntime);
                $substitutedNeedle[$key] = $item;
            }
            return $substitutedNeedle;
        }
 
        // substitute one(!) variable in string which either could result
        // again in a string or an array representing multiple values
        if (preg_match('/^{([^}]+)}$/', $needle, $matches)) {
            return $this->‪resolveRuntimeReference(
                $matches[1],
                $formRuntime
            );
        }
 
        // in case string contains more than just one variable or just a static
        // value that does not need to be substituted at all, candidates are:
        // * "prefix{variable}suffix
        // * "{variable-1},{variable-2}"
        // * "some static value"
        // * mixed cases of the above
        return preg_replace_callback(
            '/{([^}]+)}/',
            function ($matches) use ($formRuntime) {
                $value = $this->‪resolveRuntimeReference(
                    $matches[1],
                    $formRuntime
                );
 
                // substitute each match by returning the resolved value
                if (!is_array($value)) {
                    return $value;
                }
 
                // now the resolve value is an array that shall substitute
                // a variable in a string that probably is not the only one
                // or is wrapped with other static string content (see above)
                // ... which is just not possible
                throw new FinisherException(
                    'Cannot convert array to string',
                    1519239265
                );
            },
            $needle
        );
    }
 
    protected function ‪resolveRuntimeReference(string $property, FormRuntime $formRuntime)
    {
        if ($property === '__currentTimestamp') {
            return time();
        }
 
        // try to resolve the path '{...}' within the FormRuntime
        $value = ‪ObjectAccess::getPropertyPath($formRuntime, $property);
 
        if (is_object($value)) {
            $element = $formRuntime->getFormDefinition()->getElementByIdentifier($property);
 
            if (!$element instanceof StringableFormElementInterface) {
                throw new FinisherException(
                    sprintf('Cannot convert object value of "%s" to string', $property),
                    1574362327
                );
            }
 
            $value = $element->valueToString($value);
        }
 
        if ($value === null) {
            // try to resolve the path '{...}' within the FinisherVariableProvider
            $value = ‪ObjectAccess::getPropertyPath(
                $this->finisherContext->getFinisherVariableProvider(),
                $property
            );
        }
 
        if ($value !== null) {
            return $value;
        }
 
        // in case no value could be resolved
        return '{' . $property . '}';
    }
 
    public function ‪isEnabled(): bool
    {
        return !isset($this->options['renderingOptions']['enabled']) || (bool)$this->‪parseOption('renderingOptions.enabled') === true;
    }
 
    protected function ‪getTypoScriptFrontendController()
    {
        return ‪$GLOBALS['TSFE'];
    }
}