PageRepository.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Frontend\Page;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Core\Cache\CacheManager;
use TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException;
use TYPO3\CMS\Core\Resource\FileRepository;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\HttpUtility;
use TYPO3\CMS\Core\Utility\RootlineUtility;
use TYPO3\CMS\Core\Versioning\VersionState;

class PageRepository
{
    public $urltypes = array('', 'http://', 'ftp://', 'mailto:', 'https://');

    public $where_hid_del = ' AND pages.deleted=0';

    public $where_groupAccess = '';

    public $sys_language_uid = 0;

    public $versioningPreview = false;

    public $versioningPreview_where_hid_del = '';

    public $versioningWorkspaceId = 0;

    public $workspaceCache = array();

    public $error_getRootLine = '';

    public $error_getRootLine_failPid = 0;

    protected $cache_getRootLine = array();

    protected $cache_getPage = array();

    protected $cache_getPage_noCheck = array();

    protected $cache_getPageIdFromAlias = array();

    protected $cache_getMountPointInfo = array();

    protected $tableNamesAllowedOnRootLevel = array(
        'sys_file_metadata',
        'sys_category',
    );

    protected $computedPropertyNames = array(
        '_LOCALIZED_UID',
        '_MP_PARAM',
        '_ORIG_uid',
        '_ORIG_pid',
        '_PAGES_OVERLAY',
        '_PAGES_OVERLAY_UID',
        '_PAGES_OVERLAY_LANGUAGE',
    );

    const DOKTYPE_DEFAULT = 1;
    const DOKTYPE_LINK = 3;
    const DOKTYPE_SHORTCUT = 4;
    const DOKTYPE_BE_USER_SECTION = 6;
    const DOKTYPE_MOUNTPOINT = 7;
    const DOKTYPE_SPACER = 199;
    const DOKTYPE_SYSFOLDER = 254;
    const DOKTYPE_RECYCLER = 255;

    const SHORTCUT_MODE_NONE = 0;
    const SHORTCUT_MODE_FIRST_SUBPAGE = 1;
    const SHORTCUT_MODE_RANDOM_SUBPAGE = 2;
    const SHORTCUT_MODE_PARENT_PAGE = 3;

    public function init($show_hidden)
    {
        $this->where_groupAccess = '';

        if ($this->versioningPreview) {
            // For version previewing, make sure that enable-fields are not
            // de-selecting hidden pages - we need versionOL() to unset them only
            // if the overlay record instructs us to.
            // Clear where_hid_del and restrict to live and current workspaces
            $this->where_hid_del = ' AND pages.deleted=0 AND (pages.t3ver_wsid=0 OR pages.t3ver_wsid=' . (int)$this->versioningWorkspaceId . ')';
        } else {
            // add starttime / endtime, and check for hidden/deleted
            // Filter out new/deleted place-holder pages in case we are NOT in a
            // versioning preview (that means we are online!)
            $this->where_hid_del = $this->enableFields('pages', $show_hidden, array('fe_group' => true), true);
        }
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][PageRepository::class]['init'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][PageRepository::class]['init'] as $classRef) {
                $hookObject = GeneralUtility::makeInstance($classRef);
                if (!$hookObject instanceof PageRepositoryInitHookInterface) {
                    throw new \UnexpectedValueException($hookObject . ' must implement interface TYPO3\\CMS\\Frontend\\Page\\PageRepositoryInitHookInterface', 1379579812);
                }
                $hookObject->init_postProcess($this);
            }
        }
    }

    /**************************
     *
     * Selecting page records
     *
     **************************/

    public function getPage($uid, $disableGroupAccessCheck = false)
    {
        // Hook to manipulate the page uid for special overlay handling
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getPage'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getPage'] as $classRef) {
                $hookObject = GeneralUtility::getUserObj($classRef);
                if (!$hookObject instanceof PageRepositoryGetPageHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface ' . PageRepositoryGetPageHookInterface::class, 1251476766);
                }
                $hookObject->getPage_preProcess($uid, $disableGroupAccessCheck, $this);
            }
        }
        $accessCheck = $disableGroupAccessCheck ? '' : $this->where_groupAccess;
        $cacheKey = md5($accessCheck . '-' . $this->where_hid_del . '-' . $this->sys_language_uid);
        if (is_array($this->cache_getPage[$uid][$cacheKey])) {
            return $this->cache_getPage[$uid][$cacheKey];
        }
        $result = array();
        $row = $this->getDatabaseConnection()->exec_SELECTgetSingleRow('*', 'pages', 'uid=' . (int)$uid . $this->where_hid_del . $accessCheck);
        if ($row) {
            $this->versionOL('pages', $row);
            if (is_array($row)) {
                $result = $this->getPageOverlay($row);
            }
        }
        $this->cache_getPage[$uid][$cacheKey] = $result;
        return $result;
    }

    public function getPage_noCheck($uid)
    {
        if ($this->cache_getPage_noCheck[$uid]) {
            return $this->cache_getPage_noCheck[$uid];
        }
        $res = $this->getDatabaseConnection()->exec_SELECTquery('*', 'pages', 'uid=' . (int)$uid . $this->deleteClause('pages'));
        $row = $this->getDatabaseConnection()->sql_fetch_assoc($res);
        $this->getDatabaseConnection()->sql_free_result($res);
        $result = array();
        if ($row) {
            $this->versionOL('pages', $row);
            if (is_array($row)) {
                $result = $this->getPageOverlay($row);
            }
        }
        $this->cache_getPage_noCheck[$uid] = $result;
        return $result;
    }

    public function getFirstWebPage($uid)
    {
        $output = '';
        $res = $this->getDatabaseConnection()->exec_SELECTquery('*', 'pages', 'pid=' . (int)$uid . $this->where_hid_del . $this->where_groupAccess, '', 'sorting', '1');
        $row = $this->getDatabaseConnection()->sql_fetch_assoc($res);
        $this->getDatabaseConnection()->sql_free_result($res);
        if ($row) {
            $this->versionOL('pages', $row);
            if (is_array($row)) {
                $output = $this->getPageOverlay($row);
            }
        }
        return $output;
    }

    public function getPageIdFromAlias($alias)
    {
        $alias = strtolower($alias);
        if ($this->cache_getPageIdFromAlias[$alias]) {
            return $this->cache_getPageIdFromAlias[$alias];
        }
        $db = $this->getDatabaseConnection();
        $row = $db->exec_SELECTgetSingleRow('uid', 'pages', 'alias=' . $db->fullQuoteStr($alias, 'pages') . ' AND pid>=0 AND pages.deleted=0');
        // "AND pid>=0" because of versioning (means that aliases sent MUST be online!)
        if ($row) {
            $this->cache_getPageIdFromAlias[$alias] = $row['uid'];
            return $row['uid'];
        }
        $this->cache_getPageIdFromAlias[$alias] = 0;
        return 0;
    }

    public function getPageOverlay($pageInput, $lUid = -1)
    {
        $rows = $this->getPagesOverlay(array($pageInput), $lUid);
        // Always an array in return
        return isset($rows[0]) ? $rows[0] : array();
    }

    public function getPagesOverlay(array $pagesInput, $lUid = -1)
    {
        if (empty($pagesInput)) {
            return array();
        }
        // Initialize:
        if ($lUid < 0) {
            $lUid = $this->sys_language_uid;
        }
        $row = null;
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getPageOverlay'])) {
            foreach ($pagesInput as $origPage) {
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getPageOverlay'] as $classRef) {
                    $hookObject = GeneralUtility::getUserObj($classRef);
                    if (!$hookObject instanceof PageRepositoryGetPageOverlayHookInterface) {
                        throw new \UnexpectedValueException('$hookObject must implement interface ' . PageRepositoryGetPageOverlayHookInterface::class, 1269878881);
                    }
                    $hookObject->getPageOverlay_preProcess($origPage, $lUid, $this);
                }
            }
        }
        // If language UID is different from zero, do overlay:
        if ($lUid) {
            $fieldArr = GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['pageOverlayFields'], true);
            $page_ids = array();

            $origPage = reset($pagesInput);
            if (is_array($origPage)) {
                // Make sure that only fields which exist in the first incoming record are overlaid!
                $fieldArr = array_intersect($fieldArr, array_keys($origPage));
            }
            foreach ($pagesInput as $origPage) {
                if (is_array($origPage)) {
                    // Was the whole record
                    $page_ids[] = $origPage['uid'];
                } else {
                    // Was the id
                    $page_ids[] = $origPage;
                }
            }
            if (!empty($fieldArr)) {
                if (!in_array('pid', $fieldArr, true)) {
                    $fieldArr[] = 'pid';
                }
                // NOTE to enabledFields('pages_language_overlay'):
                // Currently the showHiddenRecords of TSFE set will allow
                // pages_language_overlay records to be selected as they are
                // child-records of a page.
                // However you may argue that the showHiddenField flag should
                // determine this. But that's not how it's done right now.
                // Selecting overlay record:
                $db = $this->getDatabaseConnection();
                $res = $db->exec_SELECTquery(
                    implode(',', $fieldArr),
                    'pages_language_overlay',
                    'pid IN(' . implode(',', $db->cleanIntArray($page_ids)) . ')'
                    . ' AND sys_language_uid=' . (int)$lUid . $this->enableFields('pages_language_overlay')
                );
                $overlays = array();
                while ($row = $db->sql_fetch_assoc($res)) {
                    $this->versionOL('pages_language_overlay', $row);
                    if (is_array($row)) {
                        $row['_PAGES_OVERLAY'] = true;
                        $row['_PAGES_OVERLAY_UID'] = $row['uid'];
                        $row['_PAGES_OVERLAY_LANGUAGE'] = $lUid;
                        $origUid = $row['pid'];
                        // Unset vital fields that are NOT allowed to be overlaid:
                        unset($row['uid']);
                        unset($row['pid']);
                        $overlays[$origUid] = $row;
                    }
                }
                $db->sql_free_result($res);
            }
        }
        // Create output:
        $pagesOutput = array();
        foreach ($pagesInput as $key => $origPage) {
            if (is_array($origPage)) {
                $pagesOutput[$key] = $origPage;
                if (isset($overlays[$origPage['uid']])) {
                    // Overwrite the original field with the overlay
                    foreach ($overlays[$origPage['uid']] as $fieldName => $fieldValue) {
                        if ($fieldName !== 'uid' && $fieldName !== 'pid') {
                            if ($this->shouldFieldBeOverlaid('pages_language_overlay', $fieldName, $fieldValue)) {
                                $pagesOutput[$key][$fieldName] = $fieldValue;
                            }
                        }
                    }
                }
            } else {
                if (isset($overlays[$origPage])) {
                    $pagesOutput[$key] = $overlays[$origPage];
                }
            }
        }
        return $pagesOutput;
    }

    public function getRecordOverlay($table, $row, $sys_language_content, $OLmode = '')
    {
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getRecordOverlay'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getRecordOverlay'] as $classRef) {
                $hookObject = GeneralUtility::getUserObj($classRef);
                if (!$hookObject instanceof PageRepositoryGetRecordOverlayHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface ' . PageRepositoryGetRecordOverlayHookInterface::class, 1269881658);
                }
                $hookObject->getRecordOverlay_preProcess($table, $row, $sys_language_content, $OLmode, $this);
            }
        }
        if ($row['uid'] > 0 && ($row['pid'] > 0 || in_array($table, $this->tableNamesAllowedOnRootLevel, true))) {
            if ($GLOBALS['TCA'][$table] && $GLOBALS['TCA'][$table]['ctrl']['languageField'] && $GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField']) {
                if (!$GLOBALS['TCA'][$table]['ctrl']['transOrigPointerTable']) {
                    // Will not be able to work with other tables (Just didn't implement it yet;
                    // Requires a scan over all tables [ctrl] part for first FIND the table that
                    // carries localization information for this table (which could even be more
                    // than a single table) and then use that. Could be implemented, but obviously
                    // takes a little more....) Will try to overlay a record only if the
                    // sys_language_content value is larger than zero.
                    if ($sys_language_content > 0) {
                        // Must be default language or [All], otherwise no overlaying:
                        if ((int)$row[$GLOBALS['TCA'][$table]['ctrl']['languageField']] === 0) {
                            // Select overlay record:
                            $res = $this->getDatabaseConnection()->exec_SELECTquery('*', $table, 'pid=' . (int)$row['pid'] . ' AND ' . $GLOBALS['TCA'][$table]['ctrl']['languageField'] . '=' . (int)$sys_language_content . ' AND ' . $GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'] . '=' . (int)$row['uid'] . $this->enableFields($table), '', '', '1');
                            $olrow = $this->getDatabaseConnection()->sql_fetch_assoc($res);
                            $this->getDatabaseConnection()->sql_free_result($res);
                            $this->versionOL($table, $olrow);
                            // Merge record content by traversing all fields:
                            if (is_array($olrow)) {
                                if (isset($olrow['_ORIG_uid'])) {
                                    $row['_ORIG_uid'] = $olrow['_ORIG_uid'];
                                }
                                if (isset($olrow['_ORIG_pid'])) {
                                    $row['_ORIG_pid'] = $olrow['_ORIG_pid'];
                                }
                                foreach ($row as $fN => $fV) {
                                    if ($fN !== 'uid' && $fN !== 'pid' && isset($olrow[$fN])) {
                                        if ($this->shouldFieldBeOverlaid($table, $fN, $olrow[$fN])) {
                                            $row[$fN] = $olrow[$fN];
                                        }
                                    } elseif ($fN === 'uid') {
                                        $row['_LOCALIZED_UID'] = $olrow['uid'];
                                    }
                                }
                            } elseif ($OLmode === 'hideNonTranslated' && (int)$row[$GLOBALS['TCA'][$table]['ctrl']['languageField']] === 0) {
                                // Unset, if non-translated records should be hidden. ONLY done if the source
                                // record really is default language and not [All] in which case it is allowed.
                                unset($row);
                            }
                        } elseif ($sys_language_content != $row[$GLOBALS['TCA'][$table]['ctrl']['languageField']]) {
                            unset($row);
                        }
                    } else {
                        // When default language is displayed, we never want to return a record carrying
                        // another language!
                        if ($row[$GLOBALS['TCA'][$table]['ctrl']['languageField']] > 0) {
                            unset($row);
                        }
                    }
                }
            }
        }
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getRecordOverlay'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['getRecordOverlay'] as $classRef) {
                $hookObject = GeneralUtility::getUserObj($classRef);
                if (!$hookObject instanceof PageRepositoryGetRecordOverlayHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface ' . PageRepositoryGetRecordOverlayHookInterface::class, 1269881659);
                }
                $hookObject->getRecordOverlay_postProcess($table, $row, $sys_language_content, $OLmode, $this);
            }
        }
        return $row;
    }

    /************************************************
     *
     * Page related: Menu, Domain record, Root line
     *
     ************************************************/

    public function getMenu($pageId, $fields = '*', $sortField = 'sorting', $additionalWhereClause = '', $checkShortcuts = true)
    {
        return $this->getSubpagesForPages((array)$pageId, $fields, $sortField, $additionalWhereClause, $checkShortcuts);
    }

    public function getMenuForPages(array $pageIds, $fields = '*', $sortField = 'sorting', $additionalWhereClause = '', $checkShortcuts = true)
    {
        return $this->getSubpagesForPages($pageIds, $fields, $sortField, $additionalWhereClause, $checkShortcuts, false);
    }

    protected function getSubpagesForPages(array $pageIds, $fields = '*', $sortField = 'sorting', $additionalWhereClause = '', $checkShortcuts = true, $parentPages = true)
    {
        $pages = [];
        $relationField = $parentPages ? 'pid' : 'uid';
        $db = $this->getDatabaseConnection();

        $whereStatement = $relationField . ' IN ('
            . implode(',', $db->cleanIntArray($pageIds)) . ')'
            . $this->where_hid_del
            . $this->where_groupAccess
            . ' '
            . $additionalWhereClause;

        $databaseResource = $db->exec_SELECTquery(
            $fields,
            'pages',
            $whereStatement,
            '',
            $sortField
        );

        while (($page = $db->sql_fetch_assoc($databaseResource))) {
            $originalUid = $page['uid'];

            // Versioning Preview Overlay
            $this->versionOL('pages', $page, true);

            // Add a mount point parameter if needed
            $page = $this->addMountPointParameterToPage((array)$page);

            // If shortcut, look up if the target exists and is currently visible
            if ($checkShortcuts) {
                $page = $this->checkValidShortcutOfPage((array)$page, $additionalWhereClause);
            }

            // If the page still is there, we add it to the output
            if (!empty($page)) {
                $pages[$originalUid] = $page;
            }
        }

        $db->sql_free_result($databaseResource);

        // Finally load language overlays
        return $this->getPagesOverlay($pages);
    }

    protected function addMountPointParameterToPage(array $page)
    {
        if (empty($page)) {
            return [];
        }

        // $page MUST have "uid", "pid", "doktype", "mount_pid", "mount_pid_ol" fields in it
        $mountPointInfo = $this->getMountPointInfo($page['uid'], $page);

        // There is a valid mount point.
        if (is_array($mountPointInfo) && $mountPointInfo['overlay']) {

            // Using "getPage" is OK since we need the check for enableFields AND for type 2
            // of mount pids we DO require a doktype < 200!
            $mountPointPage = $this->getPage($mountPointInfo['mount_pid']);

            if (!empty($mountPointPage)) {
                $page = $mountPointPage;
                $page['_MP_PARAM'] = $mountPointInfo['MPvar'];
            } else {
                $page = [];
            }
        }
        return $page;
    }

    protected function checkValidShortcutOfPage(array $page, $additionalWhereClause)
    {
        if (empty($page)) {
            return [];
        }

        $dokType = (int)$page['doktype'];
        $shortcutMode = (int)$page['shortcut_mode'];

        if ($dokType === self::DOKTYPE_SHORTCUT && ($page['shortcut'] || $shortcutMode)) {
            if ($shortcutMode === self::SHORTCUT_MODE_NONE) {
                // No shortcut_mode set, so target is directly set in $page['shortcut']
                $searchField = 'uid';
                $searchUid = (int)$page['shortcut'];
            } elseif ($shortcutMode === self::SHORTCUT_MODE_FIRST_SUBPAGE || $shortcutMode === self::SHORTCUT_MODE_RANDOM_SUBPAGE) {
                // Check subpages - first subpage or random subpage
                $searchField = 'pid';
                // If a shortcut mode is set and no valid page is given to select subpags
                // from use the actual page.
                $searchUid = (int)$page['shortcut'] ?: $page['uid'];
            } elseif ($shortcutMode === self::SHORTCUT_MODE_PARENT_PAGE) {
                // Shortcut to parent page
                $searchField = 'uid';
                $searchUid = $page['pid'];
            } else {
                $searchField = '';
                $searchUid = 0;
            }

            $whereStatement = $searchField . '=' . $searchUid
                . $this->where_hid_del
                . $this->where_groupAccess
                . ' ' . $additionalWhereClause;

            $count = $this->getDatabaseConnection()->exec_SELECTcountRows(
                'uid',
                'pages',
                $whereStatement
            );

            if (!$count) {
                $page = [];
            }
        } elseif ($dokType === self::DOKTYPE_SHORTCUT) {
            // Neither shortcut target nor mode is set. Remove the page from the menu.
            $page = [];
        }
        return $page;
    }
    public function getDomainStartPage($domain, $path = '', $request_uri = '')
    {
        $domain = explode(':', $domain);
        $domain = strtolower(preg_replace('/\\.$/', '', $domain[0]));
        // Removing extra trailing slashes
        $path = trim(preg_replace('/\\/[^\\/]*$/', '', $path));
        // Appending to domain string
        $domain .= $path;
        $domain = preg_replace('/\\/*$/', '', $domain);
        $res = $this->getDatabaseConnection()->exec_SELECTquery('pages.uid,sys_domain.redirectTo,sys_domain.redirectHttpStatusCode,sys_domain.prepend_params', 'pages,sys_domain', 'pages.uid=sys_domain.pid
                                                AND sys_domain.hidden=0
                                                AND (sys_domain.domainName=' . $this->getDatabaseConnection()->fullQuoteStr($domain, 'sys_domain') . ' OR sys_domain.domainName=' . $this->getDatabaseConnection()->fullQuoteStr(($domain . '/'), 'sys_domain') . ') ' . $this->where_hid_del . $this->where_groupAccess, '', '', 1);
        $row = $this->getDatabaseConnection()->sql_fetch_assoc($res);
        $this->getDatabaseConnection()->sql_free_result($res);
        if ($row) {
            if ($row['redirectTo']) {
                $redirectUrl = $row['redirectTo'];
                if ($row['prepend_params']) {
                    $redirectUrl = rtrim($redirectUrl, '/');
                    $prependStr = ltrim(substr($request_uri, strlen($path)), '/');
                    $redirectUrl .= '/' . $prependStr;
                }
                $statusCode = (int)$row['redirectHttpStatusCode'];
                if ($statusCode && defined(HttpUtility::class . '::HTTP_STATUS_' . $statusCode)) {
                    HttpUtility::redirect($redirectUrl, constant(HttpUtility::class . '::HTTP_STATUS_' . $statusCode));
                } else {
                    HttpUtility::redirect($redirectUrl, HttpUtility::HTTP_STATUS_301);
                }
                die;
            } else {
                return $row['uid'];
            }
        }
        return '';
    }

    public function getRootLine($uid, $MP = '', $ignoreMPerrors = false)
    {
        $rootline = GeneralUtility::makeInstance(RootlineUtility::class, $uid, $MP, $this);
        try {
            return $rootline->get();
        } catch (\RuntimeException $ex) {
            if ($ignoreMPerrors) {
                $this->error_getRootLine = $ex->getMessage();
                if (substr($this->error_getRootLine, -7) === 'uid -1.') {
                    $this->error_getRootLine_failPid = -1;
                }
                return array();
            } elseif ($ex->getCode() === 1343589451) {
                return array();
            }
            throw $ex;
        }
    }

    public function getPathFromRootline($rl, $len = 20)
    {
        $path = '';
        if (is_array($rl)) {
            $c = count($rl);
            for ($a = 0; $a < $c; $a++) {
                if ($rl[$a]['uid']) {
                    $path .= '/' . GeneralUtility::fixed_lgd_cs(strip_tags($rl[$a]['title']), $len);
                }
            }
        }
        return $path;
    }

    public function getExtURL($pagerow, $disable = false)
    {
        if ($disable !== false) {
            GeneralUtility::deprecationLog('The disable option of PageRepository::getExtUrl() is deprecated since TYPO3 CMS 7, will be removed with TYPO3 CMS 8.');
            return false;
        }
        if ((int)$pagerow['doktype'] === self::DOKTYPE_LINK) {
            $redirectTo = $this->urltypes[$pagerow['urltype']] . $pagerow['url'];
            // If relative path, prefix Site URL:
            $uI = parse_url($redirectTo);
            // Relative path assumed now.
            if (!$uI['scheme'] && $redirectTo[0] !== '/') {
                $redirectTo = GeneralUtility::getIndpEnv('TYPO3_SITE_URL') . $redirectTo;
            }
            return $redirectTo;
        }
        return false;
    }

    public function getMountPointInfo($pageId, $pageRec = false, $prevMountPids = array(), $firstPageUid = 0)
    {
        $result = false;
        if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids']) {
            if (isset($this->cache_getMountPointInfo[$pageId])) {
                return $this->cache_getMountPointInfo[$pageId];
            }
            // Get pageRec if not supplied:
            if (!is_array($pageRec)) {
                $res = $this->getDatabaseConnection()->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol,t3ver_state', 'pages', 'uid=' . (int)$pageId . ' AND pages.deleted=0 AND pages.doktype<>255');
                $pageRec = $this->getDatabaseConnection()->sql_fetch_assoc($res);
                $this->getDatabaseConnection()->sql_free_result($res);
                // Only look for version overlay if page record is not supplied; This assumes
                // that the input record is overlaid with preview version, if any!
                $this->versionOL('pages', $pageRec);
            }
            // Set first Page uid:
            if (!$firstPageUid) {
                $firstPageUid = $pageRec['uid'];
            }
            // Look for mount pid value plus other required circumstances:
            $mount_pid = (int)$pageRec['mount_pid'];
            if (is_array($pageRec) && (int)$pageRec['doktype'] === self::DOKTYPE_MOUNTPOINT && $mount_pid > 0 && !in_array($mount_pid, $prevMountPids, true)) {
                // Get the mount point record (to verify its general existence):
                $res = $this->getDatabaseConnection()->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol,t3ver_state', 'pages', 'uid=' . $mount_pid . ' AND pages.deleted=0 AND pages.doktype<>255');
                $mountRec = $this->getDatabaseConnection()->sql_fetch_assoc($res);
                $this->getDatabaseConnection()->sql_free_result($res);
                $this->versionOL('pages', $mountRec);
                if (is_array($mountRec)) {
                    // Look for recursive mount point:
                    $prevMountPids[] = $mount_pid;
                    $recursiveMountPid = $this->getMountPointInfo($mount_pid, $mountRec, $prevMountPids, $firstPageUid);
                    // Return mount point information:
                    $result = $recursiveMountPid ?: array(
                        'mount_pid' => $mount_pid,
                        'overlay' => $pageRec['mount_pid_ol'],
                        'MPvar' => $mount_pid . '-' . $firstPageUid,
                        'mount_point_rec' => $pageRec,
                        'mount_pid_rec' => $mountRec
                    );
                } else {
                    // Means, there SHOULD have been a mount point, but there was none!
                    $result = -1;
                }
            }
        }
        $this->cache_getMountPointInfo[$pageId] = $result;
        return $result;
    }

    /********************************
     *
     * Selecting records in general
     *
     ********************************/

    public function checkRecord($table, $uid, $checkPage = 0)
    {
        $uid = (int)$uid;
        if (is_array($GLOBALS['TCA'][$table]) && $uid > 0) {
            $res = $this->getDatabaseConnection()->exec_SELECTquery('*', $table, 'uid = ' . $uid . $this->enableFields($table));
            $row = $this->getDatabaseConnection()->sql_fetch_assoc($res);
            $this->getDatabaseConnection()->sql_free_result($res);
            if ($row) {
                $this->versionOL($table, $row);
                if (is_array($row)) {
                    if ($checkPage) {
                        $res = $this->getDatabaseConnection()->exec_SELECTquery('uid', 'pages', 'uid=' . (int)$row['pid'] . $this->enableFields('pages'));
                        $numRows = $this->getDatabaseConnection()->sql_num_rows($res);
                        $this->getDatabaseConnection()->sql_free_result($res);
                        if ($numRows > 0) {
                            return $row;
                        } else {
                            return 0;
                        }
                    } else {
                        return $row;
                    }
                }
            }
        }
        return 0;
    }

    public function getRawRecord($table, $uid, $fields = '*', $noWSOL = false)
    {
        $uid = (int)$uid;
        if (isset($GLOBALS['TCA'][$table]) && is_array($GLOBALS['TCA'][$table]) && $uid > 0) {
            $res = $this->getDatabaseConnection()->exec_SELECTquery($fields, $table, 'uid = ' . $uid . $this->deleteClause($table));
            $row = $this->getDatabaseConnection()->sql_fetch_assoc($res);
            $this->getDatabaseConnection()->sql_free_result($res);
            if ($row) {
                if (!$noWSOL) {
                    $this->versionOL($table, $row);
                }
                if (is_array($row)) {
                    return $row;
                }
            }
        }
        return 0;
    }

    public function getRecordsByField($theTable, $theField, $theValue, $whereClause = '', $groupBy = '', $orderBy = '', $limit = '')
    {
        if (is_array($GLOBALS['TCA'][$theTable])) {
            $res = $this->getDatabaseConnection()->exec_SELECTquery('*', $theTable, $theField . '=' . $this->getDatabaseConnection()->fullQuoteStr($theValue, $theTable) . $this->deleteClause($theTable) . ' ' . $whereClause, $groupBy, $orderBy, $limit);
            $rows = array();
            while ($row = $this->getDatabaseConnection()->sql_fetch_assoc($res)) {
                if (is_array($row)) {
                    $rows[] = $row;
                }
            }
            $this->getDatabaseConnection()->sql_free_result($res);
            if (!empty($rows)) {
                return $rows;
            }
        }
        return null;
    }

    /********************************
     *
     * Caching and standard clauses
     *
     ********************************/

    public static function getHash($hash)
    {
        $hashContent = null;
        $contentHashCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_hash');
        $cacheEntry = $contentHashCache->get($hash);
        if ($cacheEntry) {
            $hashContent = $cacheEntry;
        }
        return $hashContent;
    }

    public static function storeHash($hash, $data, $ident, $lifetime = 0)
    {
        GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_hash')->set($hash, $data, array('ident_' . $ident), (int)$lifetime);
    }

    public function deleteClause($table)
    {
        return $GLOBALS['TCA'][$table]['ctrl']['delete'] ? ' AND ' . $table . '.' . $GLOBALS['TCA'][$table]['ctrl']['delete'] . '=0' : '';
    }

    public function enableFields($table, $show_hidden = -1, $ignore_array = array(), $noVersionPreview = false)
    {
        if ($show_hidden === -1 && is_object($this->getTypoScriptFrontendController())) {
            // If show_hidden was not set from outside and if TSFE is an object, set it
            // based on showHiddenPage and showHiddenRecords from TSFE
            $show_hidden = $table === 'pages' ? $this->getTypoScriptFrontendController()->showHiddenPage : $this->getTypoScriptFrontendController()->showHiddenRecords;
        }
        if ($show_hidden === -1) {
            $show_hidden = 0;
        }
        // If show_hidden was not changed during the previous evaluation, do it here.
        $ctrl = $GLOBALS['TCA'][$table]['ctrl'];
        $query = '';
        if (is_array($ctrl)) {
            // Delete field check:
            if ($ctrl['delete']) {
                $query .= ' AND ' . $table . '.' . $ctrl['delete'] . '=0';
            }
            if ($ctrl['versioningWS']) {
                if (!$this->versioningPreview) {
                    // Filter out placeholder records (new/moved/deleted items)
                    // in case we are NOT in a versioning preview (that means we are online!)
                    $query .= ' AND ' . $table . '.t3ver_state<=' . new VersionState(VersionState::DEFAULT_STATE);
                } elseif ($table !== 'pages') {
                    // show only records of live and of the current workspace
                    // in case we are in a versioning preview
                    $query .= ' AND (' .
                                $table . '.t3ver_wsid=0 OR ' .
                                $table . '.t3ver_wsid=' . (int)$this->versioningWorkspaceId .
                                ')';
                }

                // Filter out versioned records
                if (!$noVersionPreview && empty($ignore_array['pid'])) {
                    $query .= ' AND ' . $table . '.pid<>-1';
                }
            }

            // Enable fields:
            if (is_array($ctrl['enablecolumns'])) {
                // In case of versioning-preview, enableFields are ignored (checked in
                // versionOL())
                if (!$this->versioningPreview || !$ctrl['versioningWS'] || $noVersionPreview) {
                    if ($ctrl['enablecolumns']['disabled'] && !$show_hidden && !$ignore_array['disabled']) {
                        $field = $table . '.' . $ctrl['enablecolumns']['disabled'];
                        $query .= ' AND ' . $field . '=0';
                    }
                    if ($ctrl['enablecolumns']['starttime'] && !$ignore_array['starttime']) {
                        $field = $table . '.' . $ctrl['enablecolumns']['starttime'];
                        $query .= ' AND ' . $field . '<=' . $GLOBALS['SIM_ACCESS_TIME'];
                    }
                    if ($ctrl['enablecolumns']['endtime'] && !$ignore_array['endtime']) {
                        $field = $table . '.' . $ctrl['enablecolumns']['endtime'];
                        $query .= ' AND (' . $field . '=0 OR ' . $field . '>' . $GLOBALS['SIM_ACCESS_TIME'] . ')';
                    }
                    if ($ctrl['enablecolumns']['fe_group'] && !$ignore_array['fe_group']) {
                        $field = $table . '.' . $ctrl['enablecolumns']['fe_group'];
                        $query .= $this->getMultipleGroupsWhereClause($field, $table);
                    }
                    // Call hook functions for additional enableColumns
                    // It is used by the extension ingmar_accessctrl which enables assigning more
                    // than one usergroup to content and page records
                    if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['addEnableColumns'])) {
                        $_params = array(
                            'table' => $table,
                            'show_hidden' => $show_hidden,
                            'ignore_array' => $ignore_array,
                            'ctrl' => $ctrl
                        );
                        foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_page.php']['addEnableColumns'] as $_funcRef) {
                            $query .= GeneralUtility::callUserFunction($_funcRef, $_params, $this);
                        }
                    }
                }
            }
        } else {
            throw new \InvalidArgumentException('There is no entry in the $TCA array for the table "' . $table . '". This means that the function enableFields() is ' . 'called with an invalid table name as argument.', 1283790586);
        }
        return $query;
    }

    public function getMultipleGroupsWhereClause($field, $table)
    {
        $memberGroups = GeneralUtility::intExplode(',', $this->getTypoScriptFrontendController()->gr_list);
        $orChecks = array();
        // If the field is empty, then OK
        $orChecks[] = $field . '=\'\'';
        // If the field is NULL, then OK
        $orChecks[] = $field . ' IS NULL';
        // If the field contsains zero, then OK
        $orChecks[] = $field . '=\'0\'';
        foreach ($memberGroups as $value) {
            $orChecks[] = $this->getDatabaseConnection()->listQuery($field, $value, $table);
        }
        return ' AND (' . implode(' OR ', $orChecks) . ')';
    }

    /**********************
     *
     * Versioning Preview
     *
     **********************/

    public function fixVersioningPid($table, &$rr)
    {
        if ($this->versioningPreview && is_array($rr) && (int)$rr['pid'] === -1 && $GLOBALS['TCA'][$table]['ctrl']['versioningWS']) {
            $oid = 0;
            $wsid = 0;
            // Have to hardcode it for "pages" table since TCA is not loaded at this moment!
            // 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 {
                // Otherwise we have to expect "uid" to be in the record and look up based
                // on this:
                $newPidRec = $this->getRawRecord($table, $rr['uid'], 't3ver_oid,t3ver_wsid', true);
                if (is_array($newPidRec)) {
                    $oid = $newPidRec['t3ver_oid'];
                    $wsid = $newPidRec['t3ver_wsid'];
                }
            }
            // If workspace ids matches and ID of current online version is found, look up
            // the PID value of that:
            if ($oid && ((int)$this->versioningWorkspaceId === 0 && $this->checkWorkspaceAccess($wsid) || (int)$wsid === (int)$this->versioningWorkspaceId)) {
                $oidRec = $this->getRawRecord($table, $oid, 'pid', true);
                if (is_array($oidRec)) {
                    // SWAP uid as well? Well no, because when fixing a versioning PID happens it is
                    // assumed that this is a "branch" type page and therefore the uid should be
                    // kept (like in versionOL()). However if the page is NOT a branch version it
                    // should not happen - but then again, direct access to that uid should not
                    // happen!
                    $rr['_ORIG_pid'] = $rr['pid'];
                    $rr['pid'] = $oidRec['pid'];
                }
            }
        }
        // Changing PID in case of moving pointer:
        if ($movePlhRec = $this->getMovePlaceholder($table, $rr['uid'], 'pid')) {
            $rr['pid'] = $movePlhRec['pid'];
        }
    }

    public function versionOL($table, &$row, $unsetMovePointers = false, $bypassEnableFieldsCheck = false)
    {
        if ($this->versioningPreview && is_array($row)) {
            // will overlay any movePlhOL found with the real record, which in turn
            // will be overlaid with its workspace version if any.
            $movePldSwap = $this->movePlhOL($table, $row);
            // implode(',',array_keys($row)) = Using fields from original record to make
            // sure no additional fields are selected. This is best for eg. getPageOverlay()
            // Computed properties are excluded since those would lead to SQL errors.
            $fieldNames = implode(',', array_keys($this->purgeComputedProperties($row)));
            if ($wsAlt = $this->getWorkspaceVersionOfRecord($this->versioningWorkspaceId, $table, $row['uid'], $fieldNames, $bypassEnableFieldsCheck)) {
                if (is_array($wsAlt)) {
                    // Always fix PID (like in fixVersioningPid() above). [This is usually not
                    // the important factor for versioning OL]
                    // 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, preserve online UID and PID
                    // (this will produce true "overlay" of element _content_, not any references)
                    // For page+content the "_ORIG_uid" should actually be used as PID for selection
                    // of tables with "versioning_followPages" enabled.
                    $wsAlt['_ORIG_uid'] = $wsAlt['uid'];
                    $wsAlt['uid'] = $row['uid'];
                    // Translate page alias as well so links are pointing to the _online_ page:
                    if ($table === 'pages') {
                        $wsAlt['alias'] = $row['alias'];
                    }
                    // Changing input record to the workspace version alternative:
                    $row = $wsAlt;
                    // Check if it is deleted/new
                    $rowVersionState = VersionState::cast($row['t3ver_state']);
                    if (
                        $rowVersionState->equals(VersionState::NEW_PLACEHOLDER)
                        || $rowVersionState->equals(VersionState::DELETE_PLACEHOLDER)
                    ) {
                        // Unset record if it turned out to be deleted in workspace
                        $row = false;
                    }
                    // Check if move-pointer in workspace (unless if a move-placeholder is the
                    // reason why it appears!):
                    // You have to specifically set $unsetMovePointers in order to clear these
                    // because it is normally a display issue if it should be shown or not.
                    if (
                        ($rowVersionState->equals(VersionState::MOVE_POINTER)
                            && !$movePldSwap
                        ) && $unsetMovePointers
                    ) {
                        // Unset record if it turned out to be deleted in workspace
                        $row = false;
                    }
                } else {
                    // No version found, then check if t3ver_state = VersionState::NEW_PLACEHOLDER
                    // (online version is dummy-representation)
                    // Notice, that unless $bypassEnableFieldsCheck is TRUE, the $row is unset if
                    // enablefields for BOTH the version AND the online record deselects it. See
                    // note for $bypassEnableFieldsCheck
                    $versionState = VersionState::cast($row['t3ver_state']);
                    if ($wsAlt <= -1 || $versionState->indicatesPlaceholder()) {
                        // Unset record if it turned out to be "hidden"
                        $row = false;
                    }
                }
            }
        }
    }

    public function movePlhOL($table, &$row)
    {
        if (!empty($GLOBALS['TCA'][$table]['ctrl']['versioningWS'])
            && (int)VersionState::cast($row['t3ver_state'])->equals(VersionState::MOVE_PLACEHOLDER)
        ) {
            // Only for WS ver 2... (moving) - enabled by default with CMS7
            // If t3ver_move_id is not found, then find it (but we like best if it is here)
            if (!isset($row['t3ver_move_id'])) {
                $moveIDRec = $this->getRawRecord($table, $row['uid'], 't3ver_move_id', true);
                $moveID = $moveIDRec['t3ver_move_id'];
            } else {
                $moveID = $row['t3ver_move_id'];
            }
            // Find pointed-to record.
            if ($moveID) {
                $res = $this->getDatabaseConnection()->exec_SELECTquery(implode(',', array_keys($row)), $table, 'uid=' . (int)$moveID . $this->enableFields($table));
                $origRow = $this->getDatabaseConnection()->sql_fetch_assoc($res);
                $this->getDatabaseConnection()->sql_free_result($res);
                if ($origRow) {
                    $row = $origRow;
                    return true;
                }
            }
        }
        return false;
    }

    public function getMovePlaceholder($table, $uid, $fields = '*')
    {
        if ($this->versioningPreview) {
            $workspace = (int)$this->versioningWorkspaceId;
            if (!empty($GLOBALS['TCA'][$table]['ctrl']['versioningWS']) && $workspace !== 0) {
                // Select workspace version of record:
                $row = $this->getDatabaseConnection()->exec_SELECTgetSingleRow($fields, $table, 'pid<>-1 AND
                                                t3ver_state=' . new VersionState(VersionState::MOVE_PLACEHOLDER) . ' AND
                                                t3ver_move_id=' . (int)$uid . ' AND
                                                t3ver_wsid=' . (int)$workspace . $this->deleteClause($table));
                if (is_array($row)) {
                    return $row;
                }
            }
        }
        return false;
    }

    public function getWorkspaceVersionOfRecord($workspace, $table, $uid, $fields = '*', $bypassEnableFieldsCheck = false)
    {
        if ($workspace !== 0 && !empty($GLOBALS['TCA'][$table]['ctrl']['versioningWS'])) {
            $workspace = (int)$workspace;
            $uid = (int)$uid;
            // Setting up enableFields for version record
            $enFields = $this->enableFields($table, -1, array(), true);
            // Select workspace version of record, only testing for deleted.
            $newrow = $this->getDatabaseConnection()->exec_SELECTgetSingleRow($fields, $table, 'pid=-1 AND
                                        t3ver_oid=' . $uid . ' AND
                                        t3ver_wsid=' . $workspace . $this->deleteClause($table));
            // If version found, check if it could have been selected with enableFields on
            // as well:
            if (is_array($newrow)) {
                if ($bypassEnableFieldsCheck || $this->getDatabaseConnection()->exec_SELECTgetSingleRow('uid', $table, 'pid=-1 AND
                                                t3ver_oid=' . $uid . ' AND
                                                t3ver_wsid=' . $workspace . $enFields)) {
                    // Return offline version, tested for its enableFields.
                    return $newrow;
                } else {
                    // Return -1 because offline version was de-selected due to its enableFields.
                    return -1;
                }
            } else {
                // OK, so no workspace version was found. Then check if online version can be
                // selected with full enable fields and if so, return 1:
                if ($bypassEnableFieldsCheck || $this->getDatabaseConnection()->exec_SELECTgetSingleRow('uid', $table, 'uid=' . $uid . $enFields)) {
                    // Means search was done, but no version found.
                    return 1;
                } else {
                    // Return -2 because the online record was de-selected due to its enableFields.
                    return -2;
                }
            }
        }
        // No look up in database because versioning not enabled / or workspace not
        // offline
        return false;
    }

    public function checkWorkspaceAccess($wsid)
    {
        if (!$this->getBackendUser() || !ExtensionManagementUtility::isLoaded('workspaces')) {
            return false;
        }
        if (isset($this->workspaceCache[$wsid])) {
            $ws = $this->workspaceCache[$wsid];
        } else {
            if ($wsid > 0) {
                // No $GLOBALS['TCA'] yet!
                $ws = $this->getDatabaseConnection()->exec_SELECTgetSingleRow('*', 'sys_workspace', 'uid=' . (int)$wsid . ' AND deleted=0');
                if (!is_array($ws)) {
                    return false;
                }
            } else {
                $ws = $wsid;
            }
            $ws = $this->getBackendUser()->checkWorkspace($ws);
            $this->workspaceCache[$wsid] = $ws;
        }
        return (string)$ws['_ACCESS'] !== '';
    }

    public function getFileReferences($tableName, $fieldName, array $element)
    {
        $fileRepository = GeneralUtility::makeInstance(FileRepository::class);
        $currentId = !empty($element['uid']) ? $element['uid'] : 0;

        // Fetch the references of the default element
        try {
            $references = $fileRepository->findByRelation($tableName, $fieldName, $currentId);
        } catch (FileDoesNotExistException $e) {
            return array();
        } catch (\InvalidArgumentException $e) {
            $logMessage = $e->getMessage() . ' (table: "' . $tableName . '", fieldName: "' . $fieldName . '", currentId: ' . $currentId . ')';
            GeneralUtility::sysLog($logMessage, 'core', GeneralUtility::SYSLOG_SEVERITY_ERROR);
            return array();
        }

        $localizedId = null;
        if (isset($element['_LOCALIZED_UID'])) {
            $localizedId = $element['_LOCALIZED_UID'];
        } elseif (isset($element['_PAGES_OVERLAY_UID'])) {
            $localizedId = $element['_PAGES_OVERLAY_UID'];
        }

        if (!empty($GLOBALS['TCA'][$tableName]['ctrl']['transForeignTable'])) {
            $tableName = $GLOBALS['TCA'][$tableName]['ctrl']['transForeignTable'];
        }

        $isTableLocalizable = (
            !empty($GLOBALS['TCA'][$tableName]['ctrl']['languageField'])
            && !empty($GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'])
        );
        if ($isTableLocalizable && $localizedId !== null) {
            $localizedReferences = $fileRepository->findByRelation($tableName, $fieldName, $localizedId);
            $localizedReferencesValue = $localizedReferences ?: '';
            if ($this->shouldFieldBeOverlaid($tableName, $fieldName, $localizedReferencesValue)) {
                $references = $localizedReferences;
            }
        }

        return $references;
    }

    protected function purgeComputedProperties(array $row)
    {
        foreach ($this->computedPropertyNames as $computedPropertyName) {
            if (array_key_exists($computedPropertyName, $row)) {
                unset($row[$computedPropertyName]);
            }
        }
        return $row;
    }

    protected function shouldFieldBeOverlaid($table, $field, $value)
    {
        $l10n_mode = isset($GLOBALS['TCA'][$table]['columns'][$field]['l10n_mode'])
            ? $GLOBALS['TCA'][$table]['columns'][$field]['l10n_mode']
            : '';

        $shouldFieldBeOverlaid = true;

        if ($l10n_mode === 'exclude') {
            $shouldFieldBeOverlaid = false;
        } elseif ($l10n_mode === 'mergeIfNotBlank') {
            $checkValue = $value;

            // 0 values are considered blank when coming from a group field
            if (empty($value) && $GLOBALS['TCA'][$table]['columns'][$field]['config']['type'] === 'group') {
                $checkValue = '';
            }

            if ($checkValue === array() || !is_array($checkValue) && trim($checkValue) === '') {
                $shouldFieldBeOverlaid = false;
            }
        }

        return $shouldFieldBeOverlaid;
    }

    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }

    protected function getTypoScriptFrontendController()
    {
        return $GLOBALS['TSFE'];
    }

    protected function getBackendUser()
    {
        return $GLOBALS['BE_USER'];
    }
}