BackendUtility.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Backend\Utility;
 
/*
 * 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 Psr\Log\LoggerInterface;
use ‪TYPO3\CMS\Backend\Backend\Shortcut\ShortcutRepository;
use ‪TYPO3\CMS\Backend\Routing\UriBuilder;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\DateTimeAspect;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryHelper;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\BackendWorkspaceRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\HiddenRestriction;
use ‪TYPO3\CMS\Core\Database\RelationHandler;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\Http\ServerRequest;
use ‪TYPO3\CMS\Core\Imaging\Icon;
use ‪TYPO3\CMS\Core\Imaging\IconFactory;
use ‪TYPO3\CMS\Core\Imaging\ImageManipulation\CropVariantCollection;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\Resource\AbstractFile;
use ‪TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\ProcessedFile;
use ‪TYPO3\CMS\Core\Resource\ResourceFactory;
use ‪TYPO3\CMS\Core\Routing\InvalidRouteArgumentsException;
use ‪TYPO3\CMS\Core\Routing\RouterInterface;
use ‪TYPO3\CMS\Core\Routing\SiteMatcher;
use ‪TYPO3\CMS\Core\Site\Entity\PseudoSite;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\Type\Bitmask\Permission;
use ‪TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\HttpUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
use ‪TYPO3\CMS\Core\Versioning\VersionState;
use ‪TYPO3\CMS\Frontend\Compatibility\LegacyDomainResolver;
use ‪TYPO3\CMS\Frontend\Page\PageRepository;
 
class ‪BackendUtility
{
    protected static ‪$tcaTableTypeConfigurationCache = [];
 
    /*******************************************
     *
     * SQL-related, selecting records, searching
     *
     *******************************************/
    public static function ‪deleteClause($table, $tableAlias = '')
    {
        trigger_error('BackendUtility::deleteClause() will be removed in TYPO3 v10.0. Add the delete statement directly in your SQL statement via the DeletedRestriction.', E_USER_DEPRECATED);
        if (empty(‪$GLOBALS['TCA'][$table]['ctrl']['delete'])) {
            return '';
        }
        $expressionBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($table)
            ->expr();
        return ' AND ' . $expressionBuilder->eq(
            ($tableAlias ?: $table) . '.' . ‪$GLOBALS['TCA'][$table]['ctrl']['delete'],
            0
        );
    }
 
    public static function ‪getRecord($table, $uid, ‪$fields = '*', $where = '', $useDeleteClause = true)
    {
        // Ensure we have a valid uid (not 0 and not NEWxxxx) and a valid TCA
        if ((int)$uid && !empty(‪$GLOBALS['TCA'][$table])) {
            $queryBuilder = static::getQueryBuilderForTable($table);
 
            // do not use enabled fields here
            $queryBuilder->getRestrictions()->removeAll();
 
            // should the delete clause be used
            if ($useDeleteClause) {
                $queryBuilder->getRestrictions()->add(GeneralUtility::makeInstance(DeletedRestriction::class));
            }
 
            // set table and where clause
            $queryBuilder
                ->select(...GeneralUtility::trimExplode(',', ‪$fields, true))
                ->from($table)
                ->where($queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter((int)$uid, \PDO::PARAM_INT)));
 
            // add custom where clause
            if ($where) {
                $queryBuilder->andWhere(‪QueryHelper::stripLogicalOperatorPrefix($where));
            }
 
            $row = $queryBuilder->execute()->fetch();
            if ($row) {
                return $row;
            }
        }
        return null;
    }
 
    public static function ‪getRecordWSOL(
        $table,
        $uid,
        ‪$fields = '*',
        $where = '',
        $useDeleteClause = true,
        $unsetMovePointers = false
    ) {
        if (‪$fields !== '*') {
            $internalFields = GeneralUtility::uniqueList(‪$fields . ',uid,pid');
            $row = ‪self::getRecord($table, $uid, $internalFields, $where, $useDeleteClause);
            ‪self::workspaceOL($table, $row, -99, $unsetMovePointers);
            if (is_array($row)) {
                foreach ($row as $key => $_) {
                    if (!GeneralUtility::inList(‪$fields, $key) && $key[0] !== '_') {
                        unset($row[$key]);
                    }
                }
            }
        } else {
            $row = ‪self::getRecord($table, $uid, ‪$fields, $where, $useDeleteClause);
            ‪self::workspaceOL($table, $row, -99, $unsetMovePointers);
        }
        return $row;
    }
 
    public static function ‪purgeComputedPropertiesFromRecord(array $record): array
    {
        return array_filter(
            $record,
            function (string $propertyName): bool {
                return $propertyName[0] !== '_';
            },
            ARRAY_FILTER_USE_KEY
        );
    }
 
    public static function ‪purgeComputedPropertyNames(array $propertyNames): array
    {
        return array_filter(
            $propertyNames,
            function (string $propertyName): bool {
                return $propertyName[0] !== '_';
            }
        );
    }
 
    public static function ‪splitTable_Uid($str)
    {
        list($uid, $table) = explode('_', strrev($str), 2);
        return [strrev($table), strrev($uid)];
    }
 
    public static function ‪BEenableFields($table, $inv = false)
    {
        $ctrl = ‪$GLOBALS['TCA'][$table]['ctrl'];
        $expressionBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable($table)
            ->getExpressionBuilder();
        $query = $expressionBuilder->andX();
        $invQuery = $expressionBuilder->orX();
 
        if (is_array($ctrl)) {
            if (is_array($ctrl['enablecolumns'])) {
                if ($ctrl['enablecolumns']['disabled'] ?? false) {
                    $field = $table . '.' . $ctrl['enablecolumns']['disabled'];
                    $query->add($expressionBuilder->eq($field, 0));
                    $invQuery->add($expressionBuilder->neq($field, 0));
                }
                if ($ctrl['enablecolumns']['starttime'] ?? false) {
                    $field = $table . '.' . $ctrl['enablecolumns']['starttime'];
                    $query->add($expressionBuilder->lte($field, (int)‪$GLOBALS['SIM_ACCESS_TIME']));
                    $invQuery->add(
                        $expressionBuilder->andX(
                            $expressionBuilder->neq($field, 0),
                            $expressionBuilder->gt($field, (int)‪$GLOBALS['SIM_ACCESS_TIME'])
                        )
                    );
                }
                if ($ctrl['enablecolumns']['endtime'] ?? false) {
                    $field = $table . '.' . $ctrl['enablecolumns']['endtime'];
                    $query->add(
                        $expressionBuilder->orX(
                            $expressionBuilder->eq($field, 0),
                            $expressionBuilder->gt($field, (int)‪$GLOBALS['SIM_ACCESS_TIME'])
                        )
                    );
                    $invQuery->add(
                        $expressionBuilder->andX(
                            $expressionBuilder->neq($field, 0),
                            $expressionBuilder->lte($field, (int)‪$GLOBALS['SIM_ACCESS_TIME'])
                        )
                    );
                }
            }
        }
 
        if ($query->count() === 0) {
            return '';
        }
 
        return ' AND ' . ($inv ? $invQuery : $query);
    }
 
    public static function ‪getRecordLocalization($table, $uid, $language, $andWhereClause = '')
    {
        $recordLocalization = false;
 
        if (self::isTableLocalizable($table)) {
            $tcaCtrl = ‪$GLOBALS['TCA'][$table]['ctrl'];
 
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable($table);
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
                ->add(GeneralUtility::makeInstance(BackendWorkspaceRestriction::class));
 
            $queryBuilder->select('*')
                ->from($table)
                ->where(
                    $queryBuilder->expr()->eq(
                        $tcaCtrl['translationSource'] ?? $tcaCtrl['transOrigPointerField'],
                        $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        $tcaCtrl['languageField'],
                        $queryBuilder->createNamedParameter((int)$language, \PDO::PARAM_INT)
                    )
                )
                ->setMaxResults(1);
 
            if ($andWhereClause) {
                $queryBuilder->andWhere(‪QueryHelper::stripLogicalOperatorPrefix($andWhereClause));
            }
 
            $recordLocalization = $queryBuilder->execute()->fetchAll();
        }
 
        return $recordLocalization;
    }
 
    /*******************************************
     *
     * Page tree, TCA related
     *
     *******************************************/
    public static function ‪BEgetRootLine($uid, $clause = '', $workspaceOL = false, array $additionalFields = [])
    {
        $runtimeCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_runtime');
        $beGetRootLineCache = $runtimeCache->get('backendUtilityBeGetRootLine') ?: [];
        ‪$output = [];
        $pid = $uid;
        $ident = $pid . '-' . $clause . '-' . $workspaceOL . ($additionalFields ? '-' . md5(implode(',', $additionalFields)) : '');
        if (is_array($beGetRootLineCache[$ident] ?? false)) {
            ‪$output = $beGetRootLineCache[$ident];
        } else {
            $loopCheck = 100;
            $theRowArray = [];
            while ($uid != 0 && $loopCheck) {
                $loopCheck--;
                $row = ‪self::getPageForRootline($uid, $clause, $workspaceOL, $additionalFields);
                if (is_array($row)) {
                    $uid = $row['pid'];
                    $theRowArray[] = $row;
                } else {
                    break;
                }
            }
            ‪$fields = [
                'uid',
                'pid',
                'title',
                'doktype',
                'slug',
                'tsconfig_includes',
                'TSconfig',
                'is_siteroot',
                't3ver_oid',
                't3ver_wsid',
                't3ver_state',
                't3ver_stage',
                'backend_layout_next_level',
                'hidden',
                'starttime',
                'endtime',
                'fe_group',
                'nav_hide',
                'content_from_pid',
                'module',
                'extendToSubpages'
            ];
            ‪$fields = array_merge(‪$fields, $additionalFields);
            $rootPage = array_fill_keys(‪$fields, null);
            if ($uid == 0) {
                $rootPage['uid'] = 0;
                $theRowArray[] = $rootPage;
            }
            $c = count($theRowArray);
            foreach ($theRowArray as $val) {
                $c--;
                ‪$output[$c] = array_intersect_key($val, $rootPage);
                if (isset($val['_ORIG_pid'])) {
                    ‪$output[$c]['_ORIG_pid'] = $val['_ORIG_pid'];
                }
            }
            $beGetRootLineCache[$ident] = ‪$output;
            $runtimeCache->set('backendUtilityBeGetRootLine', $beGetRootLineCache);
        }
        return ‪$output;
    }
 
    protected static function ‪getPageForRootline($uid, $clause, $workspaceOL, array $additionalFields = [])
    {
        $runtimeCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_runtime');
        $pageForRootlineCache = $runtimeCache->get('backendUtilityPageForRootLine') ?: [];
        $statementCacheIdent = md5($clause . ($additionalFields ? '-' . implode(',', $additionalFields) : ''));
        $ident = $uid . '-' . $workspaceOL . '-' . $statementCacheIdent;
        if (is_array($pageForRootlineCache[$ident] ?? false)) {
            $row = $pageForRootlineCache[$ident];
        } else {
            $statement = $runtimeCache->get('getPageForRootlineStatement-' . $statementCacheIdent);
            if (!$statement) {
                $queryBuilder = static::getQueryBuilderForTable('pages');
                $queryBuilder->getRestrictions()
                             ->removeAll()
                             ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
                $queryBuilder
                    ->select(
                        'pid',
                        'uid',
                        'title',
                        'doktype',
                        'slug',
                        'tsconfig_includes',
                        'TSconfig',
                        'is_siteroot',
                        't3ver_oid',
                        't3ver_wsid',
                        't3ver_state',
                        't3ver_stage',
                        'backend_layout_next_level',
                        'hidden',
                        'starttime',
                        'endtime',
                        'fe_group',
                        'nav_hide',
                        'content_from_pid',
                        'module',
                        'extendToSubpages',
                        ...$additionalFields
                    )
                    ->from('pages')
                    ->where(
                        $queryBuilder->expr()->eq('uid', $queryBuilder->createPositionalParameter($uid, \PDO::PARAM_INT)),
                        ‪QueryHelper::stripLogicalOperatorPrefix($clause)
                    );
                $statement = $queryBuilder->execute();
                $runtimeCache->set('getPageForRootlineStatement-' . $statementCacheIdent, $statement);
            } else {
                $statement->bindValue(1, (int)$uid);
                $statement->execute();
            }
            $row = $statement->fetch();
            $statement->closeCursor();
 
            if ($row) {
                $newLocation = false;
                if ($workspaceOL) {
                    ‪self::workspaceOL('pages', $row);
                    if (is_array($row) && (int)$row['t3ver_state'] === ‪VersionState::MOVE_POINTER) {
                        $newLocation = ‪self::getMovePlaceholder('pages', $row['uid'], 'pid');
                    }
                }
                if (is_array($row)) {
                    if ($newLocation !== false) {
                        $row['pid'] = $newLocation['pid'];
                    } else {
                        ‪self::fixVersioningPid('pages', $row);
                    }
                    $pageForRootlineCache[$ident] = $row;
                    $runtimeCache->set('backendUtilityPageForRootLine', $pageForRootlineCache);
                }
            }
        }
        return $row;
    }
 
    public static function ‪openPageTree($pid, $clearExpansion)
    {
        $beUser = static::getBackendUserAuthentication();
        // Get current expansion data:
        if ($clearExpansion) {
            $expandedPages = [];
        } else {
            $expandedPages = unserialize($beUser->uc['browseTrees']['browsePages'], ['allowed_classes' => false]);
        }
        // Get rootline:
        $rL = ‪self::BEgetRootLine($pid);
        // First, find out what mount index to use (if more than one DB mount exists):
        $mountIndex = 0;
        $mountKeys = array_flip($beUser->returnWebmounts());
        foreach ($rL as $rLDat) {
            if (isset($mountKeys[$rLDat['uid']])) {
                $mountIndex = $mountKeys[$rLDat['uid']];
                break;
            }
        }
        // Traverse rootline and open paths:
        foreach ($rL as $rLDat) {
            $expandedPages[$mountIndex][$rLDat['uid']] = 1;
        }
        // Write back:
        $beUser->uc['browseTrees']['browsePages'] = serialize($expandedPages);
        $beUser->writeUC();
    }
 
    public static function ‪getRecordPath($uid, $clause, $titleLimit, $fullTitleLimit = 0)
    {
        if (!$titleLimit) {
            $titleLimit = 1000;
        }
        ‪$output = $fullOutput = '/';
        $clause = trim($clause);
        if ($clause !== '' && strpos($clause, 'AND') !== 0) {
            $clause = 'AND ' . $clause;
        }
        $data = ‪self::BEgetRootLine($uid, $clause, true);
        foreach ($data as $record) {
            if ($record['uid'] === 0) {
                continue;
            }
            ‪$output = '/' . GeneralUtility::fixed_lgd_cs(strip_tags($record['title']), $titleLimit) . ‪$output;
            if ($fullTitleLimit) {
                $fullOutput = '/' . GeneralUtility::fixed_lgd_cs(strip_tags($record['title']), $fullTitleLimit) . $fullOutput;
            }
        }
        if ($fullTitleLimit) {
            return [‪$output, $fullOutput];
        }
        return ‪$output;
    }
 
    public static function ‪getOriginalTranslationTable($table)
    {
        trigger_error('Starting with TYPO3 v9, the translation table is always the same as the original table, because pages_language_overlay has been migrated into pages table.', E_USER_DEPRECATED);
        return $table;
    }
 
    public static function ‪isTableLocalizable($table)
    {
        $isLocalizable = false;
        if (isset(‪$GLOBALS['TCA'][$table]['ctrl']) && is_array(‪$GLOBALS['TCA'][$table]['ctrl'])) {
            $tcaCtrl = ‪$GLOBALS['TCA'][$table]['ctrl'];
            $isLocalizable = isset($tcaCtrl['languageField']) && $tcaCtrl['languageField'] && isset($tcaCtrl['transOrigPointerField']) && $tcaCtrl['transOrigPointerField'];
        }
        return $isLocalizable;
    }
 
    public static function ‪readPageAccess($id, $perms_clause)
    {
        if ((string)$id !== '') {
            $id = (int)$id;
            if (!$id) {
                if (static::getBackendUserAuthentication()->isAdmin()) {
                    return ['_thePath' => '/'];
                }
            } else {
                $pageinfo = ‪self::getRecord('pages', $id, '*', $perms_clause);
                if ($pageinfo['uid'] && static::getBackendUserAuthentication()->isInWebMount($pageinfo, $perms_clause)) {
                    ‪self::workspaceOL('pages', $pageinfo);
                    if (is_array($pageinfo)) {
                        ‪self::fixVersioningPid('pages', $pageinfo);
                        list($pageinfo['_thePath'], $pageinfo['_thePathFull']) = ‪self::getRecordPath((int)$pageinfo['uid'], $perms_clause, 15, 1000);
                        return $pageinfo;
                    }
                }
            }
        }
        return false;
    }
 
    public static function ‪getTCAtypes($table, $rec, $useFieldNameAsKey = false)
    {
        trigger_error('BackendUtility::getTCAtypes() will be removed in TYPO3 v10.0. The method is not in use anymore.', E_USER_DEPRECATED);
        if (isset(‪$GLOBALS['TCA'][$table])) {
            // Get type value:
            $fieldValue = ‪self::getTCAtypeValue($table, $rec);
            $cacheIdentifier = $table . '-type-' . $fieldValue . '-fnk-' . $useFieldNameAsKey;
 
            // Fetch from first-level-cache if available
            if (isset(self::$tcaTableTypeConfigurationCache[$cacheIdentifier])) {
                return self::$tcaTableTypeConfigurationCache[$cacheIdentifier];
            }
 
            // Get typesConf
            $typesConf = ‪$GLOBALS['TCA'][$table]['types'][$fieldValue] ?? null;
            // Get fields list and traverse it
            $fieldList = explode(',', $typesConf['showitem']);
 
            // Add subtype fields e.g. for a valid RTE transformation
            // The RTE runs the DB -> RTE transformation only, if the RTE field is part of the getTCAtypes array
            if (isset($typesConf['subtype_value_field'])) {
                $subType = $rec[$typesConf['subtype_value_field']];
                if (isset($typesConf['subtypes_addlist'][$subType])) {
                    $subFields = GeneralUtility::trimExplode(',', $typesConf['subtypes_addlist'][$subType], true);
                    $fieldList = array_merge($fieldList, $subFields);
                }
            }
 
            // Add palette fields e.g. for a valid RTE transformation
            $paletteFieldList = [];
            foreach ($fieldList as $fieldData) {
                $fieldDataArray = GeneralUtility::trimExplode(';', $fieldData);
                // first two entries would be fieldname and altTitle, they are not used here.
                $pPalette = $fieldDataArray[2] ?? null;
                if ($pPalette
                    && isset(‪$GLOBALS['TCA'][$table]['palettes'][$pPalette])
                    && is_array(‪$GLOBALS['TCA'][$table]['palettes'][$pPalette])
                    && isset(‪$GLOBALS['TCA'][$table]['palettes'][$pPalette]['showitem'])
                ) {
                    $paletteFields = GeneralUtility::trimExplode(',', ‪$GLOBALS['TCA'][$table]['palettes'][$pPalette]['showitem'], true);
                    foreach ($paletteFields as $paletteField) {
                        if ($paletteField !== '--linebreak--') {
                            $paletteFieldList[] = $paletteField;
                        }
                    }
                }
            }
            $fieldList = array_merge($fieldList, $paletteFieldList);
            $altFieldList = [];
            // Traverse fields in types config and parse the configuration into a nice array:
            foreach ($fieldList as $k => $v) {
                $vArray = GeneralUtility::trimExplode(';', $v);
                $fieldList[$k] = [
                    'field' => $vArray[0],
                    'title' => $vArray[1] ?? null,
                    'palette' => $vArray[2] ?? null,
                    'spec' => [],
                    'origString' => $v
                ];
                if ($useFieldNameAsKey) {
                    $altFieldList[$fieldList[$k]['field']] = $fieldList[$k];
                }
            }
            if ($useFieldNameAsKey) {
                $fieldList = $altFieldList;
            }
 
            // Add to first-level-cache
            self::$tcaTableTypeConfigurationCache[$cacheIdentifier] = $fieldList;
 
            // Return array:
            return $fieldList;
        }
        return null;
    }
 
    public static function ‪getTCAtypeValue($table, $row)
    {
        $typeNum = 0;
        if (‪$GLOBALS['TCA'][$table]) {
            $field = ‪$GLOBALS['TCA'][$table]['ctrl']['type'];
            if (strpos($field, ':') !== false) {
                list($pointerField, $foreignTableTypeField) = explode(':', $field);
                // Get field value from database if field is not in the $row array
                if (!isset($row[$pointerField])) {
                    $localRow = ‪self::getRecord($table, $row['uid'], $pointerField);
                    $foreignUid = $localRow[$pointerField];
                } else {
                    $foreignUid = $row[$pointerField];
                }
                if ($foreignUid) {
                    $fieldConfig = ‪$GLOBALS['TCA'][$table]['columns'][$pointerField]['config'];
                    $relationType = $fieldConfig['type'];
                    if ($relationType === 'select') {
                        $foreignTable = $fieldConfig['foreign_table'];
                    } elseif ($relationType === 'group') {
                        $allowedTables = explode(',', $fieldConfig['allowed']);
                        $foreignTable = $allowedTables[0];
                    } else {
                        throw new \RuntimeException(
                            'TCA foreign field pointer fields are only allowed to be used with group or select field types.',
                            1325862240
                        );
                    }
                    $foreignRow = ‪self::getRecord($foreignTable, $foreignUid, $foreignTableTypeField);
                    if ($foreignRow[$foreignTableTypeField]) {
                        $typeNum = $foreignRow[$foreignTableTypeField];
                    }
                }
            } else {
                $typeNum = $row[$field];
            }
            // If that value is an empty string, set it to "0" (zero)
            if (empty($typeNum)) {
                $typeNum = 0;
            }
        }
        // If current typeNum doesn't exist, set it to 0 (or to 1 for historical reasons, if 0 doesn't exist)
        if (!isset(‪$GLOBALS['TCA'][$table]['types'][$typeNum]) || !‪$GLOBALS['TCA'][$table]['types'][$typeNum]) {
            $typeNum = isset(‪$GLOBALS['TCA'][$table]['types']['0']) ? 0 : 1;
        }
        // Force to string. Necessary for eg '-1' to be recognized as a type value.
        $typeNum = (string)$typeNum;
        return $typeNum;
    }
 
    /*******************************************
     *
     * Caching related
     *
     *******************************************/
    public static function ‪storeHash($hash, $data, $ident)
    {
        trigger_error('BackendUtility::storeHash() will be removed in TYPO3 v10.0, use the Caching Framework directly.', E_USER_DEPRECATED);
        $cacheManager = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Cache\CacheManager::class);
        $cacheManager->getCache('cache_hash')->set($hash, $data, ['ident_' . $ident], 0);
    }
 
    public static function ‪getHash($hash)
    {
        trigger_error('BackendUtility::getHash() will be removed in TYPO3 v10.0, use the Caching Framework directly.', E_USER_DEPRECATED);
        $cacheManager = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Cache\CacheManager::class);
        $cacheEntry = $cacheManager->getCache('cache_hash')->get($hash);
        $hashContent = null;
        if ($cacheEntry) {
            $hashContent = $cacheEntry;
        }
        return $hashContent;
    }
 
    /*******************************************
     *
     * TypoScript related
     *
     *******************************************/
    public static function ‪getPagesTSconfig($id, $rootLine = null, $returnPartArray = false)
    {
        $id = (int)$id;
 
        $cache = ‪self::getRuntimeCache();
        if ($returnPartArray === false
            && $rootLine === null
            && $cache->has('pagesTsConfigIdToHash' . $id)
        ) {
            return $cache->get('pagesTsConfigHashToContent' . $cache->get('pagesTsConfigIdToHash' . $id));
        }
        $tsConfig = [];
        // No custom rootline, so the results can be cached
        if (!is_array($rootLine)) {
            $rootLine = ‪self::BEgetRootLine($id, '', true);
            $useCacheForCurrentPageId = true;
        } else {
            trigger_error('Calling BackendUtility::getPagesTSconfig() with a custom rootline handed over as second argument will be removed in TYPO3 v10.0. Use TYPO3\CMS\Backend\Utility\BackendUtility::getRawPagesTSconfig() instead and parse PageTS yourself.', E_USER_DEPRECATED);
            $useCacheForCurrentPageId = false;
        }
 
        $TSdataArray = static::getRawPagesTSconfig($id, $rootLine);
        if ($returnPartArray) {
            trigger_error('Calling BackendUtility::getPagesTSconfig() with a third parameter to return the unparsed array directly will be removed in TYPO3 v10.0. Use TYPO3\CMS\Backend\Utility\BackendUtility::getRawPagesTSconfig() instead.', E_USER_DEPRECATED);
            return $TSdataArray;
        }
        // Parsing the page TS-Config
        $pageTs = implode(LF . '[GLOBAL]' . LF, $TSdataArray);
        /* @var \TYPO3\CMS\Backend\Configuration\TsConfigParser $parseObj */
        $parseObj = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Configuration\TsConfigParser::class);
        $res = $parseObj->parseTSconfig($pageTs, 'PAGES', $id, $rootLine);
        if ($res) {
            $tsConfig = $res['TSconfig'];
        }
        $cacheHash = $res['hash'];
        // Get User TSconfig overlay, if no backend user is logged-in, this needs to be checked as well
        if (static::getBackendUserAuthentication()) {
            $userTSconfig = static::getBackendUserAuthentication()->getTSConfig() ?? [];
        } else {
            $userTSconfig = [];
        }
        $isCacheHashExtendedWithUserUid = false;
        if (is_array($userTSconfig['page.'] ?? null)) {
            ‪ArrayUtility::mergeRecursiveWithOverrule($tsConfig, $userTSconfig['page.']);
            $isCacheHashExtendedWithUserUid = true;
            $cacheHash .= '_user' . static::getBackendUserAuthentication()->user['uid'];
        }
 
        // Overlay page "mod." ts with user ts in a special and deprecated way
        if (is_array($userTSconfig['mod.'] ?? null)) {
            // @deprecated This entire "if" and variable $isCacheHashExtendedWithUserUid can be deleted in TYPO3 v10.0
            trigger_error(
                'Overriding page TSconfig "mod." with user TSconfig "mod." is deprecated. Use user TSconfig "page.mod." instead.',
                E_USER_DEPRECATED
            );
            if (!is_array($tsConfig['mod.'])) {
                $tsConfig['mod.'] = [];
            }
            ‪ArrayUtility::mergeRecursiveWithOverrule($tsConfig['mod.'], $userTSconfig['mod.']);
            if (!$isCacheHashExtendedWithUserUid) {
                $cacheHash .= '_user' . static::getBackendUserAuthentication()->user['uid'];
            }
        }
 
        if ($useCacheForCurrentPageId) {
            // Many pages end up with the same ts config. To reduce memory usage, the cache
            // entries are a linked list: One or more pids point to content hashes which then
            // contain the cached content.
            $cache->set('pagesTsConfigHashToContent' . $cacheHash, $tsConfig, ['pagesTsConfig']);
            $cache->set('pagesTsConfigIdToHash' . $id, $cacheHash, ['pagesTsConfig']);
        }
 
        return $tsConfig;
    }
 
    public static function ‪getRawPagesTSconfig($id, array $rootLine = null)
    {
        if (!is_array($rootLine)) {
            $rootLine = ‪self::BEgetRootLine($id, '', true);
        }
 
        // Order correctly
        ksort($rootLine);
        $tsDataArray = [];
        // Setting default configuration
        $tsDataArray['defaultPageTSconfig'] = ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'];
        foreach ($rootLine as $k => $v) {
            if (trim($v['tsconfig_includes'])) {
                $includeTsConfigFileList = GeneralUtility::trimExplode(',', $v['tsconfig_includes'], true);
                // Traversing list
                foreach ($includeTsConfigFileList as $key => $includeTsConfigFile) {
                    if (strpos($includeTsConfigFile, 'EXT:') === 0) {
                        list($includeTsConfigFileExtensionKey, $includeTsConfigFilename) = explode(
                            '/',
                            substr($includeTsConfigFile, 4),
                            2
                        );
                        if ((string)$includeTsConfigFileExtensionKey !== ''
                            && ‪ExtensionManagementUtility::isLoaded($includeTsConfigFileExtensionKey)
                            && (string)$includeTsConfigFilename !== ''
                        ) {
                            $extensionPath = ‪ExtensionManagementUtility::extPath($includeTsConfigFileExtensionKey);
                            $includeTsConfigFileAndPath = ‪PathUtility::getCanonicalPath($extensionPath . $includeTsConfigFilename);
                            if (strpos($includeTsConfigFileAndPath, $extensionPath) === 0 && file_exists($includeTsConfigFileAndPath)) {
                                $tsDataArray['uid_' . $v['uid'] . '_static_' . $key] = file_get_contents($includeTsConfigFileAndPath);
                            }
                        }
                    }
                }
            }
            $tsDataArray['uid_' . $v['uid']] = $v['TSconfig'];
        }
 
        $tsDataArray = static::emitGetPagesTSconfigPreIncludeSignal($tsDataArray, $id, $rootLine);
        $tsDataArray = ‪TypoScriptParser::checkIncludeLines_array($tsDataArray);
 
        return $tsDataArray;
    }
 
    /*******************************************
     *
     * Users / Groups related
     *
     *******************************************/
    public static function ‪getUserNames(‪$fields = 'username,usergroup,usergroup_cached_list,uid', $where = '')
    {
        return ‪self::getRecordsSortedByTitle(
            GeneralUtility::trimExplode(',', ‪$fields, true),
            'be_users',
            'username',
            'AND pid=0 ' . $where
        );
    }
 
    public static function ‪getGroupNames(‪$fields = 'title,uid', $where = '')
    {
        return ‪self::getRecordsSortedByTitle(
            GeneralUtility::trimExplode(',', ‪$fields, true),
            'be_groups',
            'title',
            'AND pid=0 ' . $where
        );
    }
 
    protected static function ‪getRecordsSortedByTitle(array ‪$fields, $table, $titleField, $where = '')
    {
        $fieldsIndex = array_flip(‪$fields);
        // Make sure the titleField is amongst the fields when getting sorted
        $fieldsIndex[$titleField] = 1;
 
        $result = [];
 
        $queryBuilder = static::getQueryBuilderForTable($table);
        $queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
        $res = $queryBuilder
            ->select('*')
            ->from($table)
            ->where(‪QueryHelper::stripLogicalOperatorPrefix($where))
            ->execute();
 
        while ($record = $res->fetch()) {
            // store the uid, because it might be unset if it's not among the requested $fields
            $recordId = $record['uid'];
            $record[$titleField] = ‪self::getRecordTitle($table, $record);
 
            // include only the requested fields in the result
            $result[$recordId] = array_intersect_key($record, $fieldsIndex);
        }
 
        // sort records by $sortField. This is not done in the query because the title might have been overwritten by
        // self::getRecordTitle();
        return ‪ArrayUtility::sortArraysByKey($result, $titleField);
    }
 
    public static function ‪getListGroupNames(‪$fields = 'title, uid')
    {
        trigger_error('BackendUtility::getListGroupNames() will be removed in TYPO3 v10.0, you should generate the list of backend user groups by yourself.', E_USER_DEPRECATED);
        $beUser = static::getBackendUserAuthentication();
        $exQ = '';
        if (!$beUser->isAdmin()) {
            $exQ = ' AND uid IN (' . ($beUser->user['usergroup_cached_list'] ?: 0) . ')';
        }
        return ‪self::getGroupNames(‪$fields, $exQ);
    }
 
    public static function ‪blindUserNames($usernames, $groupArray, $excludeBlindedFlag = false)
    {
        if (is_array($usernames) && is_array($groupArray)) {
            foreach ($usernames as $uid => $row) {
                $userN = $uid;
                $set = 0;
                if ($row['uid'] != static::getBackendUserAuthentication()->user['uid']) {
                    foreach ($groupArray as $v) {
                        if ($v && GeneralUtility::inList($row['usergroup_cached_list'], $v)) {
                            $userN = $row['username'];
                            $set = 1;
                        }
                    }
                } else {
                    $userN = $row['username'];
                    $set = 1;
                }
                $usernames[$uid]['username'] = $userN;
                if ($excludeBlindedFlag && !$set) {
                    unset($usernames[$uid]);
                }
            }
        }
        return $usernames;
    }
 
    public static function ‪blindGroupNames($groups, $groupArray, $excludeBlindedFlag = false)
    {
        if (is_array($groups) && is_array($groupArray)) {
            foreach ($groups as $uid => $row) {
                $groupN = $uid;
                $set = 0;
                if (in_array($uid, $groupArray, false)) {
                    $groupN = $row['title'];
                    $set = 1;
                }
                $groups[$uid]['title'] = $groupN;
                if ($excludeBlindedFlag && !$set) {
                    unset($groups[$uid]);
                }
            }
        }
        return $groups;
    }
 
    /*******************************************
     *
     * Output related
     *
     *******************************************/
    public static function ‪daysUntil($tstamp)
    {
        $delta_t = $tstamp - ‪$GLOBALS['EXEC_TIME'];
        return ceil($delta_t / (3600 * 24));
    }
 
    public static function ‪date($tstamp)
    {
        return ‪date(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'], (int)$tstamp);
    }
 
    public static function ‪datetime($value)
    {
        return ‪date(
            ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'] . ' ' . ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'],
            $value
        );
    }
 
    public static function ‪time($value, $withSeconds = true)
    {
        return gmdate('H:i' . ($withSeconds ? ':s' : ''), (int)$value);
    }
 
    public static function ‪calcAge($seconds, $labels = 'min|hrs|days|yrs|min|hour|day|year')
    {
        $labelArr = GeneralUtility::trimExplode('|', $labels, true);
        $absSeconds = abs($seconds);
        $sign = $seconds < 0 ? -1 : 1;
        if ($absSeconds < 3600) {
            $val = round($absSeconds / 60);
            $seconds = $sign * $val . ' ' . ($val == 1 ? $labelArr[4] : $labelArr[0]);
        } elseif ($absSeconds < 24 * 3600) {
            $val = round($absSeconds / 3600);
            $seconds = $sign * $val . ' ' . ($val == 1 ? $labelArr[5] : $labelArr[1]);
        } elseif ($absSeconds < 365 * 24 * 3600) {
            $val = round($absSeconds / (24 * 3600));
            $seconds = $sign * $val . ' ' . ($val == 1 ? $labelArr[6] : $labelArr[2]);
        } else {
            $val = round($absSeconds / (365 * 24 * 3600));
            $seconds = $sign * $val . ' ' . ($val == 1 ? $labelArr[7] : $labelArr[3]);
        }
        return $seconds;
    }
 
    public static function ‪dateTimeAge($tstamp, $prefix = 1, $date = '')
    {
        if (!$tstamp) {
            return '';
        }
        $label = static::getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.minutesHoursDaysYears');
        $age = ' (' . ‪self::calcAge($prefix * (‪$GLOBALS['EXEC_TIME'] - $tstamp), $label) . ')';
        return ($date === 'date' ? self::date($tstamp) : self::datetime($tstamp)) . $age;
    }
 
    public static function ‪resolveFileReferences($tableName, $fieldName, $element, $workspaceId = null)
    {
        if (empty(‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'])) {
            return null;
        }
        $configuration = ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'];
        if (empty($configuration['type']) || $configuration['type'] !== 'inline'
            || empty($configuration['foreign_table']) || $configuration['foreign_table'] !== 'sys_file_reference'
        ) {
            return null;
        }
 
        $fileReferences = [];
        $relationHandler = GeneralUtility::makeInstance(RelationHandler::class);
        if ($workspaceId !== null) {
            $relationHandler->setWorkspaceId($workspaceId);
        }
        $relationHandler->start(
            $element[$fieldName],
            $configuration['foreign_table'],
            $configuration['MM'] ?? '',
            $element['uid'],
            $tableName,
            $configuration
        );
        $relationHandler->processDeletePlaceholder();
        $referenceUids = $relationHandler->tableArray[$configuration['foreign_table']];
 
        foreach ($referenceUids as $referenceUid) {
            try {
                $fileReference = ‪ResourceFactory::getInstance()->‪getFileReferenceObject(
                    $referenceUid,
                    [],
                    $workspaceId === 0
                );
                $fileReferences[$fileReference->getUid()] = $fileReference;
            } catch (\‪TYPO3\CMS\Core\Resource\‪Exception\FileDoesNotExistException $e) {
            } catch (\InvalidArgumentException $e) {
                ‪self::getLogger()->error($e->getMessage(), ['table' => $tableName, 'fieldName' => $fieldName, 'referenceUid' => $referenceUid, 'exception' => $e]);
            }
        }
 
        return $fileReferences;
    }
 
    public static function ‪thumbCode(
        $row,
        $table,
        $field,
        $backPath = '',
        $thumbScript = '',
        $uploaddir = null,
        $abs = 0,
        $tparams = '',
        $size = '',
        $linkInfoPopup = true
    ) {
        // Check and parse the size parameter
        $size = trim($size);
        $sizeParts = [64, 64];
        if ($size) {
            $sizeParts = explode('x', $size . 'x' . $size);
        }
        $thumbData = '';
        $fileReferences = static::resolveFileReferences($table, $field, $row);
        // FAL references
        $iconFactory = GeneralUtility::makeInstance(IconFactory::class);
        if ($fileReferences !== null) {
            foreach ($fileReferences as $fileReferenceObject) {
                // Do not show previews of hidden references
                if ($fileReferenceObject->getProperty('hidden')) {
                    continue;
                }
                $fileObject = $fileReferenceObject->getOriginalFile();
 
                if ($fileObject->isMissing()) {
                    $thumbData .= '<span class="label label-danger">'
                        . htmlspecialchars(
                            static::getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:warning.file_missing')
                        )
                        . '</span>&nbsp;' . htmlspecialchars($fileObject->getName()) . '<br />';
                    continue;
                }
 
                // Preview web image or media elements
                if (‪$GLOBALS['TYPO3_CONF_VARS']['GFX']['thumbnails']
                    && GeneralUtility::inList(
                        ‪$GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'],
                        $fileReferenceObject->getExtension()
                    )
                ) {
                    $cropVariantCollection = ‪CropVariantCollection::create((string)$fileReferenceObject->getProperty('crop'));
                    $cropArea = $cropVariantCollection->getCropArea();
                    $parameters = json_encode([
                        'fileId' => $fileObject->getUid(),
                        'configuration' => [
                            'width' => $sizeParts[0],
                            'height' => $sizeParts[1] . 'c',
                            'crop' => $cropArea->isEmpty() ? null : $cropArea->makeAbsoluteBasedOnFile($fileReferenceObject),
                        ]
                    ]);
                    $uriParameters = [
                        'parameters' => $parameters,
                        'hmac' => GeneralUtility::hmac(
                            $parameters,
                            \‪TYPO3\CMS\Backend\Controller\‪File\ThumbnailController::class
                        ),
                    ];
                    $imageUrl = (string)GeneralUtility::makeInstance(UriBuilder::class)
                        ->buildUriFromRoute('thumbnails', $uriParameters);
                    $attributes = [
                        'src' => $imageUrl,
                        'width' => (int)$sizeParts[0],
                        'height' => (int)$sizeParts[1],
                        'alt' => $fileReferenceObject->getName(),
                    ];
                    $imgTag = '<img ' . GeneralUtility::implodeAttributes($attributes, true) . $tparams . '/>';
                } else {
                    // Icon
                    $imgTag = '<span title="' . htmlspecialchars($fileObject->getName()) . '">'
                        . $iconFactory->getIconForResource($fileObject, ‪Icon::SIZE_SMALL)->render()
                        . '</span>';
                }
                if ($linkInfoPopup) {
                    $onClick = 'top.TYPO3.InfoWindow.showItem(\'_FILE\',\'' . (int)$fileObject->getUid() . '\'); return false;';
                    $thumbData .= '<a href="#" onclick="' . htmlspecialchars($onClick) . '">' . $imgTag . '</a> ';
                } else {
                    $thumbData .= $imgTag;
                }
            }
        } else {
            // Find uploaddir automatically
            if ($uploaddir === null) {
                $uploaddir = $GLOBALS['TCA'][$table]['columns'][$field]['config']['uploadfolder'];
            }
            $uploaddir = rtrim($uploaddir, '/');
            // Traverse files:
            $thumbs = GeneralUtility::trimExplode(',', $row[$field], true);
            $thumbData = '';
            foreach ($thumbs as $theFile) {
                if ($theFile) {
                    $fileName = trim($uploaddir . '/' . $theFile, '/');
                    try {
                        $fileObject = ResourceFactory::getInstance()->retrieveFileOrFolderObject($fileName);
                        // Skip the resource if it's not of type ‪AbstractFile. One case where this can happen if the
                        // storage has been externally modified and the field value now points to a folder
                        // instead of a file.
                        if (!$fileObject instanceof ‪AbstractFile) {
                            continue;
                        }
                        if ($fileObject->isMissing()) {
                            $thumbData .= '<span class="label label-danger">'
                                . htmlspecialchars(static::getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:warning.file_missing'))
                                . '</span>&nbsp;' . htmlspecialchars($fileObject->getName()) . '<br />';
                            continue;
                        }
                    } catch (‪ResourceDoesNotExistException $exception) {
                        $thumbData .= '<span class="label label-danger">'
                            . htmlspecialchars(static::getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:warning.file_missing'))
                            . '</span>&nbsp;' . htmlspecialchars($fileName) . '<br />';
                        continue;
                    }
 
                    $fileExtension = $fileObject->‪getExtension();
                    if ($fileExtension === 'ttf'
                        || GeneralUtility::inList(‪$GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'], $fileExtension)
                    ) {
                        $imageUrl = $fileObject->process(
                            ‪ProcessedFile::CONTEXT_IMAGEPREVIEW,
                            [
                                'width' => $sizeParts[0],
                                'height' => $sizeParts[1]
                            ]
                        )->getPublicUrl(true);
 
                        $image = '<img src="' . htmlspecialchars($imageUrl) . '" hspace="2" border="0" title="' . htmlspecialchars($fileObject->getName()) . '"' . $tparams . ' alt="" />';
                        if ($linkInfoPopup) {
                            $onClick = 'top.TYPO3.InfoWindow.showItem(\'_FILE\', ' . GeneralUtility::quoteJSvalue($fileName) . ',\'\');return false;';
                            $thumbData .= '<a href="#" onclick="' . htmlspecialchars($onClick) . '">' . $image . '</a> ';
                        } else {
                            $thumbData .= $image;
                        }
                    } else {
                        // Gets the icon
                        $fileIcon = '<span title="' . htmlspecialchars($fileObject->getName()) . '">'
                            . $iconFactory->getIconForResource($fileObject, ‪Icon::SIZE_SMALL)->render()
                            . '</span>';
                        if ($linkInfoPopup) {
                            $onClick = 'top.TYPO3.InfoWindow.showItem(\'_FILE\', ' . GeneralUtility::quoteJSvalue($fileName) . ',\'\'); return false;';
                            $thumbData .= '<a href="#" onclick="' . htmlspecialchars($onClick) . '">' . $fileIcon . '</a> ';
                        } else {
                            $thumbData .= $fileIcon;
                        }
                    }
                }
            }
        }
        return $thumbData;
    }
 
    public static function titleAttribForPages($row, $perms_clause = '', $includeAttrib = true)
    {
        $lang = static::getLanguageService();
        $parts = [];
        $parts[] = 'id=' . $row['uid'];
        if ($row['uid'] === 0) {
            $out = htmlspecialchars($parts[0]);
            return $includeAttrib ? 'title="' . $out . '"' : $out;
        }
        if ($row['alias']) {
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['alias']['label']) . ' ' . $row['alias'];
        }
        if ($row['pid'] < 0) {
            $parts[] = 'v#1.' . $row['t3ver_id'];
        }
        switch (‪VersionState::cast($row['t3ver_state'])) {
            case new VersionState(‪VersionState::NEW_PLACEHOLDER):
                $parts[] = 'PLH WSID#' . $row['t3ver_wsid'];
                break;
            case new VersionState(‪VersionState::DELETE_PLACEHOLDER):
                $parts[] = 'Deleted element!';
                break;
            case new VersionState(‪VersionState::MOVE_PLACEHOLDER):
                $parts[] = 'OLD LOCATION (Move Placeholder) WSID#' . $row['t3ver_wsid'];
                break;
            case new VersionState(‪VersionState::MOVE_POINTER):
                $parts[] = 'NEW LOCATION (Move-to Pointer) WSID#' . $row['t3ver_wsid'];
                break;
            case new VersionState(‪VersionState::NEW_PLACEHOLDER_VERSION):
                $parts[] = 'New element!';
                break;
        }
        if ($row['doktype'] == ‪PageRepository::DOKTYPE_LINK) {
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['url']['label']) . ' ' . $row['url'];
        } elseif ($row['doktype'] == ‪PageRepository::DOKTYPE_SHORTCUT) {
            if ($perms_clause) {
                $label = self::getRecordPath((int)$row['shortcut'], $perms_clause, 20);
            } else {
                $row['shortcut'] = (int)$row['shortcut'];
                $lRec = self::getRecordWSOL('pages', $row['shortcut'], 'title');
                $label = $lRec['title'] . ' (id=' . $row['shortcut'] . ')';
            }
            if ($row['shortcut_mode'] != ‪PageRepository::SHORTCUT_MODE_NONE) {
                $label .= ', ' . $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['shortcut_mode']['label']) . ' '
                    . $lang->sL(self::getLabelFromItemlist('pages', 'shortcut_mode', $row['shortcut_mode']));
            }
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['shortcut']['label']) . ' ' . $label;
        } elseif ($row['doktype'] == ‪PageRepository::DOKTYPE_MOUNTPOINT) {
            if ((int)$row['mount_pid'] > 0) {
                if ($perms_clause) {
                    $label = self::getRecordPath((int)$row['mount_pid'], $perms_clause, 20);
                } else {
                    $lRec = self::getRecordWSOL('pages', (int)$row['mount_pid'], 'title');
                    $label = $lRec['title'] . ' (id=' . $row['mount_pid'] . ')';
                }
                $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['mount_pid']['label']) . ' ' . $label;
                if ($row['mount_pid_ol']) {
                    $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['mount_pid_ol']['label']);
                }
            } else {
                $parts[] = $lang->sl('LLL:EXT:frontend/Resources/Private/Language/locallang_tca.xlf:no_mount_pid');
            }
        }
        if ($row['nav_hide']) {
            $parts[] = $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_tca.xlf:pages.nav_hide');
        }
        if ($row['hidden']) {
            $parts[] = $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.hidden');
        }
        if ($row['starttime']) {
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['starttime']['label'])
                . ' ' . self::dateTimeAge($row['starttime'], -1, 'date');
        }
        if ($row['endtime']) {
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['endtime']['label']) . ' '
                . self::dateTimeAge($row['endtime'], -1, 'date');
        }
        if ($row['fe_group']) {
            $fe_groups = [];
            foreach (GeneralUtility::intExplode(',', $row['fe_group']) as $fe_group) {
                if ($fe_group < 0) {
                    $fe_groups[] = $lang->sL(self::getLabelFromItemlist('pages', 'fe_group', $fe_group));
                } else {
                    $lRec = self::getRecordWSOL('fe_groups', $fe_group, 'title');
                    $fe_groups[] = $lRec['title'];
                }
            }
            $label = implode(', ', $fe_groups);
            $parts[] = $lang->sL(‪$GLOBALS['TCA']['pages']['columns']['fe_group']['label']) . ' ' . $label;
        }
        $out = htmlspecialchars(implode(' - ', $parts));
        return $includeAttrib ? 'title="' . $out . '"' : $out;
    }
 
    public static function getRecordToolTip(array $row, $table = 'pages')
    {
        $toolTipText = self::getRecordIconAltText($row, $table);
        $toolTipCode = 'data-toggle="tooltip" data-title=" '
            . str_replace(' - ', '<br>', $toolTipText)
            . '" data-html="true" data-placement="right"';
        return $toolTipCode;
    }
 
    public static function getRecordIconAltText($row, $table = 'pages')
    {
        if ($table === 'pages') {
            $out = self::titleAttribForPages($row, '', 0);
        } else {
            $out = !empty(trim(‪$GLOBALS['TCA'][$table]['ctrl']['descriptionColumn'])) ? $row[‪$GLOBALS['TCA'][$table]['ctrl']['descriptionColumn']] . ' ' : '';
            $ctrl = ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns'];
            // Uid is added
            $out .= 'id=' . $row['uid'];
            if ($table === 'pages' && $row['alias']) {
                $out .= ' / ' . $row['alias'];
            }
            if (static::isTableWorkspaceEnabled($table) && $row['pid'] < 0) {
                $out .= ' - v#1.' . $row['t3ver_id'];
            }
            if (static::isTableWorkspaceEnabled($table)) {
                switch (‪VersionState::cast($row['t3ver_state'])) {
                    case new VersionState(‪VersionState::NEW_PLACEHOLDER):
                        $out .= ' - PLH WSID#' . $row['t3ver_wsid'];
                        break;
                    case new VersionState(‪VersionState::DELETE_PLACEHOLDER):
                        $out .= ' - Deleted element!';
                        break;
                    case new VersionState(‪VersionState::MOVE_PLACEHOLDER):
                        $out .= ' - OLD LOCATION (Move Placeholder) WSID#' . $row['t3ver_wsid'];
                        break;
                    case new VersionState(‪VersionState::MOVE_POINTER):
                        $out .= ' - NEW LOCATION (Move-to Pointer) WSID#' . $row['t3ver_wsid'];
                        break;
                    case new VersionState(‪VersionState::NEW_PLACEHOLDER_VERSION):
                        $out .= ' - New element!';
                        break;
                }
            }
            // Hidden
            $lang = static::getLanguageService();
            if ($ctrl['disabled']) {
                $out .= $row[$ctrl['disabled']] ? ' - ' . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.hidden') : '';
            }
            if ($ctrl['starttime']) {
                if ($row[$ctrl['starttime']] > ‪$GLOBALS['EXEC_TIME']) {
                    $out .= ' - ' . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.starttime') . ':' . self::date($row[$ctrl['starttime']]) . ' (' . self::daysUntil($row[$ctrl['starttime']]) . ' ' . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.days') . ')';
                }
            }
            if ($row[$ctrl['endtime']]) {
                $out .= ' - ' . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.endtime') . ': ' . self::date($row[$ctrl['endtime']]) . ' (' . self::daysUntil($row[$ctrl['endtime']]) . ' ' . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.days') . ')';
            }
        }
        return htmlspecialchars($out);
    }
 
    public static function getLabelFromItemlist($table, $col, $key)
    {
        // Check, if there is an "items" array:
        if (is_array(‪$GLOBALS['TCA'][$table]['columns'][$col]['config']['items'] ?? false)) {
            // Traverse the items-array...
            foreach (‪$GLOBALS['TCA'][$table]['columns'][$col]['config']['items'] as $v) {
                // ... and return the first found label where the value was equal to $key
                if ((string)$v[1] === (string)$key) {
                    return $v[0];
                }
            }
        }
        return '';
    }
 
    public static function getLabelFromItemListMerged($pageId, $table, $column, $key)
    {
        $pageTsConfig = static::getPagesTSconfig($pageId);
        $label = '';
        if (isset($pageTsConfig['TCEFORM.'])
            && \is_array($pageTsConfig['TCEFORM.'])
            && \is_array($pageTsConfig['TCEFORM.'][$table . '.'])
            && \is_array($pageTsConfig['TCEFORM.'][$table . '.'][$column . '.'])
        ) {
            if (\is_array($pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['addItems.'])
                && isset($pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['addItems.'][$key])
            ) {
                $label = $pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['addItems.'][$key];
            } elseif (\is_array($pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['altLabels.'])
                && isset($pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['altLabels.'][$key])
            ) {
                $label = $pageTsConfig['TCEFORM.'][$table . '.'][$column . '.']['altLabels.'][$key];
            }
        }
        if (empty($label)) {
            $tcaValue = self::getLabelFromItemlist($table, $column, $key);
            if (!empty($tcaValue)) {
                $label = $tcaValue;
            }
        }
        return $label;
    }
 
    public static function getLabelsFromItemsList($table, $column, $keyList, array $columnTsConfig = [])
    {
        // Check if there is an "items" array
        if (
            !isset(‪$GLOBALS['TCA'][$table]['columns'][$column]['config']['items'])
            || !is_array(‪$GLOBALS['TCA'][$table]['columns'][$column]['config']['items'])
            || $keyList === ''
        ) {
            return '';
        }
 
        $keys = GeneralUtility::trimExplode(',', $keyList, true);
        $labels = [];
        // Loop on all selected values
        foreach ($keys as $key) {
            $label = null;
            if ($columnTsConfig) {
                // Check if label has been defined or redefined via pageTsConfig
                if (isset($columnTsConfig['addItems.'][$key])) {
                    $label = $columnTsConfig['addItems.'][$key];
                } elseif (isset($columnTsConfig['altLabels.'][$key])) {
                    $label = $columnTsConfig['altLabels.'][$key];
                }
            }
            if ($label === null) {
                // Otherwise lookup the label in TCA items list
                foreach (‪$GLOBALS['TCA'][$table]['columns'][$column]['config']['items'] as $itemConfiguration) {
                    list($currentLabel, $currentKey) = $itemConfiguration;
                    if ((string)$key === (string)$currentKey) {
                        $label = $currentLabel;
                        break;
                    }
                }
            }
            if ($label !== null) {
                $labels[] = static::getLanguageService()->sL($label);
            }
        }
        return implode(', ', $labels);
    }
 
    public static function getItemLabel($table, $col)
    {
        // Check if column exists
        if (is_array(‪$GLOBALS['TCA'][$table]) && is_array(‪$GLOBALS['TCA'][$table]['columns'][$col])) {
            return ‪$GLOBALS['TCA'][$table]['columns'][$col]['label'];
        }
 
        return null;
    }
 
    public static function getRecordTitle($table, $row, $prep = false, $forceResult = true)
    {
        $recordTitle = '';
        if (isset(‪$GLOBALS['TCA'][$table]) && is_array(‪$GLOBALS['TCA'][$table])) {
            // If configured, call userFunc
            if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['label_userFunc'])) {
                $params['table'] = $table;
                $params['row'] = $row;
                $params['title'] = '';
                $params['options'] = ‪$GLOBALS['TCA'][$table]['ctrl']['label_userFunc_options'] ?? [];
 
                // Create NULL-reference
                $null = null;
                GeneralUtility::callUserFunction(‪$GLOBALS['TCA'][$table]['ctrl']['label_userFunc'], $params, $null);
                $recordTitle = $params['title'];
            } else {
                // No userFunc: Build label
                $recordTitle = self::getProcessedValue(
                    $table,
                    ‪$GLOBALS['TCA'][$table]['ctrl']['label'],
                    $row[‪$GLOBALS['TCA'][$table]['ctrl']['label']],
                    0,
                    0,
                    false,
                    $row['uid'],
                    $forceResult
                );
                if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['label_alt'])
                    && (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['label_alt_force']) || (string)$recordTitle === '')
                ) {
                    $altFields = GeneralUtility::trimExplode(',', ‪$GLOBALS['TCA'][$table]['ctrl']['label_alt'], true);
                    $tA = [];
                    if (!empty($recordTitle)) {
                        $tA[] = $recordTitle;
                    }
                    foreach ($altFields as $fN) {
                        $recordTitle = trim(strip_tags($row[$fN]));
                        if ((string)$recordTitle !== '') {
                            $recordTitle = self::getProcessedValue($table, $fN, $recordTitle, 0, 0, false, $row['uid']);
                            if (!‪$GLOBALS['TCA'][$table]['ctrl']['label_alt_force']) {
                                break;
                            }
                            $tA[] = $recordTitle;
                        }
                    }
                    if (‪$GLOBALS['TCA'][$table]['ctrl']['label_alt_force']) {
                        $recordTitle = implode(', ', $tA);
                    }
                }
            }
            // If the current result is empty, set it to '[No title]' (localized) and prepare for output if requested
            if ($prep || $forceResult) {
                if ($prep) {
                    $recordTitle = self::getRecordTitlePrep($recordTitle);
                }
                if (trim($recordTitle) === '') {
                    $recordTitle = self::getNoRecordTitle($prep);
                }
            }
        }
 
        return $recordTitle;
    }
 
    public static function getRecordTitlePrep($title, $titleLength = 0)
    {
        // If $titleLength is not a valid positive integer, use BE_USER->uc['titleLen']:
        if (!$titleLength || !‪MathUtility::canBeInterpretedAsInteger($titleLength) || $titleLength < 0) {
            $titleLength = static::getBackendUserAuthentication()->uc['titleLen'];
        }
        $titleOrig = htmlspecialchars($title);
        $title = htmlspecialchars(GeneralUtility::fixed_lgd_cs($title, $titleLength));
        // If title was cropped, offer a tooltip:
        if ($titleOrig != $title) {
            $title = '<span title="' . $titleOrig . '">' . $title . '</span>';
        }
        return $title;
    }
 
    public static function getNoRecordTitle($prep = false)
    {
        $noTitle = '[' .
            htmlspecialchars(static::getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.no_title'))
            . ']';
        if ($prep) {
            $noTitle = '<em>' . $noTitle . '</em>';
        }
        return $noTitle;
    }
 
    public static function getProcessedValue(
        $table,
        $col,
        $value,
        $fixed_lgd_chars = 0,
        $defaultPassthrough = false,
        $noRecordLookup = false,
        $uid = 0,
        $forceResult = true,
        $pid = 0
    ) {
        if ($col === 'uid') {
            // uid is not in TCA-array
            return $value;
        }
        // Check if table and field is configured
        if (!isset(‪$GLOBALS['TCA'][$table]['columns'][$col]) || !is_array(‪$GLOBALS['TCA'][$table]['columns'][$col])) {
            return null;
        }
        // Depending on the fields configuration, make a meaningful output value.
        $theColConf = ‪$GLOBALS['TCA'][$table]['columns'][$col]['config'] ?? [];
        /*****************
         *HOOK: pre-processing the human readable output from a record
         ****************/
        $null = null;
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['preProcessValue'] ?? [] as $_funcRef) {
            GeneralUtility::callUserFunction($_funcRef, $theColConf, $null);
        }
 
        $l = '';
        $lang = static::getLanguageService();
        switch ((string)($theColConf['type'] ?? '')) {
            case 'radio':
                $l = self::getLabelFromItemlist($table, $col, $value);
                $l = $lang->sL($l);
                break;
            case 'inline':
            case 'select':
                if (!empty($theColConf['MM'])) {
                    if ($uid) {
                        // Display the title of MM related records in lists
                        if ($noRecordLookup) {
                            $MMfields = [];
                            $MMfields[] = $theColConf['foreign_table'] . '.uid';
                        } else {
                            $MMfields = [$theColConf['foreign_table'] . '.' . ‪$GLOBALS['TCA'][$theColConf['foreign_table']]['ctrl']['label']];
                            if (isset(‪$GLOBALS['TCA'][$theColConf['foreign_table']]['ctrl']['label_alt'])) {
                                foreach (GeneralUtility::trimExplode(
                                    ',',
                                    ‪$GLOBALS['TCA'][$theColConf['foreign_table']]['ctrl']['label_alt'],
                                    true
                                ) as $f) {
                                    $MMfields[] = $theColConf['foreign_table'] . '.' . $f;
                                }
                            }
                        }
                        $dbGroup = GeneralUtility::makeInstance(RelationHandler::class);
                        $dbGroup->start(
                            $value,
                            $theColConf['foreign_table'],
                            $theColConf['MM'],
                            $uid,
                            $table,
                            $theColConf
                        );
                        $selectUids = $dbGroup->tableArray[$theColConf['foreign_table']];
                        if (is_array($selectUids) && !empty($selectUids)) {
                            $queryBuilder = static::getQueryBuilderForTable($theColConf['foreign_table']);
                            $queryBuilder->getRestrictions()
                                ->removeAll()
                                ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
                            $result = $queryBuilder
                                ->select('uid', ...$MMfields)
                                ->from($theColConf['foreign_table'])
                                ->where(
                                    $queryBuilder->expr()->in(
                                        'uid',
                                        $queryBuilder->createNamedParameter($selectUids, Connection::PARAM_INT_ARRAY)
                                    )
                                )
                                ->execute();
 
                            $mmlA = [];
                            while ($MMrow = $result->fetch()) {
                                // Keep sorting of $selectUids
                                $selectedUid = array_search($MMrow['uid'], $selectUids);
                                $mmlA[$selectedUid] = $MMrow['uid'];
                                if (!$noRecordLookup) {
                                    $mmlA[$selectedUid] = static::getRecordTitle(
                                        $theColConf['foreign_table'],
                                        $MMrow,
                                        false,
                                        $forceResult
                                    );
                                }
                            }
 
                            if (!empty($mmlA)) {
                                ksort($mmlA);
                                $l = implode('; ', $mmlA);
                            } else {
                                $l = 'N/A';
                            }
                        } else {
                            $l = 'N/A';
                        }
                    } else {
                        $l = 'N/A';
                    }
                } else {
                    $columnTsConfig = [];
                    if ($pid) {
                        $pageTsConfig = self::getPagesTSconfig($pid);
                        if (isset($pageTsConfig['TCEFORM.'][$table . '.'][$col . '.']) && is_array($pageTsConfig['TCEFORM.'][$table . '.'][$col . '.'])) {
                            $columnTsConfig = $pageTsConfig['TCEFORM.'][$table . '.'][$col . '.'];
                        }
                    }
                    $l = self::getLabelsFromItemsList($table, $col, $value, $columnTsConfig);
                    if (!empty($theColConf['foreign_table']) && !$l && !empty(‪$GLOBALS['TCA'][$theColConf['foreign_table']])) {
                        if ($noRecordLookup) {
                            $l = $value;
                        } else {
                            $rParts = [];
                            if ($uid && isset($theColConf['foreign_field']) && $theColConf['foreign_field'] !== '') {
                                $queryBuilder = static::getQueryBuilderForTable($theColConf['foreign_table']);
                                $queryBuilder->getRestrictions()
                                    ->removeAll()
                                    ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
                                    ->add(GeneralUtility::makeInstance(BackendWorkspaceRestriction::class));
                                $constraints = [
                                    $queryBuilder->expr()->eq(
                                        $theColConf['foreign_field'],
                                        $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                                    )
                                ];
 
                                if (!empty($theColConf['foreign_table_field'])) {
                                    $constraints[] = $queryBuilder->expr()->eq(
                                        $theColConf['foreign_table_field'],
                                        $queryBuilder->createNamedParameter($table, \PDO::PARAM_STR)
                                    );
                                }
 
                                // Add additional where clause if foreign_match_fields are defined
                                $foreignMatchFields = [];
                                if (is_array($theColConf['foreign_match_fields'])) {
                                    $foreignMatchFields = $theColConf['foreign_match_fields'];
                                }
 
                                foreach ($foreignMatchFields as $matchField => $matchValue) {
                                    $constraints[] = $queryBuilder->expr()->eq(
                                        $matchField,
                                        $queryBuilder->createNamedParameter($matchValue)
                                    );
                                }
 
                                $result = $queryBuilder
                                    ->select('*')
                                    ->from($theColConf['foreign_table'])
                                    ->where(...$constraints)
                                    ->execute();
 
                                while ($record = $result->fetch()) {
                                    $rParts[] = $record['uid'];
                                }
                            }
                            if (empty($rParts)) {
                                $rParts = GeneralUtility::trimExplode(',', $value, true);
                            }
                            $lA = [];
                            foreach ($rParts as $rVal) {
                                $rVal = (int)$rVal;
                                $r = self::getRecordWSOL($theColConf['foreign_table'], $rVal);
                                if (is_array($r)) {
                                    $lA[] = $lang->sL($theColConf['foreign_table_prefix'])
                                        . self::getRecordTitle($theColConf['foreign_table'], $r, false, $forceResult);
                                } else {
                                    $lA[] = $rVal ? '[' . $rVal . '!]' : '';
                                }
                            }
                            $l = implode(', ', $lA);
                        }
                    }
                    if (empty($l) && !empty($value)) {
                        // Use plain database value when label is empty
                        $l = $value;
                    }
                }
                break;
            case 'group':
                // resolve the titles for DB records
                if (isset($theColConf['internal_type']) && $theColConf['internal_type'] === 'db') {
                    if (isset($theColConf['MM']) && $theColConf['MM']) {
                        if ($uid) {
                            // Display the title of MM related records in lists
                            if ($noRecordLookup) {
                                $MMfields = [];
                                $MMfields[] = $theColConf['foreign_table'] . '.uid';
                            } else {
                                $MMfields = [$theColConf['foreign_table'] . '.' . ‪$GLOBALS['TCA'][$theColConf['foreign_table']]['ctrl']['label']];
                                $altLabelFields = explode(
                                    ',',
                                    ‪$GLOBALS['TCA'][$theColConf['foreign_table']]['ctrl']['label_alt']
                                );
                                foreach ($altLabelFields as $f) {
                                    $f = trim($f);
                                    if ($f !== '') {
                                        $MMfields[] = $theColConf['foreign_table'] . '.' . $f;
                                    }
                                }
                            }
                            $dbGroup = GeneralUtility::makeInstance(RelationHandler::class);
                            $dbGroup->start(
                                $value,
                                $theColConf['foreign_table'],
                                $theColConf['MM'],
                                $uid,
                                $table,
                                $theColConf
                            );
                            $selectUids = $dbGroup->tableArray[$theColConf['foreign_table']];
                            if (!empty($selectUids) && is_array($selectUids)) {
                                $queryBuilder = static::getQueryBuilderForTable($theColConf['foreign_table']);
                                $queryBuilder->getRestrictions()
                                    ->removeAll()
                                    ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
                                $result = $queryBuilder
                                    ->select('uid', ...$MMfields)
                                    ->from($theColConf['foreign_table'])
                                    ->where(
                                        $queryBuilder->expr()->in(
                                            'uid',
                                            $queryBuilder->createNamedParameter(
                                                $selectUids,
                                                Connection::PARAM_INT_ARRAY
                                            )
                                        )
                                    )
                                    ->execute();
 
                                $mmlA = [];
                                while ($MMrow = $result->fetch()) {
                                    // Keep sorting of $selectUids
                                    $selectedUid = array_search($MMrow['uid'], $selectUids);
                                    $mmlA[$selectedUid] = $MMrow['uid'];
                                    if (!$noRecordLookup) {
                                        $mmlA[$selectedUid] = static::getRecordTitle(
                                            $theColConf['foreign_table'],
                                            $MMrow,
                                            false,
                                            $forceResult
                                        );
                                    }
                                }
 
                                if (!empty($mmlA)) {
                                    ksort($mmlA);
                                    $l = implode('; ', $mmlA);
                                } else {
                                    $l = 'N/A';
                                }
                            } else {
                                $l = 'N/A';
                            }
                        } else {
                            $l = 'N/A';
                        }
                    } else {
                        $finalValues = [];
                        $relationTableName = $theColConf['allowed'];
                        $explodedValues = GeneralUtility::trimExplode(',', $value, true);
 
                        foreach ($explodedValues as $explodedValue) {
                            if (‪MathUtility::canBeInterpretedAsInteger($explodedValue)) {
                                $relationTableNameForField = $relationTableName;
                            } else {
                                list($relationTableNameForField, $explodedValue) = self::splitTable_Uid($explodedValue);
                            }
 
                            $relationRecord = static::getRecordWSOL($relationTableNameForField, $explodedValue);
                            $finalValues[] = static::getRecordTitle($relationTableNameForField, $relationRecord);
                        }
                        $l = implode(', ', $finalValues);
                    }
                } else {
                    $l = implode(', ', GeneralUtility::trimExplode(',', $value, true));
                }
                break;
            case 'check':
                if (!is_array($theColConf['items'])) {
                    $l = $value ? $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:yes') : $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:no');
                } elseif (count($theColConf['items']) === 1) {
                    reset($theColConf['items']);
                    $invertStateDisplay = current($theColConf['items'])['invertStateDisplay'] ?? false;
                    if ($invertStateDisplay) {
                        $value = !$value;
                    }
                    $l = $value ? $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:yes') : $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:no');
                } else {
                    $lA = [];
                    foreach ($theColConf['items'] as $key => $val) {
                        if ($value & pow(2, $key)) {
                            $lA[] = $lang->sL($val[0]);
                        }
                    }
                    $l = implode(', ', $lA);
                }
                break;
            case 'input':
                // Hide value 0 for dates, but show it for everything else
                if (isset($value)) {
                    $dateTimeFormats = ‪QueryHelper::getDateTimeFormats();
 
                    if (GeneralUtility::inList($theColConf['eval'] ?? '', 'date')) {
                        // Handle native date field
                        if (isset($theColConf['dbType']) && $theColConf['dbType'] === 'date') {
                            $value = $value === $dateTimeFormats['date']['empty'] ? 0 : (int)strtotime($value);
                        } else {
                            $value = (int)$value;
                        }
                        if (!empty($value)) {
                            $ageSuffix = '';
                            $dateColumnConfiguration = ‪$GLOBALS['TCA'][$table]['columns'][$col]['config'];
                            $ageDisplayKey = 'disableAgeDisplay';
 
                            // generate age suffix as long as not explicitly suppressed
                            if (!isset($dateColumnConfiguration[$ageDisplayKey])
                                // non typesafe comparison on intention
                                || $dateColumnConfiguration[$ageDisplayKey] == false
                            ) {
                                $ageSuffix = ' (' . (‪$GLOBALS['EXEC_TIME'] - $value > 0 ? '-' : '')
                                    . self::calcAge(
                                        abs(‪$GLOBALS['EXEC_TIME'] - $value),
                                        $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.minutesHoursDaysYears')
                                    )
                                    . ')';
                            }
 
                            $l = self::date($value) . $ageSuffix;
                        }
                    } elseif (GeneralUtility::inList($theColConf['eval'] ?? '', 'time')) {
                        // Handle native time field
                        if (isset($theColConf['dbType']) && $theColConf['dbType'] === 'time') {
                            $value = $value === $dateTimeFormats['time']['empty'] ? 0 : (int)strtotime('1970-01-01 ' . $value);
                        } else {
                            $value = (int)$value;
                        }
                        if (!empty($value)) {
                            $l = gmdate('H:i', (int)$value);
                        }
                    } elseif (GeneralUtility::inList($theColConf['eval'] ?? '', 'timesec')) {
                        // Handle native time field
                        if (isset($theColConf['dbType']) && $theColConf['dbType'] === 'time') {
                            $value = $value === $dateTimeFormats['time']['empty'] ? 0 : (int)strtotime('1970-01-01 ' . $value);
                        } else {
                            $value = (int)$value;
                        }
                        if (!empty($value)) {
                            $l = gmdate('H:i:s', (int)$value);
                        }
                    } elseif (GeneralUtility::inList($theColConf['eval'] ?? '', 'datetime')) {
                        // Handle native datetime field
                        if (isset($theColConf['dbType']) && $theColConf['dbType'] === 'datetime') {
                            $value = $value === $dateTimeFormats['datetime']['empty'] ? 0 : (int)strtotime($value);
                        } else {
                            $value = (int)$value;
                        }
                        if (!empty($value)) {
                            $l = self::datetime($value);
                        }
                    } else {
                        $l = $value;
                    }
                }
                break;
            case 'flex':
                $l = strip_tags($value);
                break;
            default:
                if ($defaultPassthrough) {
                    $l = $value;
                } elseif (isset($theColConf['MM'])) {
                    $l = 'N/A';
                } elseif ($value) {
                    $l = GeneralUtility::fixed_lgd_cs(strip_tags($value), 200);
                }
        }
        // If this field is a password field, then hide the password by changing it to a random number of asterisk (*)
        if (!empty($theColConf['eval']) && stristr($theColConf['eval'], 'password')) {
            $l = '';
            $randomNumber = rand(5, 12);
            for ($i = 0; $i < $randomNumber; $i++) {
                $l .= '*';
            }
        }
        /*****************
         *HOOK: post-processing the human readable output from a record
         ****************/
        $null = null;
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['postProcessValue'] ?? [] as $_funcRef) {
            $params = [
                'value' => $l,
                'colConf' => $theColConf
            ];
            $l = GeneralUtility::callUserFunction($_funcRef, $params, $null);
        }
        if ($fixed_lgd_chars) {
            return GeneralUtility::fixed_lgd_cs($l, $fixed_lgd_chars);
        }
        return $l;
    }
 
    public static function getProcessedValueExtra(
        $table,
        $fN,
        $fV,
        $fixed_lgd_chars = 0,
        $uid = 0,
        $forceResult = true,
        $pid = 0
    ) {
        $fVnew = self::getProcessedValue($table, $fN, $fV, $fixed_lgd_chars, 1, 0, $uid, $forceResult, $pid);
        if (!isset($fVnew)) {
            if (is_array(‪$GLOBALS['TCA'][$table])) {
                if ($fN == ‪$GLOBALS['TCA'][$table]['ctrl']['tstamp'] || $fN == ‪$GLOBALS['TCA'][$table]['ctrl']['crdate']) {
                    $fVnew = self::datetime($fV);
                } elseif ($fN === 'pid') {
                    // Fetches the path with no regard to the users permissions to select pages.
                    $fVnew = self::getRecordPath($fV, '1=1', 20);
                } else {
                    $fVnew = $fV;
                }
            }
        }
        return $fVnew;
    }
 
    public static function getCommonSelectFields($table, $prefix = '', ‪$fields = [])
    {
        ‪$fields[] = $prefix . 'uid';
        if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['label']) && ‪$GLOBALS['TCA'][$table]['ctrl']['label'] != '') {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['label'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['label_alt'])) {
            $secondFields = GeneralUtility::trimExplode(',', ‪$GLOBALS['TCA'][$table]['ctrl']['label_alt'], true);
            foreach ($secondFields as $fieldN) {
                ‪$fields[] = $prefix . $fieldN;
            }
        }
        if (static::isTableWorkspaceEnabled($table)) {
            ‪$fields[] = $prefix . 't3ver_id';
            ‪$fields[] = $prefix . 't3ver_state';
            ‪$fields[] = $prefix . 't3ver_wsid';
            ‪$fields[] = $prefix . 't3ver_count';
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['selicon_field'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['selicon_field'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_column'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_column'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['starttime'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['starttime'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['endtime'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['endtime'];
        }
        if (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['fe_group'])) {
            ‪$fields[] = $prefix . ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['fe_group'];
        }
        return implode(',', array_unique(‪$fields));
    }
 
    /*******************************************
     *
     * Backend Modules API functions
     *
     *******************************************/
 
    public static function helpTextArray($table, $field)
    {
        if (!isset(‪$GLOBALS['TCA_DESCR'][$table]['columns'])) {
            static::getLanguageService()->loadSingleTableDescription($table);
        }
        ‪$output = [
            'description' => null,
            'title' => null,
            'moreInfo' => false
        ];
        if (isset(‪$GLOBALS['TCA_DESCR'][$table]['columns'][$field]) && is_array(‪$GLOBALS['TCA_DESCR'][$table]['columns'][$field])) {
            $data = ‪$GLOBALS['TCA_DESCR'][$table]['columns'][$field];
            // Add alternative title, if defined
            if ($data['alttitle']) {
                ‪$output['title'] = $data['alttitle'];
            }
            // If we have more information to show and access to the cshmanual
            if (($data['image_descr'] || $data['seeAlso'] || $data['details'] || $data['syntax'])
                && static::getBackendUserAuthentication()->check('modules', 'help_CshmanualCshmanual')
            ) {
                ‪$output['moreInfo'] = true;
            }
            // Add description
            if ($data['description']) {
                ‪$output['description'] = $data['description'];
            }
        }
        return ‪$output;
    }
 
    public static function helpText($table, $field)
    {
        $helpTextArray = self::helpTextArray($table, $field);
        ‪$output = '';
        $arrow = '';
        // Put header before the rest of the text
        if ($helpTextArray['title'] !== null) {
            ‪$output .= '<h2>' . $helpTextArray['title'] . '</h2>';
        }
        // Add see also arrow if we have more info
        if ($helpTextArray['moreInfo']) {
            $iconFactory = GeneralUtility::makeInstance(IconFactory::class);
            $arrow = $iconFactory->getIcon('actions-view-go-forward', ‪Icon::SIZE_SMALL)->render();
        }
        // Wrap description and arrow in p tag
        if ($helpTextArray['description'] !== null || $arrow) {
            ‪$output .= '<p class="t3-help-short">' . nl2br(htmlspecialchars($helpTextArray['description'])) . $arrow . '</p>';
        }
        return ‪$output;
    }
 
    public static function wrapInHelp($table, $field, $text = '', array $overloadHelpText = [])
    {
        // Initialize some variables
        $helpText = '';
        $abbrClassAdd = '';
        $hasHelpTextOverload = !empty($overloadHelpText);
        // Get the help text that should be shown on hover
        if (!$hasHelpTextOverload) {
            $helpText = self::helpText($table, $field);
        }
        // If there's a help text or some overload information, proceed with preparing an output
        if (!empty($helpText) || $hasHelpTextOverload) {
            // If no text was given, just use the regular help icon
            if ($text == '') {
                $iconFactory = GeneralUtility::makeInstance(IconFactory::class);
                $text = $iconFactory->getIcon('actions-system-help-open', ‪Icon::SIZE_SMALL)->render();
                $abbrClassAdd = '-icon';
            }
            $text = '<abbr class="t3-help-teaser' . $abbrClassAdd . '">' . $text . '</abbr>';
            $wrappedText = '<span class="t3-help-link" href="#" data-table="' . $table . '" data-field="' . $field . '"';
            // The overload array may provide a title and a description
            // If either one is defined, add them to the "data" attributes
            if ($hasHelpTextOverload) {
                if (isset($overloadHelpText['title'])) {
                    $wrappedText .= ' data-title="' . htmlspecialchars($overloadHelpText['title']) . '"';
                }
                if (isset($overloadHelpText['description'])) {
                    $wrappedText .= ' data-description="' . htmlspecialchars($overloadHelpText['description']) . '"';
                }
            }
            $wrappedText .= '>' . $text . '</span>';
            return $wrappedText;
        }
        return $text;
    }
 
    public static function cshItem($table, $field, $_ = '', $wrap = '')
    {
        static::getLanguageService()->loadSingleTableDescription($table);
        if (is_array(‪$GLOBALS['TCA_DESCR'][$table])
            && is_array(‪$GLOBALS['TCA_DESCR'][$table]['columns'][$field])
        ) {
            // Creating short description
            ‪$output = self::wrapInHelp($table, $field);
            if (‪$output && $wrap) {
                $wrParts = explode('|', $wrap);
                ‪$output = $wrParts[0] . ‪$output . $wrParts[1];
            }
            return ‪$output;
        }
        return '';
    }
 
    public static function editOnClick($params, $_ = '', $requestUri = '')
    {
        if ($requestUri == -1) {
            $returnUrl = 'T3_THIS_LOCATION';
        } else {
            $returnUrl = GeneralUtility::quoteJSvalue(rawurlencode($requestUri ?: GeneralUtility::getIndpEnv('REQUEST_URI')));
        }
        $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
        return 'window.location.href=' . GeneralUtility::quoteJSvalue((string)$uriBuilder->buildUriFromRoute('record_edit') . $params . '&returnUrl=') . '+' . $returnUrl . '; return false;';
    }
 
    public static function viewOnClick(
        $pageUid,
        $backPath = '',
        $rootLine = null,
        $anchorSection = '',
        $alternativeUrl = '',
        $additionalGetVars = '',
        $switchFocus = true
    ) {
        $previewUrl = self::getPreviewUrl(
            $pageUid,
            $backPath,
            $rootLine,
            $anchorSection,
            $alternativeUrl,
            $additionalGetVars,
            $switchFocus
        );
 
        $onclickCode = 'var previewWin = window.open(' . GeneralUtility::quoteJSvalue($previewUrl) . ',\'newTYPO3frontendWindow\');'
            . ($switchFocus ? 'previewWin.focus();' : '') . LF
            . 'if (previewWin.location.href === ' . GeneralUtility::quoteJSvalue($previewUrl) . ') { previewWin.location.reload(); };';
 
        return $onclickCode;
    }
 
    public static function getPreviewUrl(
        $pageUid,
        $backPath = '',
        $rootLine = null,
        $anchorSection = '',
        $alternativeUrl = '',
        $additionalGetVars = '',
        &$switchFocus = true
    ): string {
        $viewScript = '/index.php?id=';
        if ($alternativeUrl) {
            $viewScript = $alternativeUrl;
        }
 
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['viewOnClickClass'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'preProcess')) {
                $hookObj->preProcess(
                    $pageUid,
                    $backPath,
                    $rootLine,
                    $anchorSection,
                    $viewScript,
                    $additionalGetVars,
                    $switchFocus
                );
            }
        }
 
        // If there is an alternative URL or the URL has been modified by a hook, use that one.
        if ($alternativeUrl || $viewScript !== '/index.php?id=') {
            $previewUrl = $viewScript;
        } else {
            $permissionClause = ‪$GLOBALS['BE_USER']->getPagePermsClause(‪Permission::PAGE_SHOW);
            $pageInfo = self::readPageAccess($pageUid, $permissionClause);
            // prepare custom context for link generation (to allow for example time based previews)
            $context = clone GeneralUtility::makeInstance(Context::class);
            $additionalGetVars .= self::ADMCMD_previewCmds($pageInfo, $context);
 
            // Build the URL with a site as prefix, if configured
            $siteFinder = GeneralUtility::makeInstance(SiteFinder::class);
            // Check if the page (= its rootline) has a site attached, otherwise just keep the URL as is
            $rootLine = $rootLine ?? ‪BackendUtility::BEgetRootLine($pageUid);
            try {
                $site = $siteFinder->getSiteByPageId((int)$pageUid, $rootLine);
                // Create a multi-dimensional array out of the additional get vars
                $additionalQueryParams = [];
                parse_str($additionalGetVars, $additionalQueryParams);
                if (isset($additionalQueryParams['L'])) {
                    $additionalQueryParams['_language'] = $additionalQueryParams['_language'] ?? $additionalQueryParams['L'];
                    unset($additionalQueryParams['L']);
                }
                $previewUrl = (string)$site->getRouter($context)->generateUri(
                    $pageUid,
                    $additionalQueryParams,
                    $anchorSection,
                    ‪RouterInterface::ABSOLUTE_URL
                );
            } catch (SiteNotFoundException | \InvalidArgumentException | InvalidRouteArgumentsException $e) {
                $previewUrl = self::createPreviewUrl($pageUid, $rootLine, $anchorSection, $additionalGetVars, $viewScript);
            }
        }
 
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['viewOnClickClass'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'postProcess')) {
                $previewUrl = $hookObj->postProcess(
                    $previewUrl,
                    $pageUid,
                    $rootLine,
                    $anchorSection,
                    $viewScript,
                    $additionalGetVars,
                    $switchFocus
                );
            }
        }
 
        return $previewUrl;
    }
 
    public static function wrapClickMenuOnIcon(
        $content,
        $table,
        $uid = 0,
        $context = '',
        $_addParams = '',
        $_enDisItems = '',
        $returnTagParameters = false
    ) {
        $tagParameters = [
            'class' => 't3js-contextmenutrigger',
            'data-table' => $table,
            'data-uid' => $uid,
            'data-context' => $context
        ];
 
        if ($returnTagParameters) {
            return $tagParameters;
        }
        return '<a href="#" ' . GeneralUtility::implodeAttributes($tagParameters, true) . '>' . $content . '</a>';
    }
 
    public static function getLinkToDataHandlerAction($parameters, $redirectUrl = '')
    {
        $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
        $url = (string)$uriBuilder->buildUriFromRoute('tce_db') . $parameters . '&redirect=';
        if ((int)$redirectUrl === -1) {
            $url = GeneralUtility::quoteJSvalue($url) . '+T3_THIS_LOCATION';
        } else {
            $url .= rawurlencode($redirectUrl ?: GeneralUtility::getIndpEnv('REQUEST_URI'));
        }
        return $url;
    }
 
    protected static function createPreviewUrl($pageUid, $rootLine, $anchorSection, $additionalGetVars, $viewScript)
    {
        // Look if a fixed preview language should be added:
        $beUser = static::getBackendUserAuthentication();
        $viewLanguageOrder = (string)($beUser->getTSConfig()['options.']['view.']['languageOrder'] ?? '');
 
        if (!empty($viewLanguageOrder)) {
            $suffix = '';
            // Find allowed languages (if none, all are allowed!)
            $allowedLanguages = null;
            if (!$beUser->isAdmin() && $beUser->groupData['allowed_languages'] !== '') {
                $allowedLanguages = array_flip(explode(',', $beUser->groupData['allowed_languages']));
            }
            // Traverse the view order, match first occurrence:
            $languageOrder = GeneralUtility::intExplode(',', $viewLanguageOrder);
            foreach ($languageOrder as $langUid) {
                if (is_array($allowedLanguages) && !empty($allowedLanguages)) {
                    // Choose if set.
                    if (isset($allowedLanguages[$langUid])) {
                        $suffix = '&L=' . $langUid;
                        break;
                    }
                } else {
                    // All allowed since no lang. are listed.
                    $suffix = '&L=' . $langUid;
                    break;
                }
            }
            // Add it
            $additionalGetVars .= $suffix;
        }
 
        // Check a mount point needs to be previewed
        $pageRepository = GeneralUtility::makeInstance(PageRepository::class);
        $mountPointInfo = $pageRepository->getMountPointInfo($pageUid);
 
        if ($mountPointInfo && $mountPointInfo['overlay']) {
            $pageUid = $mountPointInfo['mount_pid'];
            $additionalGetVars .= '&MP=' . $mountPointInfo['MPvar'];
        }
        $viewDomain = self::getViewDomain($pageUid, $rootLine);
 
        return $viewDomain . $viewScript . $pageUid . $additionalGetVars . $anchorSection;
    }
 
    public static function getViewDomain($pageId, $rootLine = null)
    {
        $domain = rtrim(GeneralUtility::getIndpEnv('TYPO3_SITE_URL'), '/');
        if (!is_array($rootLine)) {
            $rootLine = self::BEgetRootLine($pageId);
        }
        // Checks alternate domains
        if (!empty($rootLine)) {
            $protocol = GeneralUtility::getIndpEnv('TYPO3_SSL') ? 'https' : 'http';
            $previewDomainConfig = self::getPagesTSconfig($pageId)['TCEMAIN.']['previewDomain'] ?? '';
            $domainName = null;
            if (!empty($previewDomainConfig)) {
                if (strpos($previewDomainConfig, '://') !== false) {
                    list($protocol, $domainName) = explode('://', $previewDomainConfig);
                } else {
                    $domainName = $previewDomainConfig;
                }
            } else {
                $domainResolver = GeneralUtility::makeInstance(LegacyDomainResolver::class);
                foreach ($rootLine as $row) {
                    $domainRecord = $domainResolver->matchRootPageId((int)$row['uid']);
                    if (is_array($domainRecord)) {
                        $domainName = rtrim($domainRecord['domainName'], '/');
                        break;
                    }
                }
            }
            if ($domainName === null) {
                // Fetch the "sys_domain" record: First, check for the given domain,
                // and find the "root page" = PseudoSite to that domain, then fetch the first
                // available sys_domain record.
                $siteMatcher = GeneralUtility::makeInstance(SiteMatcher::class);
                $result = $siteMatcher->matchRequest(new ServerRequest($domain));
                $site = $result->getSite();
                if ($site instanceof PseudoSite) {
                    $domainName = (string)$site->getBase();
                    $domainName = ltrim($domainName, '/');
                }
            }
 
            if ($domainName) {
                $domain = $protocol . '://' . $domainName;
            }
            // Append port number if lockSSLPort is not the standard port 443
            $portNumber = (int)‪$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSLPort'];
            if ($portNumber > 0 && $portNumber !== 443 && $portNumber < 65536 && $protocol === 'https') {
                $domain .= ':' . strval($portNumber);
            }
        }
        return $domain;
    }
 
    public static function getModTSconfig($id, $TSref)
    {
        trigger_error(
            'BackendUtility::getModTSconfig() will be removed in TYPO3 v10.0.'
            . ' Use BackendUtility::getPagesTSconfig() to retrieve the full page TSconfig array instead.',
            E_USER_DEPRECATED
        );
        $beUser = static::getBackendUserAuthentication();
        $pageTS_modOptions = $beUser->getTSConfig($TSref, static::getPagesTSconfig($id));
        $BE_USER_modOptions = $beUser->getTSConfig($TSref);
        if ($BE_USER_modOptions['value'] === null) {
            unset($BE_USER_modOptions['value']);
        }
        ‪ArrayUtility::mergeRecursiveWithOverrule($pageTS_modOptions, $BE_USER_modOptions);
        return $pageTS_modOptions;
    }
 
    public static function getFuncMenu(
        $mainParams,
        $elementName,
        $currentValue,
        $menuItems,
        $script = '',
        $addParams = ''
    ) {
        if (!is_array($menuItems) || count($menuItems) <= 1) {
            return '';
        }
        $scriptUrl = self::buildScriptUrl($mainParams, $addParams, $script);
        $options = [];
        foreach ($menuItems as $value => $label) {
            $options[] = '<option value="'
                . htmlspecialchars($value) . '"'
                . ((string)$currentValue === (string)$value ? ' selected="selected"' : '') . '>'
                . htmlspecialchars($label, ENT_COMPAT, 'UTF-8', false) . '</option>';
        }
        $dataMenuIdentifier = str_replace(['SET[', ']'], '', $elementName);
        $dataMenuIdentifier = GeneralUtility::camelCaseToLowerCaseUnderscored($dataMenuIdentifier);
        $dataMenuIdentifier = str_replace('_', '-', $dataMenuIdentifier);
        if (!empty($options)) {
            $onChange = 'jumpToUrl(' . GeneralUtility::quoteJSvalue($scriptUrl . '&' . $elementName . '=') . '+this.options[this.selectedIndex].value,this);';
            return '
 
                <!-- Function Menu of module -->
                <select class="form-control" name="' . $elementName . '" onchange="' . htmlspecialchars($onChange) . '" data-menu-identifier="' . htmlspecialchars($dataMenuIdentifier) . '">
                    ' . implode('
                    ', $options) . '
                </select>
                        ';
        }
        return '';
    }
 
    public static function getDropdownMenu(
        $mainParams,
        $elementName,
        $currentValue,
        $menuItems,
        $script = '',
        $addParams = ''
    ) {
        if (!is_array($menuItems) || count($menuItems) <= 1) {
            return '';
        }
        $scriptUrl = self::buildScriptUrl($mainParams, $addParams, $script);
        $options = [];
        foreach ($menuItems as $value => $label) {
            $options[] = '<option value="'
                . htmlspecialchars($value) . '"'
                . ((string)$currentValue === (string)$value ? ' selected="selected"' : '') . '>'
                . htmlspecialchars($label, ENT_COMPAT, 'UTF-8', false) . '</option>';
        }
        $dataMenuIdentifier = str_replace(['SET[', ']'], '', $elementName);
        $dataMenuIdentifier = GeneralUtility::camelCaseToLowerCaseUnderscored($dataMenuIdentifier);
        $dataMenuIdentifier = str_replace('_', '-', $dataMenuIdentifier);
        if (!empty($options)) {
            $onChange = 'jumpToUrl(' . GeneralUtility::quoteJSvalue($scriptUrl . '&' . $elementName . '=') . '+this.options[this.selectedIndex].value,this);';
            return '
            <div class="form-group">
                <!-- Function Menu of module -->
                <select class="form-control input-sm" name="' . htmlspecialchars($elementName) . '" onchange="' . htmlspecialchars($onChange) . '" data-menu-identifier="' . htmlspecialchars($dataMenuIdentifier) . '">
                    ' . implode(LF, $options) . '
                </select>
            </div>
                        ';
        }
        return '';
    }
 
    public static function getFuncCheck(
        $mainParams,
        $elementName,
        $currentValue,
        $script = '',
        $addParams = '',
        $tagParams = ''
    ) {
        $scriptUrl = self::buildScriptUrl($mainParams, $addParams, $script);
        $onClick = 'jumpToUrl(' . GeneralUtility::quoteJSvalue($scriptUrl . '&' . $elementName . '=') . '+(this.checked?1:0),this);';
 
        return
            '<input' .
            ' type="checkbox"' .
            ' class="checkbox"' .
            ' name="' . $elementName . '"' .
            ($currentValue ? ' checked="checked"' : '') .
            ' onclick="' . htmlspecialchars($onClick) . '"' .
            ($tagParams ? ' ' . $tagParams : '') .
            ' value="1"' .
            ' />';
    }
 
    public static function getFuncInput(
        $mainParams,
        $elementName,
        $currentValue,
        $size = 10,
        $script = '',
        $addParams = ''
    ) {
        $scriptUrl = self::buildScriptUrl($mainParams, $addParams, $script);
        $onChange = 'jumpToUrl(' . GeneralUtility::quoteJSvalue($scriptUrl . '&' . $elementName . '=') . '+escape(this.value),this);';
        return '<input type="text" class="form-control" name="' . $elementName . '" value="' . htmlspecialchars($currentValue) . '" onchange="' . htmlspecialchars($onChange) . '" />';
    }
 
    protected static function buildScriptUrl($mainParams, $addParams, $script = '')
    {
        if (!is_array($mainParams)) {
            $mainParams = ['id' => $mainParams];
        }
        if (!$script) {
            $script = ‪PathUtility::basename(‪Environment::getCurrentScript());
        }
 
        if ($routePath = GeneralUtility::_GP('route')) {
            $uriBuilder = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\UriBuilder::class);
            $scriptUrl = (string)$uriBuilder->buildUriFromRoutePath($routePath, $mainParams);
            $scriptUrl .= $addParams;
        } else {
            $scriptUrl = $script . ‪HttpUtility::buildQueryString($mainParams, '?') . $addParams;
        }
 
        return $scriptUrl;
    }
 
    public static function unsetMenuItems($modTSconfig, $itemArray, $TSref)
    {
        trigger_error('BackendUtility::getPidForModTSconfig() will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);
        // Getting TS-config options for this module for the Backend User:
        $conf = static::getBackendUserAuthentication()->getTSConfig($TSref, $modTSconfig);
        if (is_array($conf['properties'])) {
            foreach ($conf['properties'] as $key => $val) {
                if (!$val) {
                    unset($itemArray[$key]);
                }
            }
        }
        return $itemArray;
    }
 
    public static function setUpdateSignal($set = '', $params = '')
    {
        $beUser = static::getBackendUserAuthentication();
        $modData = $beUser->getModuleData(
            \‪TYPO3\CMS\Backend\Utility\BackendUtility::class . '::getUpdateSignal',
            'ses'
        );
        if ($set) {
            $modData[$set] = [
                'set' => $set,
                'parameter' => $params
            ];
        } else {
            // clear the module data
            $modData = [];
        }
        $beUser->pushModuleData(\‪TYPO3\CMS\Backend\Utility\BackendUtility::class . '::getUpdateSignal', $modData);
    }
 
    public static function getUpdateSignalCode()
    {
        $signals = [];
        $modData = static::getBackendUserAuthentication()->getModuleData(
            \‪TYPO3\CMS\Backend\Utility\BackendUtility::class . '::getUpdateSignal',
            'ses'
        );
        if (empty($modData)) {
            return '';
        }
        // Hook: Allows to let TYPO3 execute your JS code
        $updateSignals = ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['updateSignalHook'] ?? [];
        // Loop through all setUpdateSignals and get the JS code
        foreach ($modData as $set => $val) {
            if (isset($updateSignals[$set])) {
                $params = ['set' => $set, 'parameter' => $val['parameter'], 'JScode' => ''];
                $ref = null;
                GeneralUtility::callUserFunction($updateSignals[$set], $params, $ref);
                $signals[] = $params['JScode'];
            } else {
                switch ($set) {
                    case 'updatePageTree':
                        $signals[] = '
                                if (top && top.TYPO3.Backend && top.TYPO3.Backend.NavigationContainer.PageTree) {
                                    top.TYPO3.Backend.NavigationContainer.PageTree.refreshTree();
                                }
                            ';
                        break;
                    case 'updateFolderTree':
                        $signals[] = '
                                if (top && top.nav_frame && top.nav_frame.location) {
                                    top.nav_frame.location.reload(true);
                                }';
                        break;
                    case 'updateModuleMenu':
                        $signals[] = '
                                if (top && top.TYPO3.ModuleMenu && top.TYPO3.ModuleMenu.App) {
                                    top.TYPO3.ModuleMenu.App.refreshMenu();
                                }';
                        break;
                    case 'updateTopbar':
                        $signals[] = '
                                if (top && top.TYPO3.Backend && top.TYPO3.Backend.Topbar) {
                                    top.TYPO3.Backend.Topbar.refresh();
                                }';
                        break;
                }
            }
        }
        $content = implode(LF, $signals);
        // For backwards compatibility, should be replaced
        self::setUpdateSignal();
        return $content;
    }
 
    public static function getModuleData(
        $MOD_MENU,
        $CHANGED_SETTINGS,
        $modName,
        $type = '',
        $dontValidateList = '',
        $setDefaultList = ''
    ) {
        if ($modName && is_string($modName)) {
            // Getting stored user-data from this module:
            $beUser = static::getBackendUserAuthentication();
            $settings = $beUser->getModuleData($modName, $type);
            $changed = 0;
            if (!is_array($settings)) {
                $changed = 1;
                $settings = [];
            }
            if (is_array($MOD_MENU)) {
                foreach ($MOD_MENU as $key => $var) {
                    // If a global var is set before entering here. eg if submitted, then it's substituting the current value the array.
                    if (is_array($CHANGED_SETTINGS) && isset($CHANGED_SETTINGS[$key])) {
                        if (is_array($CHANGED_SETTINGS[$key])) {
                            $serializedSettings = serialize($CHANGED_SETTINGS[$key]);
                            if ((string)$settings[$key] !== $serializedSettings) {
                                $settings[$key] = $serializedSettings;
                                $changed = 1;
                            }
                        } else {
                            if ((string)$settings[$key] !== (string)$CHANGED_SETTINGS[$key]) {
                                $settings[$key] = $CHANGED_SETTINGS[$key];
                                $changed = 1;
                            }
                        }
                    }
                    // If the $var is an array, which denotes the existence of a menu, we check if the value is permitted
                    if (is_array($var) && (!$dontValidateList || !GeneralUtility::inList($dontValidateList, $key))) {
                        // If the setting is an array or not present in the menu-array, MOD_MENU, then the default value is inserted.
                        if (is_array($settings[$key]) || !isset($MOD_MENU[$key][$settings[$key]])) {
                            $settings[$key] = (string)key($var);
                            $changed = 1;
                        }
                    }
                    // Sets default values (only strings/checkboxes, not menus)
                    if ($setDefaultList && !is_array($var)) {
                        if (GeneralUtility::inList($setDefaultList, $key) && !isset($settings[$key])) {
                            $settings[$key] = (string)$var;
                        }
                    }
                }
            } else {
                die('No menu!');
            }
            if ($changed) {
                $beUser->pushModuleData($modName, $settings);
            }
            return $settings;
        }
        die('Wrong module name: "' . $modName . '"');
    }
 
    public static function getModuleUrl($moduleName, $urlParameters = [])
    {
        trigger_error('BackendUtility::getModuleUrl() will be removed in TYPO3 v10.0, use UriBuilder->buildUriFromRoute() instead.', E_USER_DEPRECATED);
        $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
        try {
            $uri = $uriBuilder->buildUriFromRoute($moduleName, $urlParameters);
        } catch (\‪TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException $e) {
            $uri = $uriBuilder->buildUriFromRoutePath($moduleName, $urlParameters);
        }
        return (string)$uri;
    }
 
    /*******************************************
     *
     * Core
     *
     *******************************************/
    public static function lockRecords($table = '', $uid = 0, $pid = 0)
    {
        $beUser = static::getBackendUserAuthentication();
        if (isset($beUser->user['uid'])) {
            $userId = (int)$beUser->user['uid'];
            if ($table && $uid) {
                $fieldsValues = [
                    'userid' => $userId,
                    'feuserid' => 0,
                    'tstamp' => ‪$GLOBALS['EXEC_TIME'],
                    'record_table' => $table,
                    'record_uid' => $uid,
                    'username' => $beUser->user['username'],
                    'record_pid' => $pid
                ];
                GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getConnectionForTable('sys_lockedrecords')
                    ->insert(
                        'sys_lockedrecords',
                        $fieldsValues
                    );
            } else {
                GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getConnectionForTable('sys_lockedrecords')
                    ->delete(
                        'sys_lockedrecords',
                        ['userid' => (int)$userId]
                    );
            }
        }
    }
 
    public static function isRecordLocked($table, $uid)
    {
        $runtimeCache = self::getRuntimeCache();
        $cacheId = 'backend-recordLocked';
        $recordLockedCache = $runtimeCache->get($cacheId);
        if ($recordLockedCache !== false) {
            $lockedRecords = $recordLockedCache;
        } else {
            $lockedRecords = [];
 
            $queryBuilder = static::getQueryBuilderForTable('sys_lockedrecords');
            $result = $queryBuilder
                ->select('*')
                ->from('sys_lockedrecords')
                ->where(
                    $queryBuilder->expr()->neq(
                        'sys_lockedrecords.userid',
                        $queryBuilder->createNamedParameter(
                            static::getBackendUserAuthentication()->user['uid'],
                            \PDO::PARAM_INT
                        )
                    ),
                    $queryBuilder->expr()->gt(
                        'sys_lockedrecords.tstamp',
                        $queryBuilder->createNamedParameter(
                            ‪$GLOBALS['EXEC_TIME'] - 2 * 3600,
                            \PDO::PARAM_INT
                        )
                    )
                )
                ->execute();
 
            $lang = static::getLanguageService();
            while ($row = $result->fetch()) {
                // Get the type of the user that locked this record:
                if ($row['userid']) {
                    $userTypeLabel = 'beUser';
                } elseif ($row['feuserid']) {
                    $userTypeLabel = 'feUser';
                } else {
                    $userTypeLabel = 'user';
                }
                $userType = $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.' . $userTypeLabel);
                // Get the username (if available):
                if ($row['username']) {
                    $userName = $row['username'];
                } else {
                    $userName = $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.unknownUser');
                }
                $lockedRecords[$row['record_table'] . ':' . $row['record_uid']] = $row;
                $lockedRecords[$row['record_table'] . ':' . $row['record_uid']]['msg'] = sprintf(
                    $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.lockedRecordUser'),
                    $userType,
                    $userName,
                    self::calcAge(
                        ‪$GLOBALS['EXEC_TIME'] - $row['tstamp'],
                        $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.minutesHoursDaysYears')
                    )
                );
                if ($row['record_pid'] && !isset($lockedRecords[$row['record_table'] . ':' . $row['record_pid']])) {
                    $lockedRecords['pages:' . $row['record_pid']]['msg'] = sprintf(
                        $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.lockedRecordUser_content'),
                        $userType,
                        $userName,
                        self::calcAge(
                            ‪$GLOBALS['EXEC_TIME'] - $row['tstamp'],
                            $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.minutesHoursDaysYears')
                        )
                    );
                }
            }
            $runtimeCache->set($cacheId, $lockedRecords);
        }
 
        return $lockedRecords[$table . ':' . $uid] ?? false;
    }
 
    public static function getTCEFORM_TSconfig($table, $row)
    {
        self::fixVersioningPid($table, $row);
        $res = [];
        // Get main config for the table
        list($TScID, $cPid) = self::getTSCpid($table, $row['uid'], $row['pid']);
        if ($TScID >= 0) {
            $tsConfig = static::getPagesTSconfig($TScID)['TCEFORM.'][$table . '.'] ?? [];
            $typeVal = self::getTCAtypeValue($table, $row);
            foreach ($tsConfig as $key => $val) {
                if (is_array($val)) {
                    $fieldN = substr($key, 0, -1);
                    $res[$fieldN] = $val;
                    unset($res[$fieldN]['types.']);
                    if ((string)$typeVal !== '' && is_array($val['types.'][$typeVal . '.'])) {
                        ‪ArrayUtility::mergeRecursiveWithOverrule($res[$fieldN], $val['types.'][$typeVal . '.']);
                    }
                }
            }
        }
        $res['_CURRENT_PID'] = $cPid;
        $res['_THIS_UID'] = $row['uid'];
        // So the row will be passed to foreign_table_where_query()
        $res['_THIS_ROW'] = $row;
        return $res;
    }
 
    public static function getTSconfig_pidValue($table, $uid, $pid)
    {
        // If pid is an integer this takes precedence in our lookup.
        if (‪MathUtility::canBeInterpretedAsInteger($pid)) {
            $thePidValue = (int)$pid;
            // If ref to another record, look that record up.
            if ($thePidValue < 0) {
                $pidRec = self::getRecord($table, abs($thePidValue), 'pid');
                $thePidValue = is_array($pidRec) ? $pidRec['pid'] : -2;
            }
        } else {
            // Try to fetch the record pid from uid. If the uid is 'NEW...' then this will of course return nothing
            $rr = self::getRecord($table, $uid);
            $thePidValue = null;
            if (is_array($rr)) {
                // First check if the pid is -1 which means it is a workspaced element. Get the "real" record:
                if ($rr['pid'] == '-1') {
                    $rr = self::getRecord($table, $rr['t3ver_oid'], 'pid');
                    if (is_array($rr)) {
                        $thePidValue = $rr['pid'];
                    }
                } else {
                    // Returning the "pid" of the record
                    $thePidValue = $rr['pid'];
                }
            }
            if (!$thePidValue) {
                // Returns -1 if the record with this pid was not found.
                $thePidValue = -1;
            }
        }
        return $thePidValue;
    }
 
    public static function getPidForModTSconfig($table, $uid, $pid)
    {
        trigger_error('BackendUtility::getPidForModTSconfig() will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);
        return $table === 'pages' && ‪MathUtility::canBeInterpretedAsInteger($uid) ? $uid : $pid;
    }
 
    public static function getTSCpidCached($table, $uid, $pid)
    {
        $runtimeCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_runtime');
        $firstLevelCache = $runtimeCache->get('backendUtilityTscPidCached') ?: [];
        $key = $table . ':' . $uid . ':' . $pid;
        if (!isset($firstLevelCache[$key])) {
            $firstLevelCache[$key] = static::getTSCpid($table, $uid, $pid);
            $runtimeCache->set('backendUtilityTscPidCached', $firstLevelCache);
        }
        return $firstLevelCache[$key];
    }
 
    public static function getTSCpid($table, $uid, $pid)
    {
        // If pid is negative (referring to another record) the pid of the other record is fetched and returned.
        $cPid = self::getTSconfig_pidValue($table, $uid, $pid);
        // $TScID is the id of $table = pages, else it's the pid of the record.
        $TScID = $table === 'pages' && ‪MathUtility::canBeInterpretedAsInteger($uid) ? $uid : $cPid;
        return [$TScID, $cPid];
    }
 
    public static function firstDomainRecord($rootLine)
    {
        trigger_error('BackendUtility::firstDomainRecord() will be removed in TYPO3 v10.0. Use the new LigetDomainStartPagenk Generation functionality instead.', E_USER_DEPRECATED);
        $domainResolver = GeneralUtility::makeInstance(LegacyDomainResolver::class);
        foreach ($rootLine as $row) {
            $domain = $domainResolver->matchRootPageId($row['uid']);
            if (is_array($domain)) {
                return rtrim($domain['domainName'], '/');
            }
        }
        return null;
    }
 
    public static function getDomainStartPage($domain, $path = '')
    {
        trigger_error('BackendUtility::getDomainStartPage() will be removed in TYPO3 v10.0. Use the new Link Generation functionality instead.', E_USER_DEPRECATED);
        $domain = explode(':', $domain);
        $domain = strtolower(preg_replace('/\\.$/', '', $domain[0]));
        // Path is calculated.
        $path = trim(preg_replace('/\\/[^\\/]*$/', '', $path));
        // Stuff
        $domain .= $path;
 
        $queryBuilder = static::getQueryBuilderForTable('sys_domain');
        $queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
        $result = $queryBuilder
            ->select('sys_domain.*')
            ->from('sys_domain')
            ->from('pages')
            ->where(
                $queryBuilder->expr()->eq(
                    'sys_domain.pid',
                    $queryBuilder->quoteIdentifier('pages.uid')
                ),
                $queryBuilder->expr()->orX(
                    $queryBuilder->expr()->eq(
                        'sys_domain.domainName',
                        $queryBuilder->createNamedParameter($domain, \PDO::PARAM_STR)
                    ),
                    $queryBuilder->expr()->eq(
                        'sys_domain.domainName',
                        $queryBuilder->createNamedParameter($domain . '/', \PDO::PARAM_STR)
                    )
                )
            )
            ->execute()
            ->fetch();
 
        return $result;
    }
 
    public static function &softRefParserObj($spKey)
    {
        // If no softRef parser object has been set previously, try to create it:
        if (!isset(‪$GLOBALS['T3_VAR']['softRefParser'][$spKey])) {
            // Set the object string to blank by default:
            ‪$GLOBALS['T3_VAR']['softRefParser'][$spKey] = '';
            // Now, try to create parser object:
            $objRef = null;
            if (isset(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['softRefParser'][$spKey])) {
                $className = ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['softRefParser'][$spKey];
                if ($className) {
                    ‪$GLOBALS['T3_VAR']['softRefParser'][$spKey] = GeneralUtility::makeInstance($className);
                }
            }
        }
        // Return RTE object (if any!)
        return ‪$GLOBALS['T3_VAR']['softRefParser'][$spKey];
    }
 
    protected static function getRuntimeCache()
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_runtime');
    }
 
    public static function explodeSoftRefParserList($parserList)
    {
        // Return immediately if list is blank:
        if ((string)$parserList === '') {
            return false;
        }
 
        $runtimeCache = self::getRuntimeCache();
        $cacheId = 'backend-softRefList-' . md5($parserList);
        $parserListCache = $runtimeCache->get($cacheId);
        if ($parserListCache !== false) {
            return $parserListCache;
        }
 
        // Otherwise parse the list:
        $keyList = GeneralUtility::trimExplode(',', $parserList, true);
        ‪$output = [];
        foreach ($keyList as $val) {
            $reg = [];
            if (preg_match('/^([[:alnum:]_-]+)\\[(.*)\\]$/', $val, $reg)) {
                ‪$output[$reg[1]] = GeneralUtility::trimExplode(';', $reg[2], true);
            } else {
                ‪$output[$val] = '';
            }
        }
        $runtimeCache->set($cacheId, ‪$output);
        return ‪$output;
    }
 
    public static function isModuleSetInTBE_MODULES($modName)
    {
        $loaded = [];
        foreach (‪$GLOBALS['TBE_MODULES'] as $mkey => $list) {
            $loaded[$mkey] = 1;
            if (!is_array($list) && trim($list)) {
                $subList = GeneralUtility::trimExplode(',', $list, true);
                foreach ($subList as $skey) {
                    $loaded[$mkey . '_' . $skey] = 1;
                }
            }
        }
        return $modName && isset($loaded[$modName]);
    }
 
    public static function referenceCount($table, $ref, $msg = '', $count = null)
    {
        if ($count === null) {
 
            // Build base query
            $queryBuilder = static::getQueryBuilderForTable('sys_refindex');
            $queryBuilder
                ->count('*')
                ->from('sys_refindex')
                ->where(
                    $queryBuilder->expr()->eq('ref_table', $queryBuilder->createNamedParameter($table, \PDO::PARAM_STR)),
                    $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT))
                );
 
            // Look up the path:
            if ($table === '_FILE') {
                if (!GeneralUtility::isFirstPartOfStr($ref, ‪Environment::getPublicPath())) {
                    return '';
                }
 
                $ref = ‪PathUtility::stripPathSitePrefix($ref);
                $queryBuilder->andWhere(
                    $queryBuilder->expr()->eq('ref_string', $queryBuilder->createNamedParameter($ref, \PDO::PARAM_STR))
                );
            } else {
                $queryBuilder->andWhere(
                    $queryBuilder->expr()->eq('ref_uid', $queryBuilder->createNamedParameter($ref, \PDO::PARAM_INT))
                );
                if ($table === 'sys_file') {
                    $queryBuilder->andWhere($queryBuilder->expr()->neq('tablename', $queryBuilder->quote('sys_file_metadata')));
                }
            }
 
            $count = $queryBuilder->execute()->fetchColumn(0);
        }
 
        if ($count) {
            return $msg ? sprintf($msg, $count) : $count;
        }
        return $msg ? '' : 0;
    }
 
    public static function translationCount($table, $ref, $msg = '')
    {
        $count = null;
        if (‪$GLOBALS['TCA'][$table]['ctrl']['languageField']
            && ‪$GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField']
        ) {
            $queryBuilder = static::getQueryBuilderForTable($table);
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
            $count = (int)$queryBuilder
                ->count('*')
                ->from($table)
                ->where(
                    $queryBuilder->expr()->eq(
                        ‪$GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'],
                        $queryBuilder->createNamedParameter($ref, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->neq(
                        ‪$GLOBALS['TCA'][$table]['ctrl']['languageField'],
                        $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)
                    )
                )
                ->execute()
                ->fetchColumn(0);
        }
 
        if ($count && $msg) {
            return sprintf($msg, $count);
        }
 
        if ($count) {
            return $msg ? sprintf($msg, $count) : $count;
        }
        return $msg ? '' : 0;
    }
 
    /*******************************************
     *
     * Workspaces / Versioning
     *
     *******************************************/
    public static function selectVersionsOfRecord(
        $table,
        $uid,
        ‪$fields = '*',
        $workspace = 0,
        $includeDeletedRecords = false,
        $row = null
    ) {
        $realPid = 0;
        $outputRows = [];
        if (‪$GLOBALS['TCA'][$table] && static::isTableWorkspaceEnabled($table)) {
            if (is_array($row) && !$includeDeletedRecords) {
                $row['_CURRENT_VERSION'] = true;
                $realPid = $row['pid'];
                $outputRows[] = $row;
            } else {
                // Select UID version:
                $row = self::getRecord($table, $uid, ‪$fields, '', !$includeDeletedRecords);
                // Add rows to output array:
                if ($row) {
                    $row['_CURRENT_VERSION'] = true;
                    $realPid = $row['pid'];
                    $outputRows[] = $row;
                }
            }
 
            $queryBuilder = static::getQueryBuilderForTable($table);
            $queryBuilder->getRestrictions()->removeAll();
 
            // build fields to select
            $queryBuilder->select(...GeneralUtility::trimExplode(',', ‪$fields));
 
            $queryBuilder
                ->from($table)
                ->where(
                    $queryBuilder->expr()->eq('pid', $queryBuilder->createNamedParameter(-1, \PDO::PARAM_INT)),
                    $queryBuilder->expr()->neq('uid', $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)),
                    $queryBuilder->expr()->eq('t3ver_oid', $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT))
                )
                ->orderBy('t3ver_id', 'DESC');
 
            if (!$includeDeletedRecords) {
                $queryBuilder->getRestrictions()->add(GeneralUtility::makeInstance(DeletedRestriction::class));
            }
 
            if ($workspace === 0) {
                // Only in Live WS
                $queryBuilder->andWhere(
                    $queryBuilder->expr()->eq(
                        't3ver_wsid',
                        $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)
                    )
                );
            } elseif ($workspace !== null) {
                // In Live WS and Workspace with given ID
                $queryBuilder->andWhere(
                    $queryBuilder->expr()->in(
                        't3ver_wsid',
                        $queryBuilder->createNamedParameter([0, (int)$workspace], Connection::PARAM_INT_ARRAY)
                    )
                );
            }
 
            $rows = $queryBuilder->execute()->fetchAll();
 
            // Add rows to output array:
            if (is_array($rows)) {
                $outputRows = array_merge($outputRows, $rows);
            }
            // Set real-pid:
            foreach ($outputRows as $idx => $oRow) {
                $outputRows[$idx]['_REAL_PID'] = $realPid;
            }
            return $outputRows;
        }
        return null;
    }
 
    public static function fixVersioningPid($table, &$rr, $ignoreWorkspaceMatch = false)
    {
        if (!‪ExtensionManagementUtility::isLoaded('workspaces')) {
            return;
        }
        // Check that the input record is an offline version from a table that supports versioning:
        if (is_array($rr) && $rr['pid'] == -1 && static::isTableWorkspaceEnabled($table)) {
            // Check values for t3ver_oid and t3ver_wsid:
            if (isset($rr['t3ver_oid']) && isset($rr['t3ver_wsid'])) {
                // If "t3ver_oid" is already a field, just set this:
                $oid = $rr['t3ver_oid'];
                $wsid = $rr['t3ver_wsid'];
            } else {
                $oid = 0;
                $wsid = 0;
                // Otherwise we have to expect "uid" to be in the record and look up based on this:
                $newPidRec = self::getRecord($table, $rr['uid'], 't3ver_oid,t3ver_wsid');
                if (is_array($newPidRec)) {
                    $oid = $newPidRec['t3ver_oid'];
                    $wsid = $newPidRec['t3ver_wsid'];
                }
            }
            // If ID of current online version is found, look up the PID value of that:
            if ($oid
                && ($ignoreWorkspaceMatch || (static::getBackendUserAuthentication() instanceof BackendUserAuthentication && (int)$wsid === (int)static::getBackendUserAuthentication()->workspace))
            ) {
                $oidRec = self::getRecord($table, $oid, 'pid');
                if (is_array($oidRec)) {
                    $rr['_ORIG_pid'] = $rr['pid'];
                    $rr['pid'] = $oidRec['pid'];
                }
                // Use target PID in case of move pointer
                if (
                    !isset($rr['t3ver_state'])
                    || ‪VersionState::cast($rr['t3ver_state'])->equals(‪VersionState::MOVE_POINTER)
                ) {
                    $movePlaceholder = self::getMovePlaceholder($table, $oid, 'pid');
                    if ($movePlaceholder) {
                        $rr['_ORIG_pid'] = $rr['pid'];
                        $rr['pid'] = $movePlaceholder['pid'];
                    }
                }
            }
        }
    }
 
    public static function workspaceOL($table, &$row, $wsid = -99, $unsetMovePointers = false)
    {
        if (!‪ExtensionManagementUtility::isLoaded('workspaces')) {
            return;
        }
        // If this is FALSE the placeholder is shown raw in the backend.
        // I don't know if this move can be useful for users to toggle. Technically it can help debugging.
        $previewMovePlaceholders = true;
        // Initialize workspace ID
        if ($wsid == -99 && static::getBackendUserAuthentication() instanceof BackendUserAuthentication) {
            $wsid = static::getBackendUserAuthentication()->workspace;
        }
        // Check if workspace is different from zero and record is set:
        if ($wsid !== 0 && is_array($row)) {
            // Check if input record is a move-placeholder and if so, find the pointed-to live record:
            $movePldSwap = null;
            $orig_uid = 0;
            $orig_pid = 0;
            if ($previewMovePlaceholders) {
                $orig_uid = $row['uid'];
                $orig_pid = $row['pid'];
                $movePldSwap = self::movePlhOL($table, $row);
            }
            $wsAlt = self::getWorkspaceVersionOfRecord(
                $wsid,
                $table,
                $row['uid'],
                implode(',', static::purgeComputedPropertyNames(array_keys($row)))
            );
            // If version was found, swap the default record with that one.
            if (is_array($wsAlt)) {
                // Check if this is in move-state:
                if ($previewMovePlaceholders && !$movePldSwap && static::isTableWorkspaceEnabled($table) && $unsetMovePointers) {
                    // Only for WS ver 2... (moving)
                    // If t3ver_state is not found, then find it... (but we like best if it is here...)
                    if (!isset($wsAlt['t3ver_state'])) {
                        $stateRec = self::getRecord($table, $wsAlt['uid'], 't3ver_state');
                        $versionState = ‪VersionState::cast($stateRec['t3ver_state']);
                    } else {
                        $versionState = ‪VersionState::cast($wsAlt['t3ver_state']);
                    }
                    if ($versionState->equals(‪VersionState::MOVE_POINTER)) {
                        // @todo Same problem as frontend in versionOL(). See TODO point there.
                        $row = false;
                        return;
                    }
                }
                // Always correct PID from -1 to what it should be
                if (isset($wsAlt['pid'])) {
                    // Keep the old (-1) - indicates it was a version.
                    $wsAlt['_ORIG_pid'] = $wsAlt['pid'];
                    // Set in the online versions PID.
                    $wsAlt['pid'] = $row['pid'];
                }
                // For versions of single elements or page+content, swap UID and PID
                $wsAlt['_ORIG_uid'] = $wsAlt['uid'];
                $wsAlt['uid'] = $row['uid'];
                // Backend css class:
                $wsAlt['_CSSCLASS'] = 'ver-element';
                // Changing input record to the workspace version alternative:
                $row = $wsAlt;
            }
            // If the original record was a move placeholder, the uid and pid of that is preserved here:
            if ($movePldSwap) {
                $row['_MOVE_PLH'] = true;
                $row['_MOVE_PLH_uid'] = $orig_uid;
                $row['_MOVE_PLH_pid'] = $orig_pid;
                // For display; To make the icon right for the placeholder vs. the original
                $row['t3ver_state'] = (string)new VersionState(‪VersionState::MOVE_PLACEHOLDER);
            }
        }
    }
 
    public static function movePlhOL($table, &$row)
    {
        if (static::isTableWorkspaceEnabled($table)) {
            // If t3ver_move_id or t3ver_state is not found, then find it... (but we like best if it is here...)
            if (!isset($row['t3ver_move_id']) || !isset($row['t3ver_state'])) {
                $moveIDRec = self::getRecord($table, $row['uid'], 't3ver_move_id, t3ver_state');
                $moveID = $moveIDRec['t3ver_move_id'];
                $versionState = ‪VersionState::cast($moveIDRec['t3ver_state']);
            } else {
                $moveID = $row['t3ver_move_id'];
                $versionState = ‪VersionState::cast($row['t3ver_state']);
            }
            // Find pointed-to record.
            if ($versionState->equals(‪VersionState::MOVE_PLACEHOLDER) && $moveID) {
                if ($origRow = self::getRecord(
                    $table,
                    $moveID,
                    implode(',', static::purgeComputedPropertyNames(array_keys($row)))
                )) {
                    $row = $origRow;
                    return true;
                }
            }
        }
        return false;
    }
 
    public static function getWorkspaceVersionOfRecord($workspace, $table, $uid, ‪$fields = '*')
    {
        if (‪ExtensionManagementUtility::isLoaded('workspaces')) {
            if ($workspace !== 0 && self::isTableWorkspaceEnabled($table)) {
 
                // Select workspace version of record:
                $queryBuilder = static::getQueryBuilderForTable($table);
                $queryBuilder->getRestrictions()
                    ->removeAll()
                    ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
                // build fields to select
                $queryBuilder->select(...GeneralUtility::trimExplode(',', ‪$fields));
 
                $row = $queryBuilder
                    ->from($table)
                    ->where(
                        $queryBuilder->expr()->eq(
                            'pid',
                            $queryBuilder->createNamedParameter(-1, \PDO::PARAM_INT)
                        ),
                        $queryBuilder->expr()->eq(
                            't3ver_oid',
                            $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                        ),
                        $queryBuilder->expr()->eq(
                            't3ver_wsid',
                            $queryBuilder->createNamedParameter($workspace, \PDO::PARAM_INT)
                        )
                    )
                    ->execute()
                    ->fetch();
 
                return $row;
            }
        }
        return false;
    }
 
    public static function getLiveVersionOfRecord($table, $uid, ‪$fields = '*')
    {
        $liveVersionId = self::getLiveVersionIdOfRecord($table, $uid);
        if ($liveVersionId !== null) {
            return self::getRecord($table, $liveVersionId, ‪$fields);
        }
        return null;
    }
 
    public static function getLiveVersionIdOfRecord($table, $uid)
    {
        if (!‪ExtensionManagementUtility::isLoaded('workspaces')) {
            return null;
        }
        $liveVersionId = null;
        if (self::isTableWorkspaceEnabled($table)) {
            $currentRecord = self::getRecord($table, $uid, 'pid,t3ver_oid');
            if (is_array($currentRecord) && $currentRecord['pid'] == -1) {
                $liveVersionId = $currentRecord['t3ver_oid'];
            }
        }
        return $liveVersionId;
    }
 
    public static function versioningPlaceholderClause($table)
    {
        if (static::isTableWorkspaceEnabled($table) && static::getBackendUserAuthentication() instanceof BackendUserAuthentication) {
            $currentWorkspace = (int)static::getBackendUserAuthentication()->workspace;
            return ' AND (' . $table . '.t3ver_state <= ' . new VersionState(‪VersionState::DEFAULT_STATE) . ' OR ' . $table . '.t3ver_wsid = ' . $currentWorkspace . ')';
        }
        return '';
    }
 
    public static function getWorkspaceWhereClause($table, $workspaceId = null)
    {
        $whereClause = '';
        if (self::isTableWorkspaceEnabled($table) && static::getBackendUserAuthentication() instanceof BackendUserAuthentication) {
            if ($workspaceId === null) {
                $workspaceId = static::getBackendUserAuthentication()->workspace;
            }
            $workspaceId = (int)$workspaceId;
            $pidOperator = $workspaceId === 0 ? '!=' : '=';
            $whereClause = ' AND ' . $table . '.t3ver_wsid=' . $workspaceId . ' AND ' . $table . '.pid' . $pidOperator . '-1';
        }
        return $whereClause;
    }
 
    public static function wsMapId($table, $uid)
    {
        $wsRec = null;
        if (static::getBackendUserAuthentication() instanceof BackendUserAuthentication) {
            $wsRec = self::getWorkspaceVersionOfRecord(
                static::getBackendUserAuthentication()->workspace,
                $table,
                $uid,
                'uid'
            );
        }
        return is_array($wsRec) ? $wsRec['uid'] : $uid;
    }
 
    public static function getMovePlaceholder($table, $uid, ‪$fields = '*', $workspace = null)
    {
        if ($workspace === null && static::getBackendUserAuthentication() instanceof BackendUserAuthentication) {
            $workspace = static::getBackendUserAuthentication()->workspace;
        }
        if ((int)$workspace !== 0 && ‪$GLOBALS['TCA'][$table] && static::isTableWorkspaceEnabled($table)) {
            // Select workspace version of record:
            $queryBuilder = static::getQueryBuilderForTable($table);
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
            $row = $queryBuilder
                ->select(...GeneralUtility::trimExplode(',', ‪$fields, true))
                ->from($table)
                ->where(
                    $queryBuilder->expr()->neq(
                        'pid',
                        $queryBuilder->createNamedParameter(-1, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        't3ver_state',
                        $queryBuilder->createNamedParameter(
                            (string)new VersionState(‪VersionState::MOVE_PLACEHOLDER),
                            \PDO::PARAM_INT
                        )
                    ),
                    $queryBuilder->expr()->eq(
                        't3ver_move_id',
                        $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        't3ver_wsid',
                        $queryBuilder->createNamedParameter($workspace, \PDO::PARAM_INT)
                    )
                )
                ->execute()
                ->fetch();
 
            return $row ?: false;
        }
        return false;
    }
 
    /*******************************************
     *
     * Miscellaneous
     *
     *******************************************/
    public static function TYPO3_copyRightNotice()
    {
        // Copyright Notice
        $loginCopyrightWarrantyProvider = strip_tags(trim(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['loginCopyrightWarrantyProvider']));
        $loginCopyrightWarrantyURL = strip_tags(trim(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['loginCopyrightWarrantyURL']));
 
        $lang = static::getLanguageService();
 
        if (strlen($loginCopyrightWarrantyProvider) >= 2 && strlen($loginCopyrightWarrantyURL) >= 10) {
            $warrantyNote = sprintf(
                $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:warranty.by'),
                htmlspecialchars($loginCopyrightWarrantyProvider),
                '<a href="' . htmlspecialchars($loginCopyrightWarrantyURL) . '" target="_blank" rel="noopener noreferrer">',
                '</a>'
            );
        } else {
            $warrantyNote = sprintf(
                $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:no.warranty'),
                '<a href="' . TYPO3_URL_LICENSE . '" target="_blank" rel="noopener noreferrer">',
                '</a>'
            );
        }
        $cNotice = '<a href="' . TYPO3_URL_GENERAL . '" target="_blank" rel="noopener noreferrer">' .
            $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:typo3.cms') . '</a>. ' .
            $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:copyright') . ' &copy; '
            . htmlspecialchars(TYPO3_copyright_year) . ' Kasper Sk&aring;rh&oslash;j. ' .
            $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:extension.copyright') . ' ' .
            sprintf(
                $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:details.link'),
                '<a href="' . TYPO3_URL_GENERAL . '" target="_blank" rel="noopener noreferrer">' . TYPO3_URL_GENERAL . '</a>'
            ) . ' ' .
            strip_tags($warrantyNote, '<a>') . ' ' .
            sprintf(
                $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:free.software'),
                '<a href="' . TYPO3_URL_LICENSE . '" target="_blank" rel="noopener noreferrer">',
                '</a> '
            )
            . $lang->sL('LLL:EXT:backend/Resources/Private/Language/locallang_login.xlf:keep.notice');
        return $cNotice;
    }
 
    public static function ADMCMD_previewCmds($pageInfo, Context $context)
    {
        $simUser = '';
        $simTime = '';
        if ($pageInfo['fe_group'] > 0) {
            $simUser = '&ADMCMD_simUser=' . $pageInfo['fe_group'];
        } elseif ((int)$pageInfo['fe_group'] === -2) {
            // -2 means "show at any login". We simulate first available fe_group.
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('fe_groups');
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
                ->add(GeneralUtility::makeInstance(HiddenRestriction::class));
 
            $activeFeGroupRow = $queryBuilder->select('uid')
                ->from('fe_groups')
                ->execute()
                ->fetch();
 
            if (!empty($activeFeGroupRow)) {
                $simUser = '&ADMCMD_simUser=' . $activeFeGroupRow['uid'];
            }
        }
        $startTime = (int)$pageInfo['starttime'];
        $endTime = (int)$pageInfo['endtime'];
        if ($startTime > ‪$GLOBALS['EXEC_TIME']) {
            // simulate access time to ensure PageRepository will find the page and in turn PageRouter will generate
            // an URL for it
            $dateAspect = GeneralUtility::makeInstance(DateTimeAspect::class, new \DateTimeImmutable('@' . $startTime));
            $context->setAspect('date', $dateAspect);
            $simTime = '&ADMCMD_simTime=' . $startTime;
        }
        if ($endTime < ‪$GLOBALS['EXEC_TIME'] && $endTime !== 0) {
            // Set access time to page's endtime subtracted one second to ensure PageRepository will find the page and
            // in turn PageRouter will generate an URL for it
            $dateAspect = GeneralUtility::makeInstance(
                DateTimeAspect::class,
                new \DateTimeImmutable('@' . ($endTime - 1))
            );
            $context->setAspect('date', $dateAspect);
            $simTime = '&ADMCMD_simTime=' . ($endTime - 1);
        }
        return $simUser . $simTime;
    }
 
    public static function getBackendScript($interface = '')
    {
        if (!$interface) {
            $interface = static::getBackendUserAuthentication()->uc['interfaceSetup'];
        }
        switch ($interface) {
            case 'frontend':
                $script = '../.';
                break;
            case 'backend':
            default:
                $script = (string)GeneralUtility::makeInstance(UriBuilder::class)->buildUriFromRoute('main');
        }
        return $script;
    }
 
    public static function isTableWorkspaceEnabled($table)
    {
        return !empty(‪$GLOBALS['TCA'][$table]['ctrl']['versioningWS']);
    }
 
    public static function getTcaFieldConfiguration($table, $field)
    {
        $configuration = [];
        if (isset(‪$GLOBALS['TCA'][$table]['columns'][$field]['config'])) {
            $configuration = ‪$GLOBALS['TCA'][$table]['columns'][$field]['config'];
        }
        return $configuration;
    }
 
    public static function isWebMountRestrictionIgnored($table)
    {
        return !empty(‪$GLOBALS['TCA'][$table]['ctrl']['security']['ignoreWebMountRestriction']);
    }
 
    public static function isRootLevelRestrictionIgnored($table)
    {
        return !empty(‪$GLOBALS['TCA'][$table]['ctrl']['security']['ignoreRootLevelRestriction']);
    }
 
    public static function shortcutExists($url)
    {
        trigger_error(
            'Method BackendUtility::shortcutExists() has been marked as deprecated and will be removed in TYPO3 v10.0. Use an instance of ShortcutRepository instead.',
            E_USER_DEPRECATED
        );
 
        $shortcutRepository = GeneralUtility::makeInstance(ShortcutRepository::class);
        return $shortcutRepository->shortcutExists($url);
    }
 
    protected static function getSignalSlotDispatcher()
    {
        return GeneralUtility::makeInstance(\‪TYPO3\CMS\‪Extbase\SignalSlot\Dispatcher::class);
    }
 
    protected static function emitGetPagesTSconfigPreIncludeSignal(
        array $TSdataArray,
        $id,
        array $rootLine
    ) {
        $signalArguments = static::getSignalSlotDispatcher()->dispatch(
            __CLASS__,
            'getPagesTSconfigPreInclude',
            [$TSdataArray, $id, $rootLine, false]
        );
        return $signalArguments[0];
    }
 
    protected static function getConnectionForTable($table)
    {
        return GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
    }
 
    protected static function getQueryBuilderForTable($table)
    {
        return GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
    }
 
    protected static function getLogger()
    {
        return GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
    }
 
    protected static function getLanguageService()
    {
        return ‪$GLOBALS['LANG'];
    }
 
    protected static function getBackendUserAuthentication()
    {
        return ‪$GLOBALS['BE_USER'] ?? null;
    }
}