Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.t3lib_page.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2005 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
class t3lib_pageSelect {
        var $urltypes = Array('','http://','ftp://','mailto:');
        var $where_hid_del = ' AND pages.deleted=0';    // This is not the final clauses. There will normally be conditions for the hidden,starttime and endtime fields as well. You MUST initialize the object by the init() function
        var $where_groupAccess = '';    // Clause for fe_group access
        var $sys_language_uid = 0;

                // Versioning preview related:
        var $versioningPreview = FALSE;         // If true, preview of other record versions is allowed. THIS MUST ONLY BE SET IF the page is not cached and truely previewed by a backend user!!!
        var $versionPreviewMap = array(
# EXAMPLE:              'tt_content:421' => 427
        );


                // Internal, dynamic:
        var $error_getRootLine = '';            // Error string set by getRootLine()
        var $error_getRootLine_failPid = 0;             // Error uid set by getRootLine()


        function init($show_hidden)     {
                $this->where_groupAccess = '';
                $this->where_hid_del = ' AND pages.deleted=0 ';
                if (!$show_hidden)      {
                        $this->where_hid_del.= 'AND pages.hidden=0 ';
                }
                $this->where_hid_del.= 'AND (pages.starttime<='.$GLOBALS['SIM_EXEC_TIME'].') AND (pages.endtime=0 OR pages.endtime>'.$GLOBALS['SIM_EXEC_TIME'].') ';
        }

















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

        function getPage($uid, $disableGroupAccessCheck=FALSE)  {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'uid='.intval($uid).$this->where_hid_del.($disableGroupAccessCheck ? '' : $this->where_groupAccess));
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
#??                     $this->versionOL('pages',$row);
                        return $this->getPageOverlay($row);
                }
                return Array();
        }

        function getPage_noCheck($uid)  {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'uid='.intval($uid).$this->deleteClause('pages'));
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
#??                     $this->versionOL('pages',$row);
                        return $this->getPageOverlay($row);
                }
                return Array();
        }

        function getFirstWebPage($uid)  {
                $output = '';
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'pid='.intval($uid).$this->where_hid_del.$this->where_groupAccess, '', 'sorting', '1');
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
#??                     $this->versionOL('pages',$row);
                        $output = $this->getPageOverlay($row);
                }
                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                return $output;
        }

        function getPageIdFromAlias($alias)     {
                $alias = strtolower($alias);
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'alias='.$GLOBALS['TYPO3_DB']->fullQuoteStr($alias, 'pages').' AND pid>=0 AND pages.deleted=0');  // "AND pid>=0" is because of versioning...
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        return $row['uid'];
                }
                return 0;
        }

        function getPageOverlay($pageInput,$lUid=-1)    {

                        // Initialize:
                if ($lUid<0)    $lUid = $this->sys_language_uid;
                unset($row);

                        // If language UID is different from zero, do overlay:
                if ($lUid)      {
                        $fieldArr = explode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['pageOverlayFields']);
                        if (is_array($pageInput))       {
                                $page_id = $pageInput['uid'];   // Was the whole record
                                $fieldArr = array_intersect($fieldArr,array_keys($pageInput));          // Make sure that only fields which exist in the incoming record are overlaid!
                        } else {
                                $page_id = $pageInput;  // Was the id
                        }

                        if (count($fieldArr))   {
                                /*
                                        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:
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                        implode(',',$fieldArr),
                                                        'pages_language_overlay',
                                                        'pid='.intval($page_id).'
                                                                AND sys_language_uid='.intval($lUid).
                                                                $this->enableFields('pages_language_overlay'),
                                                        '',
                                                        '',
                                                        '1'
                                                );
                                $row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
                                if (is_array($row))     {
                                        $row['_PAGES_OVERLAY'] = TRUE;
                                        $this->versionOL('pages_language_overlay',$row);

                                                // Unset vital fields that are NOT allowed to be overlaid:
                                        unset($row['uid']);
                                        unset($row['pid']);
                                }
                        }
                }

                        // Create output:
                if (is_array($pageInput))       {
                        return is_array($row) ? array_merge($pageInput,$row) : $pageInput;      // If the input was an array, simply overlay the newfound array and return...
                } else {
                        return is_array($row) ? $row : array(); // always an array in return
                }
        }

        function getRecordOverlay($table,$row,$sys_language_content,$OLmode='') {
                global $TCA;

                if ($row['uid']>0 && $row['pid']>0)     {
                        if ($TCA[$table] && $TCA[$table]['ctrl']['languageField'] && $TCA[$table]['ctrl']['transOrigPointerField'])     {
                                if (!$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 that zero.
                                        if ($sys_language_content>0)    {

                                                        // Must be default language or [All], otherwise no overlaying:
                                                if ($row[$TCA[$table]['ctrl']['languageField']]<=0)     {

                                                                // Select overlay record:
                                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                                                '*',
                                                                                $table,
                                                                                'pid='.intval($row['pid']).
                                                                                        ' AND '.$TCA[$table]['ctrl']['languageField'].'='.intval($sys_language_content).
                                                                                        ' AND '.$TCA[$table]['ctrl']['transOrigPointerField'].'='.intval($row['uid']).
                                                                                        $this->enableFields($table),
                                                                                '',
                                                                                '',
                                                                                '1'
                                                                        );
                                                        $olrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
                                                        $this->versionOL($table,$olrow);
        #debug($row);
        #debug($olrow);
                                                                // Merge record content by traversing all fields:
                                                        if (is_array($olrow))   {
                                                                foreach($row as $fN => $fV)     {
                                                                        if ($fN!='uid' && $fN!='pid' && isset($olrow[$fN]))     {

                                                                                if ($GLOBALS['TSFE']->TCAcachedExtras[$table]['l10n_mode'][$fN]!='exclude'
                                                                                                && ($GLOBALS['TSFE']->TCAcachedExtras[$table]['l10n_mode'][$fN]!='mergeIfNotBlank' || strcmp(trim($olrow[$fN]),'')))    {
                                                                                        $row[$fN] = $olrow[$fN];
                                                                                }
                                                                        }
                                                                }
                                                        } elseif ($OLmode==='hideNonTranslated' && $row[$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);
                                                        }

                                                        // Otherwise, check if sys_language_content is different from the value of the record - that means a japanese site might try to display french content.
                                                } elseif ($sys_language_content!=$row[$TCA[$table]['ctrl']['languageField']])   {
                                                        unset($row);
                                                }
                                        } else {
                                                        // When default language is displayed, we never want to return a record carrying another language!:
                                                if ($row[$TCA[$table]['ctrl']['languageField']]>0)      {
                                                        unset($row);
                                                }
                                        }
                                }
                        }
                }

                return $row;
        }


















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

        function getMenu($uid,$fields='*',$sortField='sorting',$addWhere='')    {
                $output = Array();
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($fields, 'pages', 'pid='.intval($uid).$this->where_hid_del.$this->where_groupAccess.' '.$addWhere, '', $sortField);
                while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
#??                     $this->versionOL('pages',$row);

                                // Keep mount point:
                        $origUid = $row['uid'];
                        $mount_info = $this->getMountPointInfo($origUid, $row); // $row MUST have "uid", "pid", "doktype", "mount_pid", "mount_pid_ol" fields in it
                        if (is_array($mount_info) && $mount_info['overlay'])    {       // There is a valid mount point.
                                $mp_row = $this->getPage($mount_info['mount_pid']);             // Using "getPage" is OK since we need the check for enableFields AND for type 2 of mount pids we DO require a doktype < 200!
                                if (count($mp_row))     {
                                        $row = $mp_row;
                                        $row['_MP_PARAM'] = $mount_info['MPvar'];
                                } else unset($row);     // If the mount point could not be fetched with respect to enableFields, unset the row so it does not become a part of the menu!
                        }

                                // Add to output array after overlaying language:
                        if (is_array($row))     {
                                $output[$origUid] = $this->getPageOverlay($row);
                        }
                }
                return $output;
        }

        function getDomainStartPage($domain, $path='',$request_uri='')  {
                $domain = explode(':',$domain);
                $domain = strtolower(ereg_replace('\.$','',$domain[0]));
                        // Removing extra trailing slashes
                $path = trim(ereg_replace('\/[^\/]*$','',$path));
                        // Appending to domain string
                $domain.= $path;
                $domain = ereg_replace('\/*$','',$domain);

                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                        'pages.uid,sys_domain.redirectTo,sys_domain.prepend_params',
                                        'pages,sys_domain',
                                        'pages.uid=sys_domain.pid
                                                AND sys_domain.hidden=0
                                                AND (sys_domain.domainName='.$GLOBALS['TYPO3_DB']->fullQuoteStr($domain, 'sys_domain').' OR sys_domain.domainName='.$GLOBALS['TYPO3_DB']->fullQuoteStr($domain.'/', 'sys_domain').') '.
                                                $this->where_hid_del.$this->where_groupAccess,
                                        '',
                                        '',
                                        1
                                );
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        if ($row['redirectTo']) {
                                $rURL = $row['redirectTo'];
                                if ($row['prepend_params'])     {
                                        $rURL = ereg_replace('\/$','',$rURL);
                                        $prependStr = ereg_replace('^\/','',substr($request_uri,strlen($path)));
                                        $rURL.= '/'.$prependStr;
                                }
                                Header('Location: '.t3lib_div::locationHeaderUrl($rURL));
                                exit;
                        } else {
                                return $row['uid'];
                        }
                }
        }

        function getRootLine($uid, $MP='', $ignoreMPerrors=FALSE)       {

                        // Initialize:
                $selFields = t3lib_div::uniqueList('pid,uid,t3ver_oid,title,alias,nav_title,media,layout,hidden,starttime,endtime,fe_group,extendToSubpages,doktype,TSconfig,storage_pid,is_siteroot,mount_pid,mount_pid_ol,fe_login_mode,'.$GLOBALS['TYPO3_CONF_VARS']['FE']['addRootLineFields']);
                $this->error_getRootLine = '';
                $this->error_getRootLine_failPid = 0;

                        // Splitting the $MP parameters if present
                $MPA = array();
                if ($MP)        {
                        $MPA = explode(',',$MP);
                        reset($MPA);
                        while(list($MPAk) = each($MPA)) {
                                $MPA[$MPAk] = explode('-', $MPA[$MPAk]);
                        }
                }

                $loopCheck = 0;
                $theRowArray = Array();
                $uid = intval($uid);

                while ($uid!=0 && $loopCheck<20)        {       // Max 20 levels in the page tree.
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($selFields, 'pages', 'uid='.intval($uid).' AND pages.deleted=0 AND pages.doktype!=255');
                        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                $this->fixVersioningPid('pages',$row);
#??                             $this->versionOL('pages',$row);

                                        // Mount Point page types are allowed ONLY a) if they are the outermost record in rootline and b) if the overlay flag is not set:
                                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'] && $row['doktype']==7 && !$ignoreMPerrors)   {
                                        $mount_info = $this->getMountPointInfo($row['uid'], $row);
                                        if ($loopCheck>0 || $mount_info['overlay'])     {
                                                $this->error_getRootLine = 'Illegal Mount Point found in rootline';
                                                return array();
                                        }
                                }

                                $uid = $row['pid'];     // Next uid

                                if (count($MPA) && $GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'])      {
                                        $curMP = end($MPA);
                                        if (!strcmp($row['uid'],$curMP[0]))     {

                                                array_pop($MPA);
                                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($selFields, 'pages', 'uid='.intval($curMP[1]).' AND pages.deleted=0 AND pages.doktype!=255');
                                                $mp_row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);

                                                if (is_array($mp_row))  {
                                                        $this->fixVersioningPid('pages',$mp_row);
#??                                                     $this->versionOL('pages',$mp_row);
                                                        $mount_info = $this->getMountPointInfo($mp_row['uid'], $mp_row);
                                                        if (is_array($mount_info) && $mount_info['mount_pid']==$curMP[0])       {
                                                                $uid = $mp_row['pid'];  // Setting next uid

                                                                if ($mount_info['overlay'])     {       // Symlink style: Keep mount point (current row).
                                                                        $row['_MOUNT_OL'] = TRUE;       // Set overlay mode:
                                                                        $row['_MOUNT_PAGE'] = array(
                                                                                'uid' => $mp_row['uid'],
                                                                                'pid' => $mp_row['pid'],
                                                                                'title' =>  $mp_row['title'],
                                                                        );
                                                                } else {        // Normal operation: Insert the mount page row in rootline instead mount point.
                                                                        if ($loopCheck>0)       {
                                                                                $row = $mp_row;
                                                                        } else {
                                                                                $this->error_getRootLine = 'Current Page Id is a mounted page of the overlay type and cannot be accessed directly!';
                                                                                return array(); // Matching the page id (first run, $loopCheck = 0) with the MPvar is ONLY allowed if the mount point is the "overlay" type (otherwise it could be forged!)
                                                                        }
                                                                }

                                                                $row['_MOUNTED_FROM'] = $curMP[0];
                                                                $row['_MP_PARAM'] = $mount_info['MPvar'];
                                                        } else {
                                                                $this->error_getRootLine = 'MP var was corrupted';
                                                                return array(); // The MP variables did NOT connect proper mount points:
                                                        }
                                                } else {
                                                        $this->error_getRootLine = 'No moint point record found according to PID in MP var';
                                                        return array(); // The second PID in MP var was NOT a valid page.
                                                }
                                        }
                                }
                                        // Add row to rootline with language overlaid:
                                $theRowArray[] = $this->getPageOverlay($row);
                        } else {
                                $this->error_getRootLine = 'Broken rootline';
                                $this->error_getRootLine_failPid = $uid;
                                return array(); // broken rootline.
                        }

                        $loopCheck++;
                }

                        // If the MPA array is NOT empty, we have to return an error; All MP elements were not resolved!
                if (count($MPA))        {
                        $this->error_getRootLine = 'MP value remain!';
                        return array();
                }

                        // Create output array (with reversed order of numeric keys):
                $output = Array();
                $c = count($theRowArray);
                foreach($theRowArray as $key => $val)   {
                        $c--;
                        $output[$c] = $val;
                }

                return $output;
        }

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

        function getExtURL($pagerow,$disable=0) {
                if ($pagerow['doktype']==3 && !$disable)        {
                        $redirectTo = $this->urltypes[$pagerow['urltype']].$pagerow['url'];

                                // If relative path, prefix Site URL:
                        $uI = parse_url($redirectTo);
                        if (!$uI['scheme'] && substr($redirectTo,0,1)!='/')     { // relative path assumed now...
                                $redirectTo = t3lib_div::getIndpEnv('TYPO3_SITE_URL').$redirectTo;
                        }
                        return $redirectTo;
                }
        }

        function getMountPointInfo($pageId, $pageRec=FALSE, $prevMountPids=array(), $firstPageUid=0)    {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'])     {

                                // Get pageRec if not supplied:
                        if (!is_array($pageRec))        {
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol', 'pages', 'uid='.intval($pageId).' AND pages.deleted=0 AND pages.doktype!=255');
                                $pageRec = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
#??                             $this->versionOL('pages',$pageRec);
                        }

                                // Set first Page uid:
                        if (!$firstPageUid)     $firstPageUid = $pageRec['uid'];

                                // Look for mount pid value plus other required circumstances:
                        $mount_pid = intval($pageRec['mount_pid']);
                        if (is_array($pageRec) && $pageRec['doktype']==7 && $mount_pid>0 && !in_array($mount_pid, $prevMountPids))      {

                                        // Get the mount point record (to verify its general existence):
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol', 'pages', 'uid='.$mount_pid.' AND pages.deleted=0 AND pages.doktype!=255');
                                $mount_rec = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
                                if (is_array($mount_rec))       {
#??                                     $this->versionOL('pages',$mount_rec);

                                                // Look for recursive mount point:
                                        $prevMountPids[] = $mount_pid;
                                        $recursiveMountPid = $this->getMountPointInfo($mount_pid, $mount_rec, $prevMountPids, $firstPageUid);

                                                // Return mount point information:
                                        return $recursiveMountPid ?
                                                                $recursiveMountPid :
                                                                array(
                                                                        'mount_pid' => $mount_pid,
                                                                        'overlay' => $pageRec['mount_pid_ol'],
                                                                        'MPvar' => $mount_pid.'-'.$firstPageUid,
                                                                        'mount_point_rec' => $pageRec,
                                                                        'mount_pid_rec' => $mount_rec,
                                                                );
                                } else {
                                        return -1;      // Means, there SHOULD have been a mount point, but there was none!
                                }
                        }
                }

                return FALSE;
        }

















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

        function checkRecord($table,$uid,$checkPage=0)  {
                global $TCA;
                $uid=intval($uid);
                if (is_array($TCA[$table])) {
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.intval($uid).$this->enableFields($table));
                        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
#??                             $this->versionOL($table,$row);
                                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                if ($checkPage) {
                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'uid='.intval($row['pid']).$this->enableFields('pages'));
                                        if ($GLOBALS['TYPO3_DB']->sql_num_rows($res))   {
                                                return $row;
                                        } else {
                                                return 0;
                                        }
                                } else {
                                        return $row;
                                }
                        }
                }
        }

        function getRawRecord($table,$uid,$fields='*')  {
                global $TCA;
                $uid = intval($uid);
                if (is_array($TCA[$table]) || $table=='pages') {        // Excluding pages here so we can ask the function BEFORE TCA gets initialized. Support for this is followed up in deleteClause()...
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($fields, $table, 'uid='.intval($uid).$this->deleteClause($table));
                        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
#??                             $this->versionOL($table,$row);
                                return $row;
                        }
                }
        }

        function getRecordsByField($theTable,$theField,$theValue,$whereClause='',$groupBy='',$orderBy='',$limit='')     {
                global $TCA;
                if (is_array($TCA[$theTable])) {
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                '*',
                                                $theTable,
                                                $theField.'='.$GLOBALS['TYPO3_DB']->fullQuoteStr($theValue, $theTable).
                                                        $this->deleteClause($theTable).' '.
                                                                $whereClause,   // whereClauseMightContainGroupOrderBy
                                                $groupBy,
                                                $orderBy,
                                                $limit
                                        );
                        $rows = array();
                        while($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))       {
#??                             $this->versionOL($theTable,$row);
                                $rows[] = $row;
                        }
                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                        if (count($rows))       return $rows;
                }
        }














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

        function getHash($hash,$expTime=0)      {
                        //
                $expTime = intval($expTime);
                if ($expTime)   {
                        $whereAdd = ' AND tstamp > '.(time()-$expTime);
                }
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('content', 'cache_hash', 'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($hash, 'cache_hash').$whereAdd);
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                        return $row['content'];
                }
        }

        function storeHash($hash,$data,$ident)  {
                $insertFields = array(
                        'hash' => $hash,
                        'content' => $data,
                        'ident' => $ident,
                        'tstamp' => time()
                );
                $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_hash', 'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($hash, 'cache_hash'));
                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_hash', $insertFields);
        }

        function deleteClause($table)   {
                global $TCA;
                if (!strcmp($table,'pages'))    {       // Hardcode for pages...:
                        return ' AND pages.deleted=0';
                } else {
                        return $TCA[$table]['ctrl']['delete'] ? ' AND '.$table.'.'.$TCA[$table]['ctrl']['delete'].'=0' : '';
                }
        }

        function enableFields($table,$show_hidden=-1,$ignore_array=array())     {
                if ($show_hidden==-1 && is_object($GLOBALS['TSFE']))    {       // 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' ? $GLOBALS['TSFE']->showHiddenPage : $GLOBALS['TSFE']->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))    {
                        if ($ctrl['delete'])    {
                                $query.=' AND '.$table.'.'.$ctrl['delete'].'=0';
                        }
                        if (is_array($ctrl['enablecolumns']))   {
                                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_EXEC_TIME'].')';
                                }
                                if ($ctrl['enablecolumns']['endtime'] && !$ignore_array['endtime'])     {
                                        $field = $table.'.'.$ctrl['enablecolumns']['endtime'];
                                        $query.=' AND ('.$field.'=0 OR '.$field.'>'.$GLOBALS['SIM_EXEC_TIME'].')';
                                }
                                if ($ctrl['enablecolumns']['fe_group'] && !$ignore_array['fe_group'])   {
                                        $field = $table.'.'.$ctrl['enablecolumns']['fe_group'];
                                        $gr_list = $GLOBALS['TSFE']->gr_list;
                                        if (!strcmp($gr_list,''))       $gr_list=0;
                                        $query.=' AND '.$field.' IN ('.$gr_list.')';
                                }

                                        // 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($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($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_page.php']['addEnableColumns'] as $_funcRef)    {
                                                $query .= t3lib_div::callUserFunction($_funcRef,$_params,$this);
                                        }
                                }
                        }
                } else {
                        die ('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.');
                }

                return $query;
        }















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

        function fixVersioningPid($table,&$rr)  {
                global $TCA;
# SWAP uid as well???
                if ($this->versioningPreview && $rr['pid']==-1 && ($table=='pages' || $TCA[$table]['ctrl']['versioning']))      {       // Have to hardcode it for "pages" table since TCA is not loaded at this moment!
                        if ($rr['t3ver_oid']>0) {       // If "t3ver_oid" is already a field, just set this:
                                $oid = $rr['t3ver_oid'];
                        } 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');
                                if (is_array($newPidRec))       {
                                        $oid = $newPidRec['t3ver_oid'];
                                }
                        }

                                // If ID of current online version is found, look up the PID value of that:
                        if ($oid)       {
                                $oidRec = $this->getRawRecord($table,$oid,'pid');
                                if (is_array($oidRec))  {
                                        $rr['_ORIG_pid'] = $rr['pid'];
                                        $rr['pid'] = $oidRec['pid'];
                                }
                        }
                }
        }

        function versionOL($table,&$row)        {
                global $TCA;

                if ($this->versioningPreview && $TCA[$table]['ctrl']['versioning'])     {
#debug($row,$table);
#debug($this->versionPreviewMap);
                        if (is_array($row) && isset($this->versionPreviewMap[$table.':'.$row['uid']]))  {

                                        // ID to look for:
                                $lookFor = $this->versionPreviewMap[$table.':'.$row['uid']];

                                        // Select the alternative version:
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.intval($lookFor).$this->deleteClause($table));
                                if ($altrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                        if ($altrow['pid']==-1 && $altrow['t3ver_oid']==$row['uid'])    {
                                                unset($altrow['pid']);  // Unsetting PID since this is basically the same as what fixVersioningPid would do to the record...
                                                unset($altrow['uid']);  // Unsetting UID because the overlaid record should KEEP its own UID.
                                                # unset(...);   // more fields being unset???
                                                $row = t3lib_div::array_merge_recursive_overrule($row,$altrow,TRUE);
#debug($row,'Found:');
                                        }
                                }
                        }
                }
        }
}



if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_page.php'])      {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_page.php']);
}
?>

---