9.5/_tca_inline_8php_source.html

<?php

namespace ‪TYPO3\CMS\Backend\Form\FormDataProvider;


/*

 * 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\Form\Exception\DatabaseRecordException;

use ‪TYPO3\CMS\Backend\Form\FormDataCompiler;

use ‪TYPO3\CMS\Backend\Form\FormDataGroup\OnTheFly;

use ‪TYPO3\CMS\Backend\Form\FormDataGroup\TcaDatabaseRecord;

use ‪TYPO3\CMS\Backend\Form\FormDataProviderInterface;

use ‪TYPO3\CMS\Backend\Form\InlineStackProcessor;

use ‪TYPO3\CMS\Backend\Utility\BackendUtility;

use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;

use ‪TYPO3\CMS\Core\Database\RelationHandler;

use ‪TYPO3\CMS\Core\Localization\LanguageService;

use ‪TYPO3\CMS\Core\Messaging\FlashMessage;

use ‪TYPO3\CMS\Core\Messaging\FlashMessageService;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\MathUtility;

use ‪TYPO3\CMS\Core\Versioning\VersionState;


class ‪TcaInline extends ‪AbstractDatabaseRecordProvider implements ‪FormDataProviderInterface

{

    public function ‪addData(array $result)

    {

        $result = $this->‪addInlineFirstPid($result);


        foreach ($result['processedTca']['columns'] as $fieldName => $fieldConfig) {

            if (!$this->‪isInlineField($fieldConfig)) {

                continue;

            }

            $result['processedTca']['columns'][$fieldName]['children'] = [];

            if (!$this->‪isUserAllowedToModify($fieldConfig)) {

                continue;

            }

            if ($result['inlineResolveExistingChildren']) {

                $result = $this->‪resolveRelatedRecords($result, $fieldName);

                $result = $this->‪addForeignSelectorAndUniquePossibleRecords($result, $fieldName);

            }

        }


        return $result;

    }


    protected function ‪isInlineField($fieldConfig)

    {

        return !empty($fieldConfig['config']['type']) && $fieldConfig['config']['type'] === 'inline';

    }


    protected function ‪isUserAllowedToModify($fieldConfig)

    {

        return $this->‪getBackendUser()->‪check('tables_modify', $fieldConfig['config']['foreign_table']);

    }


    protected function ‪addInlineFirstPid(array $result)

    {

        if ($result['inlineFirstPid'] === null) {

            $table = $result['tableName'];

            $row = $result['databaseRow'];

            // If the parent is a page, use the uid(!) of the (new?) page as pid for the child records:

            if ($table === 'pages') {

                $liveVersionId = ‪BackendUtility::getLiveVersionIdOfRecord('pages', $row['uid']);

                $pid = $liveVersionId === null ? $row['uid'] : $liveVersionId;

            } elseif (($row['pid'] ?? 0) < 0) {

                $prevRec = ‪BackendUtility::getRecord($table, abs($row['pid']));

                $pid = $prevRec['pid'];

            } else {

                $pid = $row['pid'] ?? 0;

            }

            if (‪MathUtility::canBeInterpretedAsInteger($pid)) {

                $pageRecord = ‪BackendUtility::getRecord('pages', (int)$pid);

                if ((int)$pageRecord[‪$GLOBALS['TCA']['pages']['ctrl']['transOrigPointerField']] > 0) {

                    $pid = (int)$pageRecord[‪$GLOBALS['TCA']['pages']['ctrl']['transOrigPointerField']];

                }

            } elseif (strpos($pid, 'NEW') !== 0) {

                throw new \RuntimeException(

                    'inlineFirstPid should either be an integer or a "NEW..." string',

                    1521220142

                );

            }

            $result['inlineFirstPid'] = $pid;

        }

        return $result;

    }


    protected function ‪resolveRelatedRecordsOverlays(array $result, $fieldName)

    {

        $childTableName = $result['processedTca']['columns'][$fieldName]['config']['foreign_table'];


        $connectedUidsOfLocalizedOverlay = [];

        if ($result['command'] === 'edit') {

            $connectedUidsOfLocalizedOverlay = $this->‪resolveConnectedRecordUids(

                $result['processedTca']['columns'][$fieldName]['config'],

                $result['tableName'],

                $result['databaseRow']['uid'],

                $result['databaseRow'][$fieldName]

            );

        }

        $result['databaseRow'][$fieldName] = implode(',', $connectedUidsOfLocalizedOverlay);

        $connectedUidsOfLocalizedOverlay = $this->‪getWorkspacedUids($connectedUidsOfLocalizedOverlay, $childTableName);

        if ($result['inlineCompileExistingChildren']) {

            $tableNameWithDefaultRecords = $result['tableName'];

            $connectedUidsOfDefaultLanguageRecord = $this->‪resolveConnectedRecordUids(

                $result['processedTca']['columns'][$fieldName]['config'],

                $tableNameWithDefaultRecords,

                $result['defaultLanguageRow']['uid'],

                $result['defaultLanguageRow'][$fieldName]

            );

            $connectedUidsOfDefaultLanguageRecord = $this->‪getWorkspacedUids($connectedUidsOfDefaultLanguageRecord, $childTableName);


            $showPossible = $result['processedTca']['columns'][$fieldName]['config']['appearance']['showPossibleLocalizationRecords'];


            // Find which records are localized, which records are not localized and which are

            // localized but miss default language record

            $fieldNameWithDefaultLanguageUid = ‪$GLOBALS['TCA'][$childTableName]['ctrl']['transOrigPointerField'];

            foreach ($connectedUidsOfLocalizedOverlay as $localizedUid) {

                try {

                    $localizedRecord = $this->‪getRecordFromDatabase($childTableName, $localizedUid);

                } catch (‪DatabaseRecordException $e) {

                    // The child could not be compiled, probably it was deleted and a dangling mm record exists

                    $this->logger->warning(

                        $e->getMessage(),

                        [

                            'table' => $childTableName,

                            'uid' => $localizedUid,

                            'exception' => $e

                        ]

                    );

                    continue;

                }

                $uidOfDefaultLanguageRecord = $localizedRecord[$fieldNameWithDefaultLanguageUid];

                if (in_array($uidOfDefaultLanguageRecord, $connectedUidsOfDefaultLanguageRecord)) {

                    // This localized child has a default language record. Remove this record from list of default language records

                    $connectedUidsOfDefaultLanguageRecord = array_diff($connectedUidsOfDefaultLanguageRecord, [$uidOfDefaultLanguageRecord]);

                }

                // Compile localized record

                $compiledChild = $this->‪compileChild($result, $fieldName, $localizedUid);

                $result['processedTca']['columns'][$fieldName]['children'][] = $compiledChild;

            }

            if ($showPossible) {

                foreach ($connectedUidsOfDefaultLanguageRecord as $defaultLanguageUid) {

                    // If there are still uids in $connectedUidsOfDefaultLanguageRecord, these are records that

                    // exist in default language, but are not localized yet. Compile and mark those

                    try {

                        $compiledChild = $this->‪compileChild($result, $fieldName, $defaultLanguageUid);

                    } catch (‪DatabaseRecordException $e) {

                        // The child could not be compiled, probably it was deleted and a dangling mm record exists

                        $this->logger->warning(

                            $e->getMessage(),

                            [

                                'table' => $childTableName,

                                'uid' => $defaultLanguageUid,

                                'exception' => $e

                            ]

                        );

                        continue;

                    }

                    $compiledChild['isInlineDefaultLanguageRecordInLocalizedParentContext'] = true;

                    $result['processedTca']['columns'][$fieldName]['children'][] = $compiledChild;

                }

            }

        }


        return $result;

    }


    protected function ‪resolveRelatedRecords(array $result, $fieldName)

    {

        if ($result['defaultLanguageRow'] !== null) {

            return $this->‪resolveRelatedRecordsOverlays($result, $fieldName);

        }


        $childTableName = $result['processedTca']['columns'][$fieldName]['config']['foreign_table'];

        $connectedUidsOfDefaultLanguageRecord = $this->‪resolveConnectedRecordUids(

            $result['processedTca']['columns'][$fieldName]['config'],

            $result['tableName'],

            $result['databaseRow']['uid'],

            $result['databaseRow'][$fieldName]

        );

        $result['databaseRow'][$fieldName] = implode(',', $connectedUidsOfDefaultLanguageRecord);


        $connectedUidsOfDefaultLanguageRecord = $this->‪getWorkspacedUids($connectedUidsOfDefaultLanguageRecord, $childTableName);


        if ($result['inlineCompileExistingChildren']) {

            foreach ($connectedUidsOfDefaultLanguageRecord as $uid) {

                $compiledChild = $this->‪compileChild($result, $fieldName, $uid);

                $result['processedTca']['columns'][$fieldName]['children'][] = $compiledChild;

            }

        }

        return $result;

    }


    protected function ‪addForeignSelectorAndUniquePossibleRecords(array $result, $fieldName)

    {

        if (!is_array($result['processedTca']['columns'][$fieldName]['config']['selectorOrUniqueConfiguration'])) {

            return $result;

        }


        $selectorOrUniqueConfiguration = $result['processedTca']['columns'][$fieldName]['config']['selectorOrUniqueConfiguration'];

        $foreignFieldName = $selectorOrUniqueConfiguration['fieldName'];

        $selectorOrUniquePossibleRecords = [];


        if ($selectorOrUniqueConfiguration['config']['type'] === 'select') {

            // Compile child table data for this field only

            $selectDataInput = [

                'tableName' => $result['processedTca']['columns'][$fieldName]['config']['foreign_table'],

                'command' => 'new',

                // Since there is no existing record that may have a type, it does not make sense to

                // do extra handling of pageTsConfig merged here. Just provide "parent" pageTS as is

                'pageTsConfig' => $result['pageTsConfig'],

                'userTsConfig' => $result['userTsConfig'],

                'databaseRow' => $result['databaseRow'],

                'processedTca' => [

                    'ctrl' => [],

                    'columns' => [

                        $foreignFieldName => [

                            'config' => $selectorOrUniqueConfiguration['config'],

                        ],

                    ],

                ],

                'inlineExpandCollapseStateArray' => $result['inlineExpandCollapseStateArray'],

            ];

            $formDataGroup = GeneralUtility::makeInstance(OnTheFly::class);

            $formDataGroup->setProviderList([TcaSelectItems::class]);

            $formDataCompiler = GeneralUtility::makeInstance(FormDataCompiler::class, $formDataGroup);

            $compilerResult = $formDataCompiler->compile($selectDataInput);

            $selectorOrUniquePossibleRecords = $compilerResult['processedTca']['columns'][$foreignFieldName]['config']['items'];

        }


        $result['processedTca']['columns'][$fieldName]['config']['selectorOrUniquePossibleRecords'] = $selectorOrUniquePossibleRecords;


        return $result;

    }


    protected function ‪compileChild(array $result, $parentFieldName, $childUid)

    {

        $parentConfig = $result['processedTca']['columns'][$parentFieldName]['config'];

        $childTableName = $parentConfig['foreign_table'];


        $inlineStackProcessor = GeneralUtility::makeInstance(InlineStackProcessor::class);

        $inlineStackProcessor->initializeByGivenStructure($result['inlineStructure']);

        $inlineTopMostParent = $inlineStackProcessor->getStructureLevel(0);


        $formDataGroup = GeneralUtility::makeInstance(TcaDatabaseRecord::class);

        $formDataCompiler = GeneralUtility::makeInstance(FormDataCompiler::class, $formDataGroup);

        $formDataCompilerInput = [

            'command' => 'edit',

            'tableName' => $childTableName,

            'vanillaUid' => (int)$childUid,

            // Give incoming returnUrl down to children so they generate a returnUrl back to

            // the originally opening record, also see "originalReturnUrl" in inline container

            // and FormInlineAjaxController

            'returnUrl' => $result['returnUrl'],

            'isInlineChild' => true,

            'inlineStructure' => $result['inlineStructure'],

            'inlineExpandCollapseStateArray' => $result['inlineExpandCollapseStateArray'],

            'inlineFirstPid' => $result['inlineFirstPid'],

            'inlineParentConfig' => $parentConfig,


            // values of the current parent element

            // it is always a string either an id or new...

            'inlineParentUid' => $result['databaseRow']['uid'],

            'inlineParentTableName' => $result['tableName'],

            'inlineParentFieldName' => $parentFieldName,


            // values of the top most parent element set on first level and not overridden on following levels

            'inlineTopMostParentUid' => $result['inlineTopMostParentUid'] ?: $inlineTopMostParent['uid'],

            'inlineTopMostParentTableName' => $result['inlineTopMostParentTableName'] ?: $inlineTopMostParent['table'],

            'inlineTopMostParentFieldName' => $result['inlineTopMostParentFieldName'] ?: $inlineTopMostParent['field'],

        ];


        // For foreign_selector with useCombination $mainChild is the mm record

        // and $combinationChild is the child-child. For 1:n "normal" relations,

        // $mainChild is just the normal child record and $combinationChild is empty.

        $mainChild = $formDataCompiler->compile($formDataCompilerInput);

        if ($parentConfig['foreign_selector'] && $parentConfig['appearance']['useCombination']) {

            try {

                $mainChild['combinationChild'] = $this->‪compileChildChild($mainChild, $parentConfig);

            } catch (‪DatabaseRecordException $e) {

                // The child could not be compiled, probably it was deleted and a dangling mm record

                // exists. This is a data inconsistency, we catch this exception and create a flash message

                $message = vsprintf(

                    $this->‪getLanguageService()->sL('LLL:EXT:backend/Resources/Private/Language/locallang.xlf:formEngine.databaseRecordErrorInlineChildChild'),

                    [$e->‪getTableName(), $e->‪getUid(), $childTableName, (int)$childUid]

                );

                $flashMessage = GeneralUtility::makeInstance(

                    FlashMessage::class,

                    $message,

                    '',

                    ‪FlashMessage::ERROR

                );

                GeneralUtility::makeInstance(FlashMessageService::class)->getMessageQueueByIdentifier()->enqueue($flashMessage);

            }

        }

        return $mainChild;

    }


    protected function ‪compileChildChild(array $child, array $parentConfig)

    {

        // foreign_selector on intermediate is probably type=select, so data provider of this table resolved that to the uid already

        $childChildUid = $child['databaseRow'][$parentConfig['foreign_selector']][0];

        // child-child table name is set in child tca "the selector field" foreign_table

        $childChildTableName = $child['processedTca']['columns'][$parentConfig['foreign_selector']]['config']['foreign_table'];

        $formDataGroup = GeneralUtility::makeInstance(TcaDatabaseRecord::class);

        $formDataCompiler = GeneralUtility::makeInstance(FormDataCompiler::class, $formDataGroup);


        $formDataCompilerInput = [

            'command' => 'edit',

            'tableName' => $childChildTableName,

            'vanillaUid' => (int)$childChildUid,

            'isInlineChild' => true,

            'isInlineChildExpanded' => $child['isInlineChildExpanded'],

            // @todo: this is the wrong inline structure, isn't it? Shouldn't it contain the part from child child, too?

            'inlineStructure' => $child['inlineStructure'],

            'inlineFirstPid' => $child['inlineFirstPid'],

            // values of the top most parent element set on first level and not overridden on following levels

            'inlineTopMostParentUid' => $child['inlineTopMostParentUid'],

            'inlineTopMostParentTableName' => $child['inlineTopMostParentTableName'],

            'inlineTopMostParentFieldName' => $child['inlineTopMostParentFieldName'],

        ];

        $childChild = $formDataCompiler->compile($formDataCompilerInput);

        return $childChild;

    }


    protected function ‪getWorkspacedUids(array $connectedUids, $childTableName)

    {

        $backendUser = $this->‪getBackendUser();

        $newConnectedUids = [];

        foreach ($connectedUids as $uid) {

            // Fetch workspace version of a record (if any):

            // @todo: Needs handling

            if ($backendUser->workspace !== 0 && ‪BackendUtility::isTableWorkspaceEnabled($childTableName)) {

                $workspaceVersion = ‪BackendUtility::getWorkspaceVersionOfRecord($backendUser->workspace, $childTableName, $uid, 'uid,t3ver_state');

                if (!empty($workspaceVersion)) {

                    $versionState = ‪VersionState::cast($workspaceVersion['t3ver_state']);

                    if ($versionState->equals(‪VersionState::DELETE_PLACEHOLDER)) {

                        continue;

                    }

                    $uid = $workspaceVersion['uid'];

                }

            }

            $newConnectedUids[] = $uid;

        }

        return $newConnectedUids;

    }


    protected function ‪resolveConnectedRecordUids(array $parentConfig, $parentTableName, $parentUid, $parentFieldValue)

    {

        $directlyConnectedIds = GeneralUtility::trimExplode(',', $parentFieldValue);

        if (empty($parentConfig['MM'])) {

            $parentUid = $this->‪getLiveDefaultId($parentTableName, $parentUid);

        }

        $relationHandler = GeneralUtility::makeInstance(RelationHandler::class);

        $relationHandler->registerNonTableValues = (bool)$parentConfig['allowedIdValues'];

        $relationHandler->start($parentFieldValue, $parentConfig['foreign_table'], $parentConfig['MM'], $parentUid, $parentTableName, $parentConfig);

        $foreignRecordUids = $relationHandler->getValueArray();

        $resolvedForeignRecordUids = [];

        foreach ($foreignRecordUids as $aForeignRecordUid) {

            if ($parentConfig['MM'] || $parentConfig['foreign_field']) {

                $resolvedForeignRecordUids[] = (int)$aForeignRecordUid;

            } else {

                foreach ($directlyConnectedIds as $id) {

                    if ((int)$aForeignRecordUid === (int)$id) {

                        $resolvedForeignRecordUids[] = (int)$aForeignRecordUid;

                    }

                }

            }

        }

        return $resolvedForeignRecordUids;

    }


    protected function ‪getLiveDefaultId($tableName, $uid)

    {

        $liveDefaultId = ‪BackendUtility::getLiveVersionIdOfRecord($tableName, $uid);

        if ($liveDefaultId === null) {

            $liveDefaultId = $uid;

        }

        return $liveDefaultId;

    }


    protected function ‪getBackendUser()

    {

        return ‪$GLOBALS['BE_USER'];

    }


    protected function ‪getLanguageService()

    {

        return ‪$GLOBALS['LANG'];

    }

}