14971594147

Committed 12 May 2025 11:57AM UTC coverage: 93.21% (-0.04%) from 93.246%

Build # 14971594147

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[BUGFIX] Provider variables in Configuration section even if FF data is array

Fixes an issue where some contexts in TYPO3 BE would not see the variables
coming from the Flux fields, when rendering the Configuration section. This
patch adds support for the case where FF data is an array instead of XML.

Run Details

1 of 5 new or added lines in 1 file covered. (20.0%)

1 existing line in 1 file now uncovered.

7083 of 7599 relevant lines covered (93.21%)

66.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.15

/Classes/Provider/AbstractProvider.php

<?php
declare(strict_types=1);
namespace FluidTYPO3\Flux\Provider;

/*
 * This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use FluidTYPO3\Flux\Builder\ViewBuilder;
use FluidTYPO3\Flux\Enum\FormOption;
use FluidTYPO3\Flux\Form;
use FluidTYPO3\Flux\Form\Container\Grid;
use FluidTYPO3\Flux\Form\Transformation\FormDataTransformer;
use FluidTYPO3\Flux\Hooks\HookHandler;
use FluidTYPO3\Flux\Service\CacheService;
use FluidTYPO3\Flux\Service\TypoScriptService;
use FluidTYPO3\Flux\Service\WorkspacesAwareRecordService;
use FluidTYPO3\Flux\Utility\ExtensionNamingUtility;
use FluidTYPO3\Flux\Utility\MiscellaneousUtility;
use FluidTYPO3\Flux\Utility\RecursiveArrayUtility;
use FluidTYPO3\Flux\ViewHelpers\FormViewHelper;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Messaging\FlashMessage;
use TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Type\ContextualFeedbackSeverity;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\PathUtility;
use TYPO3\CMS\Core\Utility\VersionNumberUtility;
use TYPO3\CMS\Extbase\Reflection\ObjectAccess;
use TYPO3Fluid\Fluid\View\Exception\InvalidTemplateResourceException;
use TYPO3Fluid\Fluid\View\ViewInterface;

class AbstractProvider implements ProviderInterface
{
    const FORM_CLASS_PATTERN = '%s\\Form\\%s\\%sForm';
    const CONTENT_OBJECT_TYPE_LIST = 'list';

    /**
     * Fill with the table column name which should trigger this Provider.
     */
    protected ?string $fieldName = null;

    /**
     * Fill with the name of the DB table which should trigger this Provider.
     */
    protected ?string $tableName = null;

    /**
     * Fill with the "list_type" value that should trigger this Provider.
     */
    protected string $listType = '';

    /**
     * Fill with the "CType" value that should trigger this Provider.
     */
    protected string $contentObjectType = '';

    protected string $name = self::class;
    protected ?string $parentFieldName = null;
    protected ?array $row = null;
    protected ?string $templatePathAndFilename = null;
    protected array $templateVariables = [];
    protected ?array $templatePaths = null;
    protected ?string $configurationSectionName = 'Configuration';
    protected string $extensionKey = 'FluidTYPO3.Flux';
    protected ?string $pluginName = null;
    protected ?string $controllerName = null;
    protected string $controllerAction = 'default';
    protected int $priority = 50;
    protected ?Form $form = null;
    protected ?Grid $grid = null;

    protected FormDataTransformer $formDataTransformer;
    protected WorkspacesAwareRecordService $recordService;
    protected ViewBuilder $viewBuilder;
    protected CacheService $cacheService;
    protected TypoScriptService $typoScriptService;

    public function __construct(
        FormDataTransformer $formDataTransformer,
        WorkspacesAwareRecordService $recordService,
        ViewBuilder $viewBuilder,
        CacheService $cacheService,
        TypoScriptService $typoScriptService
    ) {
        $this->formDataTransformer = $formDataTransformer;
        $this->recordService = $recordService;
        $this->viewBuilder = $viewBuilder;
        $this->cacheService = $cacheService;
        $this->typoScriptService = $typoScriptService;
    }

    public function loadSettings(array $settings): void
    {
        if (isset($settings['name'])) {
            $this->setName($settings['name']);
        }
        if (isset($settings['form'])) {
            $form = Form::create($settings['form']);
            if (isset($settings['extensionKey'])) {
                $extensionKey = $settings['extensionKey'];
                $extensionName = ExtensionNamingUtility::getExtensionName($extensionKey);
                $form->setExtensionName($extensionName);
            }
            $settings['form'] = $form;
        }
        if (isset($settings['grid'])) {
            $settings['grid'] = Grid::create($settings['grid']);
        }
        foreach ($settings as $name => $value) {
            if (property_exists($this, $name)) {
                $this->$name = $value;
            }
        }
        $fieldName = $this->getFieldName([]);
        if (true === isset($settings['listType'])) {
            $listType = $settings['listType'];
            $GLOBALS['TCA'][$this->tableName]['types']['list']['subtypes_addlist'][$listType] = $fieldName;
        }
        $GLOBALS['TCA'][$this->tableName]['columns'][$fieldName]['config']['type'] = 'flex';
    }

    public function trigger(array $row, ?string $table, ?string $field, ?string $extensionKey = null): bool
    {
        $providerFieldName = $this->getFieldName($row);
        $providerTableName = $this->getTableName($row);
        $providerExtensionKey = $this->extensionKey;
        $contentObjectType = $this->contentObjectType;
        $listType = $this->listType;

        // Content type resolving: CType *may* be an array when called from certain FormEngine contexts, such as
        // user functions registered via userFunc.
        $contentTypeFromRecord = (is_array($row['CType'] ?? null) ? $row['CType'][0] : null) ?? $row['CType'] ?? null;
        $pluginTypeFromRecord = $row['list_type'] ?? null;

        $rowContainsPlugin = $contentTypeFromRecord === static::CONTENT_OBJECT_TYPE_LIST;
        $isContentRecord = $table === 'tt_content';
        $rowIsEmpty = (0 === count($row));
        $matchesContentType = $contentTypeFromRecord === $contentObjectType;
        $matchesPluginType = $rowContainsPlugin && $pluginTypeFromRecord === $listType;
        $matchesTableName = ($providerTableName === $table || !$table);
        $matchesFieldName = ($providerFieldName === $field || !$field);
        $matchesExtensionKey = ($providerExtensionKey === $extensionKey || !$extensionKey);

        // Requirements: must always match ext-key, table and field. If record is a content record, must additionally
        // match either Ctype and list_type, or must match CType in record that does not have a list_type.
        $isFullMatch = $matchesExtensionKey && $matchesTableName && $matchesFieldName
            && (!$isContentRecord || ($matchesContentType && ((!$rowContainsPlugin) || $matchesPluginType)));
        $isFallbackMatch = ($matchesTableName && $matchesFieldName && $rowIsEmpty);
        return ($isFullMatch || $isFallbackMatch);
    }

    /**
     * If not-NULL is returned, the value is used as
     * object class name when creating a Form implementation
     * instance which can be returned as form instead of
     * reading from template or overriding the getForm() method.
     *
     * @return class-string|null
     */
    protected function resolveFormClassName(array $row, ?string $forField = null): ?string
    {
        $packageName = $this->getControllerPackageNameFromRecord($row, $forField);
        $packageKey = str_replace('.', '\\', $packageName);
        $controllerName = $this->getControllerNameFromRecord($row);
        $action = $this->getControllerActionFromRecord($row, $forField);
        $expectedClassName = sprintf(static::FORM_CLASS_PATTERN, $packageKey, $controllerName, ucfirst($action));
        return class_exists($expectedClassName) ? $expectedClassName : null;
    }

    protected function getViewVariables(array $row, ?string $forField = null): array
    {
        $extensionKey = (string) $this->getExtensionKey($row, $forField);
        $fieldName = $forField ?? $this->getFieldName($row);
        $variables = [
            'record' => $row,
            'settings' => $this->typoScriptService->getSettingsForExtensionName($extensionKey),
            'forField' => $forField,
        ];

        // Special case: when saving a new record variable $row[$fieldName] is already an array
        // and must not be processed by the configuration service. This has limited support from
        // Flux (essentially: no Form instance which means no inheritance, transformation or
        // form options can be dependended upon at this stage).
        if (isset($row[$fieldName])) {
            if (is_array($row[$fieldName])) {
                $xml = GeneralUtility::array2xml($row[$fieldName]);
            } else {
                $xml = $row[$fieldName];
            }
            $recordVariables = $this->formDataTransformer->convertFlexFormContentToArray($xml);
            $variables = RecursiveArrayUtility::mergeRecursiveOverrule($variables, $recordVariables);
        }

        $variables = RecursiveArrayUtility::mergeRecursiveOverrule($this->templateVariables, $variables);

        return $variables;
    }

    public function getForm(array $row, ?string $forField = null): ?Form
    {
        /** @var Form $form */
        $form = $this->form
            ?? $this->createCustomFormInstance($row, $forField)
            ?? $this->extractConfiguration($row, 'form', $forField)
            ?? Form::create();
        $form->setOption(FormOption::RECORD, $row);
        $form->setOption(FormOption::RECORD_TABLE, $this->getTableName($row));
        $form->setOption(FormOption::RECORD_FIELD, $forField ?? $this->getFieldName($row));
        return $form;
    }

    protected function createCustomFormInstance(array $row, ?string $forField = null): ?Form
    {
        $formClassName = $this->resolveFormClassName($row, $forField);
        if ($formClassName !== null && class_exists($formClassName)) {
            $tableName = $this->getTableName($row);
            $fieldName = $forField ?? $this->getFieldName($row);
            $id = 'row_' . $row['uid'];
            if ($tableName) {
                $id = $tableName;
            }
            if ($fieldName) {
                $id .= '_' . $fieldName;
            }
            return $formClassName::create(['id' => $id]);
        }
        return null;
    }

    public function getGrid(array $row): Grid
    {
        if ($this->grid instanceof Grid) {
            return $this->grid;
        }
        $form = $this->getForm($row);
        if ($form) {
            $container = $this->detectContentContainerParent($form);
            if ($container) {
                $values = $this->getFlexFormValues($row);
                $contentContainer = $container->getContentContainer();
                $persistedObjects = [];
                if ($contentContainer instanceof Form\Container\SectionObject) {
                    $persistedObjects = array_column(
                        (array) (ObjectAccess::getProperty($values, (string) $container->getName()) ?? []),
                        (string) $contentContainer->getName()
                    );
                }

                // Determine the mode to render, then create an ad-hoc grid.
                /** @var Grid $grid */
                $grid = Grid::create();
                if ($container->getGridMode() === Form\Container\Section::GRID_MODE_ROWS) {
                    foreach ($persistedObjects as $index => $object) {
                        $gridRow = $grid->createContainer(Form\Container\Row::class, 'row' . $index);
                        $gridColumn = $gridRow->createContainer(
                            Form\Container\Column::class,
                            'column' . $object['colPos'],
                            $object['label'] ?? 'Column ' . $object['colPos']
                        );
                        $gridColumn->setColumnPosition((int) $object['colPos']);
                    }
                } elseif ($container->getGridMode() === Form\Container\Section::GRID_MODE_COLUMNS) {
                    $gridRow = $grid->createContainer(Form\Container\Row::class, 'row');
                    foreach ($persistedObjects as $index => $object) {
                        $gridColumn = $gridRow->createContainer(
                            Form\Container\Column::class,
                            'column' . $object['colPos'],
                            $object['label'] ?? 'Column ' . $object['colPos']
                        );
                        $gridColumn->setColumnPosition((int) $object['colPos']);
                        $gridColumn->setColSpan((int) ($object['colspan'] ?? 1));
                    }
                }
                return $grid;
            }
        }
        /** @var array $grids */
        $grids = $this->extractConfiguration($row, 'grids');
        $grid = $grids['grid'] ?? Grid::create();
        $grid->setExtensionName($grid->getExtensionName() ?: $this->getControllerExtensionKeyFromRecord($row));
        return $grid;
    }

    protected function detectContentContainerParent(Form\ContainerInterface $container): ?Form\Container\Section
    {
        if ($container instanceof Form\Container\SectionObject && $container->isContentContainer()) {
            /** @var Form\Container\Section $parent */
            $parent = $container->getParent();
            return $parent;
        }
        foreach ($container->getChildren() as $child) {
            if ($child instanceof Form\ContainerInterface
                && ($detected = $this->detectContentContainerParent($child))
            ) {
                return $detected;
            }
        }
        return null;
    }

    /**
     * @return mixed|null
     */
    protected function extractConfiguration(array $row, ?string $name = null, ?string $forField = null)
    {
        $cacheKeyAll = $this->getCacheKeyForStoredVariable($row, '_all', $forField) . '_' . $forField;
        /** @var array $allCached */
        $allCached = $this->cacheService->getFromCaches($cacheKeyAll);
        $fromCache = $allCached[$name] ?? null;
        if ($fromCache) {
            return $fromCache;
        }
        $configurationSectionName = $this->getConfigurationSectionName($row, $forField);
        $viewVariables = $this->getViewVariables($row, $forField);
        $view = $this->getViewForRecord($row, $forField);
        $view->getRenderingContext()->getViewHelperVariableContainer()->addOrUpdate(
            FormViewHelper::class,
            FormViewHelper::SCOPE_VARIABLE_EXTENSIONNAME,
            $this->getExtensionKey($row, $forField)
        );

        try {
            if ($configurationSectionName) {
                $view->renderSection($configurationSectionName, $viewVariables, false);
            } else {
                $view->assignMultiple($viewVariables);
                $view->render();
            }
        } catch (InvalidTemplateResourceException $exception) {
            $this->dispatchFlashMessageForException($exception);
            return null;
        }

        $variables = $view->getRenderingContext()->getViewHelperVariableContainer()->getAll(FormViewHelper::class, []);
        $cachePersistent = false;
        if (isset($variables['form'])) {
            $variables['form']->setOption(
                FormOption::TEMPLATE_FILE,
                $this->getTemplatePathAndFilename($row, $forField)
            );
            $cachePersistent = (boolean) $variables['form']->getOption(FormOption::STATIC);
        }

        $this->cacheService->setInCaches(
            $variables,
            $cachePersistent,
            $cacheKeyAll
        );

        $returnValue = $name ? ($variables[$name] ?? null) : $variables;

        return HookHandler::trigger(
            HookHandler::PROVIDER_EXTRACTED_OBJECT,
            [
                'record' => $row,
                'name' => $name,
                'value' => $returnValue
            ]
        )['value'];
    }

    public function setListType(string $listType): self
    {
        $this->listType = $listType;
        return $this;
    }

    public function getListType(): string
    {
        return $this->listType;
    }

    public function setContentObjectType(string $contentObjectType): self
    {
        $this->contentObjectType = $contentObjectType;
        return $this;
    }

    public function getContentObjectType(): string
    {
        return $this->contentObjectType;
    }

    public function getFieldName(array $row): ?string
    {
        return $this->fieldName;
    }

    public function getParentFieldName(array $row): ?string
    {
        unset($row);
        return $this->parentFieldName;
    }

    public function getTableName(array $row): ?string
    {
        unset($row);
        return $this->tableName;
    }

    public function getTemplatePathAndFilename(array $row, ?string $forField = null): ?string
    {
        $templatePathAndFilename = (string) $this->templatePathAndFilename;
        if ($templatePathAndFilename !== '' && !PathUtility::isAbsolutePath($templatePathAndFilename)) {
            $templatePathAndFilename = $this->resolveAbsolutePathToFile($templatePathAndFilename);
        }
        if (true === empty($templatePathAndFilename)) {
            $templatePathAndFilename = null;
        }
        return HookHandler::trigger(
            HookHandler::PROVIDER_RESOLVED_TEMPLATE,
            [
                'template' => $templatePathAndFilename,
                'provider' => $this,
                'record' => $row
            ]
        )['template'];
    }

    /**
     * Converts the contents of the provided row's Flux-enabled field,
     * at the same time running through the inheritance tree generated
     * by getInheritanceTree() in order to apply inherited values.
     */
    public function getFlexFormValues(array $row, ?string $forField = null): array
    {
        $fieldName = $forField ?? $this->getFieldName($row);
        $form = $this->getForm($row);
        return $this->formDataTransformer->convertFlexFormContentToArray($row[$fieldName] ?? '', $form);
    }

    /**
     * Returns the page record with localisation applied, if any
     * exists in database. Maintains uid and pid of the original
     * page if localisation is applied.
     */
    protected function getPageValues(): array
    {
        $record = $GLOBALS['TSFE']->page ?? null;
        if (!$record) {
            return [];
        }
        return $record;
    }

    public function getTemplateVariables(array $row): array
    {
        $variables = array_merge(
            $this->templateVariables,
            $this->getViewVariables($row)
        );
        $variables['page'] = $this->getPageValues();
        $variables['user'] = $GLOBALS['TSFE']->fe_user->user ?? [];
        if (file_exists((string) $this->getTemplatePathAndFilename($row))) {
            $variables['grid'] = $this->getGrid($row);
            $variables['form'] = $this->getForm($row);
        }
        return $variables;
    }

    public function getConfigurationSectionName(array $row, ?string $forField = null): ?string
    {
        unset($row, $forField);
        return $this->configurationSectionName;
    }

    public function getExtensionKey(array $row, ?string $forField = null): string
    {
        unset($row);
        return $this->extensionKey;
    }

    public function getPriority(array $row): int
    {
        unset($row);
        return $this->priority;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getPluginName(): ?string
    {
        return $this->pluginName;
    }

    public function setPluginName(?string $pluginName): self
    {
        $this->pluginName = $pluginName;
        return $this;
    }

    /**
     * Post-process record data for the table that this ConfigurationProvider
     * is attached to.
     *
     * @param string $operation TYPO3 operation identifier, i.e. "update", "new" etc.
     * @param integer $id The ID of the current record (which is sometimes not included in $row)
     * @param array $row the record that was modified
     * @param DataHandler $reference A reference to the DataHandler object that modified the record
     * @param array $removals Allows overridden methods to pass an array of fields to remove from the stored Flux value
     * @return bool true to stop processing other providers, false to continue processing other providers.
     */
    public function postProcessRecord(
        string $operation,
        int $id,
        array $row,
        DataHandler $reference,
        array $removals = []
    ): bool {
        if (!in_array($operation, ['update', 'new'], true)) {
            return false;
        }

        $record = $reference->datamap[$this->tableName][$id] ?? $row;
        $tableName = (string) $this->getTableName($record);
        $fieldName = $this->getFieldName($record);

        $dontProcess = (
            $fieldName === null
            || !isset($record[$fieldName])
            || !isset($record[$fieldName]['data'])
            || !is_array($record[$fieldName]['data'])
        );
        if ($dontProcess) {
            return false;
        }

        $stored = $this->recordService->getSingle($tableName, '*', $id) ?? $record;

        $removals = array_merge(
            $removals,
            $this->extractFieldNamesToClear($record, $fieldName)
        );

        if (!empty($removals) && !empty($stored[$fieldName])) {
            $stored[$fieldName] = MiscellaneousUtility::cleanFlexFormXml($stored[$fieldName], $removals);
            $this->recordService->update($tableName, $stored);
        }

        return false;
    }

    protected function extractFieldNamesToClear(array $record, string $fieldName): array
    {
        return $this->extractWizardTaggedFieldNames($record, $fieldName, 'clear');
    }

    protected function extractFieldNamesToProtect(array $record, string $fieldName): array
    {
        return $this->extractWizardTaggedFieldNames($record, $fieldName, 'protect');
    }

    protected function extractWizardTaggedFieldNames(array $record, string $fieldName, string $wizardName): array
    {
        $wizardTagName = '_' . $wizardName;
        $tagLength = strlen($wizardTagName);
        $fieldNames = [];
        $data = $record[$fieldName]['data'] ?? [];
        foreach ($data as $sheetName => $sheetFields) {
            foreach ($sheetFields['lDEF'] as $sheetFieldName => $fieldDefinition) {
                if ($wizardTagName === substr($sheetFieldName, -$tagLength)) {
                    $fieldNames[] = $sheetFieldName;
                } else {
                    $wizardFieldName = $sheetFieldName . $wizardTagName;
                    if (isset($data[$sheetName]['lDEF'][$wizardFieldName]['vDEF'])) {
                        if ((boolean) $data[$sheetName]['lDEF'][$wizardFieldName]['vDEF']) {
                            $fieldNames[] = $sheetFieldName;
                        }
                    }
                }
            }
        }
        return array_unique($fieldNames);
    }

    /**
     * Post-process the TCEforms DataStructure for a record associated
     * with this ConfigurationProvider.
     */
    public function postProcessDataStructure(array &$row, ?array &$dataStructure, array $conf): void
    {
        $form = $this->getForm($row, $conf['fieldName'] ?? null);
        if ($dataStructure !== null && $form !== null) {
            // Last minute set the field name. Ensures the field name matches the one given with the DS identifier,
            // even if the Form instance was resolved from another field (e.g. inherited Form in page template).
            $form->setOption(
                FormOption::RECORD_FIELD,
                $conf['fieldName'] ?? $form->getOption(FormOption::RECORD_FIELD)
            );
            $dataStructure = array_replace_recursive($dataStructure, $form->build());
        }
    }

    /**
     * Processes the table configuration (TCA) for the table associated
     * with this Provider, as determined by the trigger() method. Gets
     * passed an instance of the record being edited/created along with
     * the current configuration array - and must return a complete copy
     * of the configuration array manipulated to the Provider's needs.
     *
     * @param array $row The record being edited/created
     * @param array $configuration Current TCA configuration
     * @return array The large FormEngine configuration array - see FormEngine documentation!
     */
    public function processTableConfiguration(array $row, array $configuration): array
    {
        $form = $this->getForm($row);
        if (!$form) {
            return $configuration;
        }

        /** @var string $table */
        $table = $this->getTableName($row);
        $recordType = $configuration['recordTypeValue'];

        // Replace or add fields as native TCA fields if defined as native=1 in the Flux form:
        foreach ($form->getFields() as $fieldName => $field) {
            if (!$field instanceof Form\FieldInterface || !$field->isNative()) {
                continue;
            }

            // Basic initialization: declare the TCA field's data structure and initialize it in databaseRow.
            $configuration['processedTca']['columns'][$fieldName] = $field->build();
            if (!in_array($fieldName, $configuration['columnsToProcess'], true)) {
                $configuration['columnsToProcess'][] = $fieldName;
                $configuration['databaseRow'][$fieldName] = $configuration['databaseRow'][$fieldName]
                    ?? $field->getDefault();
            }

            // Handle potential positioning instructions.
            $positionOption = $field->getPosition();
            if (!empty($positionOption)) {
                $insertFieldDefinition = $fieldName;
                if (strpos($positionOption, ' ') !== false) {
                    [$position, $sheet] = explode(' ', $positionOption, 2);
                    $insertFieldDefinition = '--div--;' . $sheet . ',' . $fieldName;
                } else {
                    $position = $positionOption;
                }
                ExtensionManagementUtility::addToAllTCAtypes($table, $insertFieldDefinition, $recordType, $position);
                $configuration['processedTca']['types'][$recordType]['showitem']
                    = $GLOBALS['TCA'][$table]['types'][$recordType]['showitem'];
            }
        }

        // Remove any fields listed in the "hideNativeFields" Flux form option
        /** @var string|array $hideFieldsOption */
        $hideFieldsOption = $form->getOption(FormOption::HIDE_NATIVE_FIELDS);
        if (!empty($hideFieldsOption)) {
            $hideFields = is_array($hideFieldsOption)
                ? $hideFieldsOption
                : GeneralUtility::trimExplode(',', $hideFieldsOption, true);
            foreach ($hideFields as $hideField) {
                unset($configuration['processedTca']['columns'][$hideField]);
            }
        }
        return $configuration;
    }

    protected function getViewForRecord(array $row, ?string $forField = null): ViewInterface
    {
        return $this->viewBuilder->buildTemplateView(
            $this->getControllerExtensionKeyFromRecord($row, $forField),
            $this->getControllerNameFromRecord($row),
            $this->getControllerActionFromRecord($row, $forField),
            $this->getPluginName() ?? $this->getControllerNameFromRecord($row),
            $this->getTemplatePathAndFilename($row, $forField)
        );
    }

    /**
     * Get preview chunks - header and content - as
     * [string $headerContent, string $previewContent, boolean $continueRendering]
     *
     * Default implementation renders the Preview section from the template
     * file that the actual Provider returns for $row, using paths also
     * determined by $row. Example: fluidcontent's Provider returns files
     * and paths based on selected "Fluid Content type" and inherits and
     * uses this method to render a Preview from the template file in the
     * specific path. This default implementation expects the TYPO3 core
     * to render the default header, so it returns NULL as $headerContent.
     */
    public function getPreview(array $row): array
    {
        $previewContent = $this->viewBuilder->buildPreviewView(
            $this->getControllerExtensionKeyFromRecord($row),
            $this->getControllerNameFromRecord($row),
            $this->getControllerActionFromRecord($row),
            $this->getPluginName() ?? $this->getControllerNameFromRecord($row),
            $this->getTemplatePathAndFilename($row)
        )->getPreview($this, $row);
        return [null, $previewContent, empty($previewContent)];
    }

    protected function getCacheKeyForStoredVariable(array $row, string $variable, ?string $forField = null): string
    {
        return implode(
            '-',
            [
                'flux',
                'storedvariable',
                $this->getTableName($row),
                $forField ?? $this->getFieldName($row),
                $row['uid'] ?? 0,
                $this->getControllerExtensionKeyFromRecord($row, $forField),
                $this->getControllerActionFromRecord($row, $forField),
                $variable
            ]
        );
    }

    /**
     * Stub: override this to return a controller name associated with $row.
     * Default strategy: return base name of Provider class minus the "Provider" suffix.
     */
    public function getControllerNameFromRecord(array $row): string
    {
        if (!empty($this->controllerName)) {
            return $this->controllerName;
        }
        $class = get_class($this);
        $separator = false !== strpos($class, '\\') ? '\\' : '_';
        $parts = explode($separator, $class);
        $base = end($parts);
        return substr($base, 0, -8);
    }

    /**
     * Stub: Get the extension key of the controller associated with $row
     */
    public function getControllerExtensionKeyFromRecord(array $row, ?string $forField = null): string
    {
        return $this->extensionKey;
    }

    /**
     * Stub: Get the package name of the controller associated with $row
     */
    public function getControllerPackageNameFromRecord(array $row, ?string $forField = null): string
    {
        $extensionKey = $this->getControllerExtensionKeyFromRecord($row, $forField);
        $extensionName = ExtensionNamingUtility::getExtensionName($extensionKey);
        $vendor = ExtensionNamingUtility::getVendorName($extensionKey);
        return null !== $vendor ? $vendor . '.' . $extensionName : $extensionName;
    }

    /**
     * Stub: Get the name of the controller action associated with $row
     */
    public function getControllerActionFromRecord(array $row, ?string $forField = null): string
    {
        return $this->controllerAction;
    }

    /**
     * Stub: Get a compacted controller name + action name string
     */
    public function getControllerActionReferenceFromRecord(array $row, ?string $forField = null): string
    {
        return $this->getControllerNameFromRecord($row) . '->' . $this->getControllerActionFromRecord($row, $forField);
    }

    public function setTableName(string $tableName): self
    {
        $this->tableName = $tableName;
        return $this;
    }

    public function setFieldName(?string $fieldName): self
    {
        $this->fieldName = $fieldName;
        return $this;
    }

    public function setExtensionKey(string $extensionKey): self
    {
        $this->extensionKey = $extensionKey;
        return $this;
    }

    public function setControllerName(string $controllerName): self
    {
        $this->controllerName = $controllerName;
        return $this;
    }

    public function setControllerAction(string $controllerAction): self
    {
        $this->controllerAction = $controllerAction;
        return $this;
    }

    public function setTemplateVariables(?array $templateVariables): self
    {
        $this->templateVariables = $templateVariables ?? [];
        return $this;
    }

    public function setTemplatePathAndFilename(?string $templatePathAndFilename): self
    {
        $this->templatePathAndFilename = $templatePathAndFilename;
        return $this;
    }

    public function setTemplatePaths(?array $templatePaths): self
    {
        $this->templatePaths = $templatePaths;
        return $this;
    }

    public function setConfigurationSectionName(?string $configurationSectionName): self
    {
        $this->configurationSectionName = $configurationSectionName;
        return $this;
    }

    public function setName(string $name): self
    {
        $this->name = $name;
        return $this;
    }

    public function setForm(Form $form): self
    {
        $this->form = $form;
        return $this;
    }

    public function setGrid(Grid $grid): self
    {
        $this->grid = $grid;
        return $this;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function dispatchFlashMessageForException(\Throwable $error): void
    {
        if (version_compare(VersionNumberUtility::getCurrentTypo3Version(), '13.4', '>=')) {
            $level = ContextualFeedbackSeverity::ERROR;
        } else {
            $level = FlashMessage::ERROR;
        }
        /** @var FlashMessage $flashMesasage */
        $flashMesasage = GeneralUtility::makeInstance(
            FlashMessage::class,
            $error->getMessage(),
            '',
            $level
        );
        /** @var FlashMessageService $flashMessageService */
        $flashMessageService = GeneralUtility::makeInstance(FlashMessageService::class);
        $flashMesasageQueue = $flashMessageService->getMessageQueueByIdentifier();
        $flashMesasageQueue->enqueue($flashMesasage);
    }

    /**
     * @codeCoverageIgnore
     */
    protected function resolveAbsolutePathToFile(?string $file): ?string
    {
        return $file === null ? null : GeneralUtility::getFileAbsFileName($file);
    }
}

FluidTYPO3 / flux / 14971594147

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous