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_tcemain.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2006 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!
***************************************************************/
// *******************************
// Including necessary libraries
// *******************************
require_once (PATH_t3lib.'class.t3lib_loaddbgroup.php');
require_once (PATH_t3lib.'class.t3lib_parsehtml_proc.php');
require_once (PATH_t3lib.'class.t3lib_stdgraphic.php');
require_once (PATH_t3lib.'class.t3lib_basicfilefunc.php');
require_once (PATH_t3lib.'class.t3lib_refindex.php');
require_once (PATH_t3lib.'class.t3lib_flexformtools.php');











class t3lib_TCEmain     {


                // *********************
                // Public variables you can configure before using the class:
                // *********************

        var $storeLogMessages = TRUE;                   // Boolean: If true, the default log-messages will be stored. This should not be necessary if the locallang-file for the log-display is properly configured. So disabling this will just save some database-space as the default messages are not saved.
        var $enableLogging = TRUE;                              // Boolean: If true, actions are logged to sys_log.
        var $reverseOrder = FALSE;                              // Boolean: If true, the datamap array is reversed in the order, which is a nice thing if you're creating a whole new bunch of records.
        var $checkSimilar = TRUE;                               // Boolean: If true, only fields which are different from the database values are saved! In fact, if a whole input array is similar, it's not saved then.
        var $stripslashes_values = TRUE;                // Boolean: If true, incoming values in the data-array have their slashes stripped. ALWAYS SET THIS TO ZERO and supply an unescaped data array instead. This switch may totally disappear in future versions of this class!
        var $checkStoredRecords = TRUE;                 // Boolean: This will read the record after having updated or inserted it. If anything is not properly submitted an error is written to the log. This feature consumes extra time by selecting records
        var $checkStoredRecords_loose = TRUE;   // Boolean: If set, values '' and 0 will equal each other when the stored records are checked.
        var $deleteTree = FALSE;                                // Boolean. If this is set, then a page is deleted by deleting the whole branch under it (user must have deletepermissions to it all). If not set, then the page is deleted ONLY if it has no branch
        var $neverHideAtCopy = FALSE;                   // Boolean. If set, then the 'hideAtCopy' flag for tables will be ignored.
        var $dontProcessTransformations = FALSE;        // Boolean: If set, then transformations are NOT performed on the input.
        var $bypassWorkspaceRestrictions = FALSE;       // Boolean: If true, workspace restrictions are bypassed on edit an create actions (process_datamap()). YOU MUST KNOW what you do if you use this feature!

        var $copyWhichTables = '*';                             // String. Comma-list. This list of tables decides which tables will be copied. If empty then none will. If '*' then all will (that the user has permission to of course)
        var $generalComment = '';                               // General comment, eg. for staging in workspaces.

        var $copyTree = 0;                                              // Integer. If 0 then branch is NOT copied. If 1 then pages on the 1st level is copied. If 2 then pages on the second level is copied ... and so on

        var $defaultValues = array();                   // Array [table][fields]=value: New records are created with default values and you can set this array on the form $defaultValues[$table][$field] = $value to override the default values fetched from TCA. If ->setDefaultsFromUserTS is called UserTSconfig default values will overrule existing values in this array (thus UserTSconfig overrules externally set defaults which overrules TCA defaults)
        var $overrideValues = array();                  // Array [table][fields]=value: You can set this array on the form $overrideValues[$table][$field] = $value to override the incoming data. You must set this externally. You must make sure the fields in this array are also found in the table, because it's not checked. All columns can be set by this array!
        var $alternativeFileName = array();             // Array [filename]=alternative_filename: Use this array to force another name onto a file. Eg. if you set ['/tmp/blablabal'] = 'my_file.txt' and '/tmp/blablabal' is set for a certain file-field, then 'my_file.txt' will be used as the name instead.
        var $data_disableFields=array();                // If entries are set in this array corresponding to fields for update, they are ignored and thus NOT updated. You could set this array from a series of checkboxes with value=0 and hidden fields before the checkbox with 1. Then an empty checkbox will disable the field.
        var $suggestedInsertUids=array();               // Use this array to validate suggested uids for tables by setting [table]:[uid]. This is a dangerous option since it will force the inserted record to have a certain UID. The value just have to be true, but if you set it to "DELETE" it will make sure any record with that UID will be deleted first (raw delete). The option is used for import of T3D files when synchronizing between two mirrored servers. As a security measure this feature is available only for Admin Users (for now)

        var $callBackObj;                                               // Object. Call back object for flex form traversation. Useful when external classes wants to use the iteration functions inside tcemain for traversing a FlexForm structure.




                // *********************
                // Internal variables (mapping arrays) which can be used (read-only) from outside
                // *********************
        var $autoVersionIdMap = Array();                        // Contains mapping of auto-versionized records.
        var $substNEWwithIDs = Array();                         // When new elements are created, this array contains a map between their "NEW..." string IDs and the eventual UID they got when stored in database
        var $substNEWwithIDs_table = Array();           // Like $substNEWwithIDs, but where each old "NEW..." id is mapped to the table it was from.
        var $copyMappingArray_merged = Array();         // This array is the sum of all copying operations in this class. May be READ from outside, thus partly public.
        var $copiedFileMap = Array();                           // A map between input file name and final destination for files being attached to records.
        var     $errorLog = Array();                                    // Errors are collected in this variable.



                // *********************
                // Internal Variables, do not touch.
                // *********************

                // Variables set in init() function:
        var $BE_USER;           // The user-object the script uses. If not set from outside, this is set to the current global $BE_USER.
        var $userid;            // will be set to uid of be_user executing this script
        var $username;          // will be set to username of be_user executing this script
        var $admin;                     // will be set if user is admin

        var $defaultPermissions = array(                // Can be overridden from $TYPO3_CONF_VARS
                'user' => 'show,edit,delete,new,editcontent',
                'group' => 'show,edit,new,editcontent',
                'everybody' => ''
        );

        var $exclude_array;                     // The list of <table>-<fields> that cannot be edited by user. This is compiled from TCA/exclude-flag combined with non_exclude_fields for the user.
        var $datamap = Array();         // Set with incoming data array
        var $cmdmap = Array();          // Set with incoming cmd array

                // Internal static:
        var $pMap = Array(              // Permission mapping
                'show' => 1,                    // 1st bit
                'edit' => 2,                    // 2nd bit
                'delete' => 4,                  // 3rd bit
                'new' => 8,                             // 4th bit
                'editcontent' => 16             // 5th bit
        );
        var $sortIntervals = 256;                                       // Integer: The interval between sorting numbers used with tables with a 'sorting' field defined. Min 1

                // Internal caching arrays
        var $recUpdateAccessCache = Array();            // Used by function checkRecordUpdateAccess() to store whether a record is updateable or not.
        var $recInsertAccessCache = Array();            // User by function checkRecordInsertAccess() to store whether a record can be inserted on a page id
        var $isRecordInWebMount_Cache=array();          // Caching array for check of whether records are in a webmount
        var $isInWebMount_Cache=array();                        // Caching array for page ids in webmounts
        var $cachedTSconfig = array();                          // Caching for collecting TSconfig for page ids
        var $pageCache = Array();                                       // Used for caching page records in pageInfo()
        var $checkWorkspaceCache = Array();                     // Array caching workspace access for BE_USER

                // Other arrays:
        var $dbAnalysisStore=array();                           // For accumulation of MM relations that must be written after new records are created.
        var $removeFilesStore=array();                          // For accumulation of files which must be deleted after processing of all input content
        var $uploadedFileArray = array();                       // Uploaded files, set by process_uploads()
        var $registerDBList=array();                            // Used for tracking references that might need correction after operations
        var $copyMappingArray = Array();                        // Used by the copy action to track the ids of new pages so subpages are correctly inserted! THIS is internally cleared for each executed copy operation! DO NOT USE THIS FROM OUTSIDE! Read from copyMappingArray_merged instead which is accumulating this information.

                // Various
        var $fileFunc;                                                          // For "singleTon" file-manipulation object
        var $checkValue_currentRecord=array();          // Set to "currentRecord" during checking of values.
        var $autoVersioningUpdate = FALSE;                      // A signal flag used to tell file processing that autoversioning has happend and hence certain action should be applied.












        function start($data,$cmd,$altUserObject='')    {

                        // Initializing BE_USER
                $this->BE_USER = is_object($altUserObject) ? $altUserObject : $GLOBALS['BE_USER'];
                $this->userid = $this->BE_USER->user['uid'];
                $this->username = $this->BE_USER->user['username'];
                $this->admin = $this->BE_USER->user['admin'];

                if ($GLOBALS['BE_USER']->uc['recursiveDelete'])    {
                        $this->deleteTree = 1;
                }

                        // Initializing default permissions for pages
                $defaultPermissions = $GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPermissions'];
                if (isset($defaultPermissions['user']))         {$this->defaultPermissions['user'] = $defaultPermissions['user'];}
                if (isset($defaultPermissions['group']))                {$this->defaultPermissions['group'] = $defaultPermissions['group'];}
                if (isset($defaultPermissions['everybody']))            {$this->defaultPermissions['everybody'] = $defaultPermissions['everybody'];}

                        // generates the excludelist, based on TCA/exclude-flag and non_exclude_fields for the user:
                $this->exclude_array = $this->admin ? array() : $this->getExcludeListArray();

                        // Setting the data and cmd arrays
                if (is_array($data)) {
                        reset($data);
                        $this->datamap = $data;
                }
                if (is_array($cmd))     {
                        reset($cmd);
                        $this->cmdmap = $cmd;
                }
        }

        function setMirror($mirror)     {
                if (is_array($mirror))  {
                        reset($mirror);
                        while(list($table,$uid_array)=each($mirror))    {
                                if (isset($this->datamap[$table]))      {
                                        reset($uid_array);
                                        while (list($id,$uidList) = each($uid_array))   {
                                                if (isset($this->datamap[$table][$id])) {
                                                        $theIdsInArray = t3lib_div::trimExplode(',',$uidList,1);
                                                        while(list(,$copyToUid)=each($theIdsInArray))   {
                                                                $this->datamap[$table][$copyToUid] = $this->datamap[$table][$id];
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        function setDefaultsFromUserTS($userTS) {
                global $TCA;
                if (is_array($userTS))  {
                        foreach($userTS as $k => $v)    {
                                $k = substr($k,0,-1);
                                if ($k && is_array($v) && isset($TCA[$k]))      {
                                        if (is_array($this->defaultValues[$k])) {
                                                $this->defaultValues[$k] = array_merge($this->defaultValues[$k],$v);
                                        } else {
                                                $this->defaultValues[$k] = $v;
                                        }
                                }
                        }
                }
        }

        function process_uploads($postFiles)    {

                if (is_array($postFiles))       {

                                // Editing frozen:
                        if ($this->BE_USER->workspace!==0 && $this->BE_USER->workspaceRec['freeze'])    {
                                $this->newlog('All editing in this workspace has been frozen!',1);
                                return FALSE;
                        }

                        reset($postFiles);
                        $subA = current($postFiles);
                        if (is_array($subA))    {
                                if (is_array($subA['name']) && is_array($subA['type']) && is_array($subA['tmp_name']) && is_array($subA['size']))       {
                                                // Initialize the uploadedFilesArray:
                                        $this->uploadedFileArray=array();

                                                // For each entry:
                                        foreach($subA as $key => $values)       {
                                                $this->process_uploads_traverseArray($this->uploadedFileArray,$values,$key);
                                        }
                                } else {
                                        $this->uploadedFileArray=$subA;
                                }
                        }
                }
        }

        function process_uploads_traverseArray(&$outputArr,$inputArr,$keyToSet) {
                if (is_array($inputArr))        {
                        foreach($inputArr as $key => $value)    {
                                $this->process_uploads_traverseArray($outputArr[$key],$inputArr[$key],$keyToSet);
                        }
                } else {
                        $outputArr[$keyToSet]=$inputArr;
                }
        }















        /*********************************************
         *
         * PROCESSING DATA
         *
         *********************************************/

        function process_datamap() {
                global $TCA, $TYPO3_CONF_VARS;

                        // Editing frozen:
                if ($this->BE_USER->workspace!==0 && $this->BE_USER->workspaceRec['freeze'])    {
                        $this->newlog('All editing in this workspace has been frozen!',1);
                        return FALSE;
                }

                        // First prepare user defined objects (if any) for hooks which extend this function:
                $hookObjectsArr = array();
                if (is_array ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'])) {
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'] as $classRef) {
                                $hookObjectsArr[] = &t3lib_div::getUserObj($classRef);
                        }
                }

                        // Organize tables so that the pages-table is always processed first. This is required if you want to make sure that content pointing to a new page will be created.
                $orderOfTables = Array();
                if (isset($this->datamap['pages']))     {               // Set pages first.
                        $orderOfTables[]='pages';
                }
                reset($this->datamap);
                while (list($table,) = each($this->datamap))    {
                        if ($table!='pages')    {
                                $orderOfTables[]=$table;
                        }
                }

                        // Process the tables...
                foreach($orderOfTables as $table)       {
                                /* Check if
                                        - table is set in $TCA,
                                        - table is NOT readOnly
                                        - the table is set with content in the data-array (if not, there's nothing to process...)
                                        - permissions for tableaccess OK
                                */
                        $modifyAccessList = $this->checkModifyAccessList($table);
                        if (!$modifyAccessList) {
                                $id = 0;
                                $this->log($table,$id,2,0,1,"Attempt to modify table '%s' without permission",1,array($table));
                        }
                        if (isset($TCA[$table]) && !$this->tableReadOnly($table) && is_array($this->datamap[$table]) && $modifyAccessList)      {
                                if ($this->reverseOrder)        {
                                        $this->datamap[$table] = array_reverse($this->datamap[$table], 1);
                                }

                                        // For each record from the table, do:
                                        // $id is the record uid, may be a string if new records...
                                        // $incomingFieldArray is the array of fields
                                foreach($this->datamap[$table] as $id => $incomingFieldArray)   {
                                        if (is_array($incomingFieldArray))      {

                                                        // Hook: processDatamap_preProcessIncomingFieldArray
                                                foreach($hookObjectsArr as $hookObj)    {
                                                        if (method_exists($hookObj, 'processDatamap_preProcessFieldArray')) {
                                                                $hookObj->processDatamap_preProcessFieldArray($incomingFieldArray, $table, $id, $this);
                                                        }
                                                }

                                                        // ******************************
                                                        // Checking access to the record
                                                        // ******************************
                                                $createNewVersion = FALSE;
                                                $recordAccess = FALSE;
                                                $old_pid_value = '';
                                                $resetRejected = FALSE;
                                                $this->autoVersioningUpdate = FALSE;

                                                if (!t3lib_div::testInt($id)) {               // Is it a new record? (Then Id is a string)
                                                        $fieldArray = $this->newFieldArray($table);     // Get a fieldArray with default values
                                                        if (isset($incomingFieldArray['pid']))  {       // A pid must be set for new records.
                                                                        // $value = the pid
                                                                $pid_value = $incomingFieldArray['pid'];

                                                                        // Checking and finding numerical pid, it may be a string-reference to another value
                                                                $OK = 1;
                                                                if (strstr($pid_value,'NEW'))   {       // If a NEW... id
                                                                        if (substr($pid_value,0,1)=='-') {$negFlag=-1;$pid_value=substr($pid_value,1);} else {$negFlag=1;}
                                                                        if (isset($this->substNEWwithIDs[$pid_value]))  {       // Trying to find the correct numerical value as it should be mapped by earlier processing of another new record.
                                                                                $old_pid_value = $pid_value;
                                                                                $pid_value=intval($negFlag*$this->substNEWwithIDs[$pid_value]);
                                                                        } else {$OK = 0;}       // If not found in the substArray we must stop the process...
                                                                } elseif ($pid_value>=0 && $this->BE_USER->workspace!==0 && $TCA[$table]['ctrl']['versioning_followPages'])     {       // PID points to page, the workspace is an offline space and the table follows page during versioning: This means we must check if the PID page has a version in the workspace with swapmode set to 0 (zero = page+content) and if so, change the pid to the uid of that version.
                                                                        if ($WSdestPage = t3lib_BEfunc::getWorkspaceVersionOfRecord($this->BE_USER->workspace, 'pages', $pid_value, 'uid,t3ver_swapmode'))      {       // Looks for workspace version of page.
                                                                                if ($WSdestPage['t3ver_swapmode']==0)   {       // if swapmode is zero, then change pid value.
                                                                                        $pid_value = $WSdestPage['uid'];
                                                                                }
                                                                        }
                                                                }
                                                                $pid_value = intval($pid_value);

                                                                        // The $pid_value is now the numerical pid at this point
                                                                if ($OK)        {
                                                                        $sortRow = $TCA[$table]['ctrl']['sortby'];
                                                                        if ($pid_value>=0)      {       // Points to a page on which to insert the element, possibly in the top of the page
                                                                                if ($sortRow)   {       // If this table is sorted we better find the top sorting number
                                                                                        $fieldArray[$sortRow] = $this->getSortNumber($table,0,$pid_value);
                                                                                }
                                                                                $fieldArray['pid'] = $pid_value;        // The numerical pid is inserted in the data array
                                                                        } else {        // points to another record before ifself
                                                                                if ($sortRow)   {       // If this table is sorted we better find the top sorting number
                                                                                        $tempArray=$this->getSortNumber($table,0,$pid_value);   // Because $pid_value is < 0, getSortNumber returns an array
                                                                                        $fieldArray['pid'] = $tempArray['pid'];
                                                                                        $fieldArray[$sortRow] = $tempArray['sortNumber'];
                                                                                } else {        // Here we fetch the PID of the record that we point to...
                                                                                        $tempdata = $this->recordInfo($table,abs($pid_value),'pid');
                                                                                        $fieldArray['pid']=$tempdata['pid'];
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        $theRealPid = $fieldArray['pid'];

                                                                // Now, check if we may insert records on this pid.
                                                        if ($theRealPid>=0)     {
                                                                $recordAccess = $this->checkRecordInsertAccess($table,$theRealPid);             // Checks if records can be inserted on this $pid.
                                                                if ($recordAccess)      {
                                                                        $this->addDefaultPermittedLanguageIfNotSet($table,$incomingFieldArray);
                                                                        $recordAccess = $this->BE_USER->recordEditAccessInternals($table,$incomingFieldArray,TRUE);
                                                                        if (!$recordAccess)             {
                                                                                $this->newlog("recordEditAccessInternals() check failed. [".$this->BE_USER->errorMsg."]",1);
                                                                        } elseif(!$this->bypassWorkspaceRestrictions)   {
                                                                                        // Workspace related processing:
                                                                                if ($res = $this->BE_USER->workspaceAllowLiveRecordsInPID($theRealPid,$table))  {       // If LIVE records cannot be created in the current PID due to workspace restrictions, prepare creation of placeholder-record
                                                                                        if ($res<0)     {
                                                                                                $recordAccess = FALSE;
                                                                                                $this->newlog('Stage for versioning root point and users access level did not allow for editing',1);
                                                                                        }
                                                                                } else {        // So, if no live records were allowed, we have to create a new version of this record:
                                                                                        if ($TCA[$table]['ctrl']['versioningWS'])       {
                                                                                                $createNewVersion = TRUE;
                                                                                        } else {
                                                                                                $recordAccess = FALSE;
                                                                                                $this->newlog('Record could not be created in this workspace in this branch',1);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else {
                                                                debug('Internal ERROR: pid should not be less than zero!');
                                                        }
                                                        $status = 'new';                                                // Yes new record, change $record_status to 'insert'
                                                } else {        // Nope... $id is a number
                                                        $fieldArray = array();
                                                        $recordAccess = $this->checkRecordUpdateAccess($table,$id);
                                                        if (!$recordAccess)             {
                                                                $propArr = $this->getRecordProperties($table,$id);
                                                                $this->log($table,$id,2,0,1,"Attempt to modify record '%s' (%s) without permission. Or non-existing page.",2,array($propArr['header'],$table.':'.$id),$propArr['event_pid']);
                                                        } else {        // Next check of the record permissions (internals)
                                                                $recordAccess = $this->BE_USER->recordEditAccessInternals($table,$id);
                                                                if (!$recordAccess)             {
                                                                        $propArr = $this->getRecordProperties($table,$id);
                                                                        $this->newlog("recordEditAccessInternals() check failed. [".$this->BE_USER->errorMsg."]",1);
                                                                } else {        // Here we fetch the PID of the record that we point to...
                                                                        $tempdata = $this->recordInfo($table,$id,'pid'.($TCA[$table]['ctrl']['versioningWS']?',t3ver_wsid,t3ver_stage':''));
                                                                        $theRealPid = $tempdata['pid'];

                                                                                // Prepare the reset of the rejected flag if set:
                                                                        if ($TCA[$table]['ctrl']['versioningWS'] && $tempdata['t3ver_stage']<0) {
                                                                                $resetRejected = TRUE;
                                                                        }

                                                                                // Checking access in case of offline workspace:
                                                                        if (!$this->bypassWorkspaceRestrictions && $errorCode = $this->BE_USER->workspaceCannotEditRecord($table,$tempdata))    {
                                                                                $recordAccess = FALSE;          // Versioning is required and it must be offline version!

                                                                                        // Auto-creation of version: In offline workspace, test if versioning is enabled and look for workspace version of input record. If there is no versionized record found we will create one and save to that.
                                                                                if ($this->BE_USER->workspaceAllowAutoCreation($table,$id,$theRealPid)) {
                                                                                        $tce = t3lib_div::makeInstance('t3lib_TCEmain');
                                                                                        $tce->stripslashes_values = 0;

                                                                                                // Setting up command for creating a new version of the record:
                                                                                        $cmd = array();
                                                                                        $cmd[$table][$id]['version'] = array(
                                                                                                'action' => 'new',
                                                                                                'treeLevels' => -1,     // Default is to create a version of the individual records...
                                                                                                'label' => 'Auto-created for WS #'.$this->BE_USER->workspace
                                                                                        );
                                                                                        $tce->start(array(),$cmd);
                                                                                        $tce->process_cmdmap();
                                                                                        $this->errorLog = array_merge($this->errorLog,$tce->errorLog);

                                                                                        if ($tce->copyMappingArray[$table][$id])        {
                                                                                                $this->uploadedFileArray[$table][$tce->copyMappingArray[$table][$id]] = $this->uploadedFileArray[$table][$id];
                                                                                                $id = $this->autoVersionIdMap[$table][$id] = $tce->copyMappingArray[$table][$id];
                                                                                                $recordAccess = TRUE;
                                                                                                $this->autoVersioningUpdate = TRUE;
                                                                                        } else $this->newlog("Could not be edited in offline workspace in the branch where found (failure state: '".$errorCode."'). Auto-creation of version failed!",1);
                                                                                } else $this->newlog("Could not be edited in offline workspace in the branch where found (failure state: '".$errorCode."'). Auto-creation of version not allowed in workspace!",1);
                                                                        }
                                                                }
                                                        }
                                                        $status = 'update';     // the default is 'update'
                                                }

                                                        // If access was granted above, proceed to create or update record:
                                                if ($recordAccess)      {

                                                        list($tscPID) = t3lib_BEfunc::getTSCpid($table,$id,$old_pid_value ? $old_pid_value : $fieldArray['pid']);       // Here the "pid" is set IF NOT the old pid was a string pointing to a place in the subst-id array.
                                                        $TSConfig = $this->getTCEMAIN_TSconfig($tscPID);
                                                        if ($status=='new' && $table=='pages' && is_array($TSConfig['permissions.']))   {
                                                                $fieldArray = $this->setTSconfigPermissions($fieldArray,$TSConfig['permissions.']);
                                                        }
                                                        if ($createNewVersion)  {
                                                                $newVersion_placeholderFieldArray = $fieldArray;
                                                        }

                                                                // Processing of all fields in incomingFieldArray and setting them in $fieldArray
                                                        $fieldArray = $this->fillInFieldArray($table,$id,$fieldArray,$incomingFieldArray,$theRealPid,$status,$tscPID);

                                                                // NOTICE! All manipulation beyond this point bypasses both "excludeFields" AND possible "MM" relations / file uploads to field!

                                                                // Forcing some values unto field array:
                                                        $fieldArray = $this->overrideFieldArray($table,$fieldArray);    // NOTICE: This overriding is potentially dangerous; permissions per field is not checked!!!
                                                        if ($createNewVersion)  {
                                                                $newVersion_placeholderFieldArray = $this->overrideFieldArray($table,$newVersion_placeholderFieldArray);
                                                        }

                                                                // Setting system fields
                                                        if ($status=='new')     {
                                                                if ($TCA[$table]['ctrl']['crdate'])     {
                                                                        $fieldArray[$TCA[$table]['ctrl']['crdate']]=time();
                                                                        if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['crdate']]=time();
                                                                }
                                                                if ($TCA[$table]['ctrl']['cruser_id'])  {
                                                                        $fieldArray[$TCA[$table]['ctrl']['cruser_id']]=$this->userid;
                                                                        if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['cruser_id']]=$this->userid;
                                                                }
                                                        } elseif ($this->checkSimilar) {        // Removing fields which are equal to the current value:
                                                                $fieldArray = $this->compareFieldArrayWithCurrentAndUnset($table,$id,$fieldArray);
                                                        }
                                                        if ($TCA[$table]['ctrl']['tstamp'] && count($fieldArray))       {
                                                                $fieldArray[$TCA[$table]['ctrl']['tstamp']]=time();
                                                                if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['tstamp']]=time();
                                                        }
                                                        if ($resetRejected)     {
                                                                $fieldArray['t3ver_stage'] = 0;
                                                        }

                                                                // Hook: processDatamap_postProcessFieldArray
                                                        foreach($hookObjectsArr as $hookObj)    {
                                                                if (method_exists($hookObj, 'processDatamap_postProcessFieldArray')) {
                                                                        $hookObj->processDatamap_postProcessFieldArray($status, $table, $id, $fieldArray, $this);
                                                                }
                                                        }

                                                                // Performing insert/update. If fieldArray has been unset by some userfunction (see hook above), don't do anything
                                                                // Kasper: Unsetting the fieldArray is dangerous; MM relations might be saved already and files could have been uploaded that are now "lost"
                                                        if (is_array($fieldArray)) {
                                                                if ($status=='new')     {
                                                                        if ($createNewVersion)  {       // This creates a new version of the record with online placeholder and offline version
                                                                                $versioningType = $table==='pages' ? $this->BE_USER->workspaceVersioningTypeGetClosest(t3lib_div::intInRange($TYPO3_CONF_VARS['BE']['newPagesVersioningType'],-1,1)) : -1;
                                                                                if ($this->BE_USER->workspaceVersioningTypeAccess($versioningType))     {
                                                                                        $newVersion_placeholderFieldArray['t3ver_label'] = 'INITIAL PLACEHOLDER';
                                                                                        $newVersion_placeholderFieldArray['t3ver_state'] = 1;   // Setting placeholder state value for temporary record
                                                                                        $newVersion_placeholderFieldArray['t3ver_wsid'] = $this->BE_USER->workspace;    // Setting workspace - only so display of place holders can filter out those from other workspaces.
                                                                                        $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['label']] = '[PLACEHOLDER, WS#'.$this->BE_USER->workspace.']';
                                                                                        $this->insertDB($table,$id,$newVersion_placeholderFieldArray,FALSE);    // Saving placeholder as 'original'

                                                                                                // For the actual new offline version, set versioning values to point to placeholder:
                                                                                        $fieldArray['pid'] = -1;
                                                                                        $fieldArray['t3ver_oid'] = $this->substNEWwithIDs[$id];
                                                                                        $fieldArray['t3ver_id'] = 1;
                                                                                        $fieldArray['t3ver_state'] = -1;        // Setting placeholder state value for version (so it can know it is currently a new version...)
                                                                                        $fieldArray['t3ver_label'] = 'First draft version';
                                                                                        $fieldArray['t3ver_wsid'] = $this->BE_USER->workspace;
                                                                                        if ($table==='pages') {         // Swap mode set to "branch" so we can build branches for pages.
                                                                                                $fieldArray['t3ver_swapmode'] = $versioningType;
                                                                                        }
                                                                                        $phShadowId = $this->insertDB($table,$id,$fieldArray,TRUE,0,TRUE);      // When inserted, $this->substNEWwithIDs[$id] will be changed to the uid of THIS version and so the interface will pick it up just nice!
                                                                                        if ($phShadowId)        {
                                                                                                $this->placeholderShadowing($table,$phShadowId);
                                                                                        }
                                                                                } else $this->newlog('Versioning type "'.$versioningType.'" was not allowed, so could not create new record.',1);
                                                                        } else {
                                                                                $this->insertDB($table,$id,$fieldArray,FALSE,$incomingFieldArray['uid']);
                                                                        }
                                                                } else {
                                                                        $this->updateDB($table,$id,$fieldArray);
                                                                        $this->placeholderShadowing($table,$id);
                                                                }
                                                        }

                                                                // Hook: processDatamap_afterDatabaseOperations
                                                        foreach($hookObjectsArr as $hookObj)    {
                                                                if (method_exists($hookObj, 'processDatamap_afterDatabaseOperations')) {
                                                                        $hookObj->processDatamap_afterDatabaseOperations($status, $table, $id, $fieldArray, $this);
                                                                }
                                                        }
                                                }       // if ($recordAccess)   {
                                        }       // if (is_array($incomingFieldArray))   {
                                }
                        }
                }
                $this->dbAnalysisStoreExec();
                $this->removeRegisteredFiles();
        }

        function placeholderShadowing($table,$id)       {
                global $TCA;

                if ($liveRec = t3lib_BEfunc::getLiveVersionOfRecord($table,$id,'*'))    {
                        if ((int)$liveRec['t3ver_state']===1)   {
                                $justStoredRecord = t3lib_BEfunc::getRecord($table,$id);
                                $newRecord = array();

                                $shadowColumns = t3lib_div::trimExplode(',', $TCA[$table]['ctrl']['shadowColumnsForNewPlaceholders'],1);
                                foreach($shadowColumns as $fieldName)   {
                                        if (strcmp($justStoredRecord[$fieldName],$liveRec[$fieldName])) {
                                                $newRecord[$fieldName] = $justStoredRecord[$fieldName];
                                        }
                                }

                                if (count($newRecord))  {
                                        $this->newlog('Shadowing done on fields '.implode(',',array_keys($newRecord)).' in Placeholder record '.$table.':'.$liveRec['uid'].' (offline version UID='.$id.')');
                                        $this->updateDB($table,$liveRec['uid'],$newRecord);
                                }
                        }
                }
        }

        function fillInFieldArray($table,$id,$fieldArray,$incomingFieldArray,$realPid,$status,$tscPID)  {
                global $TCA;

                        // Initialize:
                t3lib_div::loadTCA($table);
                $originalLanguageRecord = NULL;
                $originalLanguage_diffStorage = NULL;
                $diffStorageFlag = FALSE;

                        // Setting 'currentRecord' and 'checkValueRecord':
                if (strstr($id,'NEW'))  {
                        $currentRecord = $checkValueRecord = $fieldArray;       // must have the 'current' array - not the values after processing below...

                                // IF $incomingFieldArray is an array, overlay it.
                                // The point is that when new records are created as copies with flex type fields there might be a field containing information about which DataStructure to use and without that information the flexforms cannot be correctly processed.... This should be OK since the $checkValueRecord is used by the flexform evaluation only anyways...
                        if (is_array($incomingFieldArray) && is_array($checkValueRecord))       {
                                $checkValueRecord = t3lib_div::array_merge_recursive_overrule($checkValueRecord, $incomingFieldArray);
                        }
                } else {
                        $currentRecord = $checkValueRecord = $this->recordInfo($table,$id,'*'); // We must use the current values as basis for this!

                                // Get original language record if available:
                        if (is_array($currentRecord)
                                        && $TCA[$table]['ctrl']['transOrigDiffSourceField']
                                        && $TCA[$table]['ctrl']['languageField']
                                        && $currentRecord[$TCA[$table]['ctrl']['languageField']] > 0
                                        && $TCA[$table]['ctrl']['transOrigPointerField']
                                        && intval($currentRecord[$TCA[$table]['ctrl']['transOrigPointerField']]) > 0)   {

                                $lookUpTable = $TCA[$table]['ctrl']['transOrigPointerTable'] ? $TCA[$table]['ctrl']['transOrigPointerTable'] : $table;
                                $originalLanguageRecord = $this->recordInfo($lookUpTable,$currentRecord[$TCA[$table]['ctrl']['transOrigPointerField']],'*');
                                t3lib_BEfunc::workspaceOL($lookUpTable,$originalLanguageRecord);
                                $originalLanguage_diffStorage = unserialize($currentRecord[$TCA[$table]['ctrl']['transOrigDiffSourceField']]);
                        }
                }
                $this->checkValue_currentRecord = $checkValueRecord;

                        /*
                                In the following all incoming value-fields are tested:
                                - Are the user allowed to change the field?
                                - Is the field uid/pid (which are already set)
                                - perms-fields for pages-table, then do special things...
                                - If the field is nothing of the above and the field is configured in TCA, the fieldvalues are evaluated by ->checkValue

                                If everything is OK, the field is entered into $fieldArray[]
                        */
                foreach($incomingFieldArray as $field => $fieldValue)   {
                        if (!in_array($table.'-'.$field, $this->exclude_array) && !$this->data_disableFields[$table][$id][$field])      {       // The field must be editable.

                                        // Checking if a value for language can be changed:
                                $languageDeny = $TCA[$table]['ctrl']['languageField'] && !strcmp($TCA[$table]['ctrl']['languageField'], $field) && !$this->BE_USER->checkLanguageAccess($fieldValue);

                                if (!$languageDeny)     {
                                                // Stripping slashes - will probably be removed the day $this->stripslashes_values is removed as an option...
                                        if ($this->stripslashes_values) {
                                                if (is_array($fieldValue))      {
                                                        t3lib_div::stripSlashesOnArray($fieldValue);
                                                } else $fieldValue = stripslashes($fieldValue);
                                        }

                                        switch ($field) {
                                                case 'uid':
                                                case 'pid':
                                                        // Nothing happens, already set
                                                break;
                                                case 'perms_userid':
                                                case 'perms_groupid':
                                                case 'perms_user':
                                                case 'perms_group':
                                                case 'perms_everybody':
                                                                // Permissions can be edited by the owner or the administrator
                                                        if ($table=='pages' && ($this->admin || $status=='new' || $this->pageInfo($id,'perms_userid')==$this->userid) ) {
                                                                $value=intval($fieldValue);
                                                                switch($field)  {
                                                                        case 'perms_userid':
                                                                                $fieldArray[$field]=$value;
                                                                        break;
                                                                        case 'perms_groupid':
                                                                                $fieldArray[$field]=$value;
                                                                        break;
                                                                        default:
                                                                                if ($value>=0 && $value<pow(2,5))       {
                                                                                        $fieldArray[$field]=$value;
                                                                                }
                                                                        break;
                                                                }
                                                        }
                                                break;
                                                case 't3ver_oid':
                                                case 't3ver_id':
                                                case 't3ver_wsid':
                                                case 't3ver_state':
                                                case 't3ver_swapmode':
                                                case 't3ver_count':
                                                case 't3ver_stage':
                                                case 't3ver_tstamp':
                                                        // t3ver_label is not here because it CAN be edited as a regular field!
                                                break;
                                                default:
                                                        if (isset($TCA[$table]['columns'][$field]))     {
                                                                        // Evaluating the value.
                                                                $res = $this->checkValue($table,$field,$fieldValue,$id,$status,$realPid,$tscPID);
                                                                if (isset($res['value']))       {
                                                                        $fieldArray[$field]=$res['value'];

                                                                                // Add the value of the original record to the diff-storage content:
                                                                        if ($TCA[$table]['ctrl']['transOrigDiffSourceField'])   {
                                                                                $originalLanguage_diffStorage[$field] = $originalLanguageRecord[$field];
                                                                                $diffStorageFlag = TRUE;
                                                                        }
                                                                }
                                                        } elseif ($TCA[$table]['ctrl']['origUid']===$field) {   // Allow value for original UID to pass by...
                                                                $fieldArray[$field] = $fieldValue;
                                                        }
                                                break;
                                        }
                                }       // Checking language.
                        }       // Check exclude fields / disabled fields...
                }

                        // Add diff-storage information:
                if ($diffStorageFlag && !isset($fieldArray[$TCA[$table]['ctrl']['transOrigDiffSourceField']]))  {       // If the field is set it would probably be because of an undo-operation - in which case we should not update the field of course...
                         $fieldArray[$TCA[$table]['ctrl']['transOrigDiffSourceField']] = serialize($originalLanguage_diffStorage);
                }

                        // Checking for RTE-transformations of fields:
                $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table,$currentRecord);
                $theTypeString = t3lib_BEfunc::getTCAtypeValue($table,$currentRecord);
                if (is_array($types_fieldConfig))       {
                        reset($types_fieldConfig);
                        while(list(,$vconf) = each($types_fieldConfig)) {
                                        // Write file configuration:
                                $eFile = t3lib_parsehtml_proc::evalWriteFile($vconf['spec']['static_write'],array_merge($currentRecord,$fieldArray));   // inserted array_merge($currentRecord,$fieldArray) 170502

                                        // RTE transformations:
                                if (!$this->dontProcessTransformations) {
                                        if (isset($fieldArray[$vconf['field']]))        {
                                                        // Look for transformation flag:
                                                switch((string)$incomingFieldArray['_TRANSFORM_'.$vconf['field']])      {
                                                        case 'RTE':
                                                                $RTEsetup = $this->BE_USER->getTSConfig('RTE',t3lib_BEfunc::getPagesTSconfig($tscPID));
                                                                $thisConfig = t3lib_BEfunc::RTEsetup($RTEsetup['properties'],$table,$vconf['field'],$theTypeString);

                                                                        // Set alternative relative path for RTE images/links:
                                                                $RTErelPath = is_array($eFile) ? dirname($eFile['relEditFile']) : '';

                                                                        // Get RTE object, draw form and set flag:
                                                                $RTEobj = &t3lib_BEfunc::RTEgetObj();
                                                                if (is_object($RTEobj)) {
                                                                        $fieldArray[$vconf['field']] = $RTEobj->transformContent('db',$fieldArray[$vconf['field']],$table,$vconf['field'],$currentRecord,$vconf['spec'],$thisConfig,$RTErelPath,$currentRecord['pid']);
                                                                } else {
                                                                        debug('NO RTE OBJECT FOUND!');
                                                                }
                                                        break;
                                                }
                                        }
                                }

                                        // Write file configuration:
                                if (is_array($eFile))   {
                                        $mixedRec = array_merge($currentRecord,$fieldArray);
                                        $SW_fileContent = t3lib_div::getUrl($eFile['editFile']);
                                        $parseHTML = t3lib_div::makeInstance('t3lib_parsehtml_proc');
                                        $parseHTML->init('','');

                                        $eFileMarker = $eFile['markerField']&&trim($mixedRec[$eFile['markerField']]) ? trim($mixedRec[$eFile['markerField']]) : '###TYPO3_STATICFILE_EDIT###';
                                        $insertContent = str_replace($eFileMarker,'',$mixedRec[$eFile['contentField']]);        // must replace the marker if present in content!

                                        $SW_fileNewContent = $parseHTML->substituteSubpart($SW_fileContent, $eFileMarker, chr(10).$insertContent.chr(10), 1, 1);
                                        t3lib_div::writeFile($eFile['editFile'],$SW_fileNewContent);

                                                // Write status:
                                        if (!strstr($id,'NEW') && $eFile['statusField'])        {
                                                $GLOBALS['TYPO3_DB']->exec_UPDATEquery(
                                                        $table,
                                                        'uid='.intval($id),
                                                        array(
                                                                $eFile['statusField'] => $eFile['relEditFile'].' updated '.date('d-m-Y H:i:s').', bytes '.strlen($mixedRec[$eFile['contentField']])
                                                        )
                                                );
                                        }
                                } elseif ($eFile && is_string($eFile))  {
                                        $this->log($table,$id,2,0,1,"Write-file error: '%s'",13,array($eFile),$realPid);
                                }
                        }
                }
                        // Return fieldArray
                return $fieldArray;
        }












        /*********************************************
         *
         * Evaluation of input values
         *
         ********************************************/

        function checkValue($table,$field,$value,$id,$status,$realPid,$tscPID)  {
                global $TCA, $PAGES_TYPES;
                t3lib_div::loadTCA($table);

                $res = Array(); // result array
                $recFID = $table.':'.$id.':'.$field;

                        // Processing special case of field pages.doktype
                if ($table=='pages' && $field=='doktype')       {
                                // If the user may not use this specific doktype, we issue a warning
                        if (! ($this->admin || t3lib_div::inList($this->BE_USER->groupData['pagetypes_select'],$value)))        {
                                $propArr = $this->getRecordProperties($table,$id);
                                $this->log($table,$id,5,0,1,"You cannot change the 'doktype' of page '%s' to the desired value.",1,array($propArr['header']),$propArr['event_pid']);
                                return $res;
                        };
                        if ($status=='update')  {
                                        // This checks 1) if we should check for disallowed tables and 2) if there are records from disallowed tables on the current page
                                $onlyAllowedTables = isset($PAGES_TYPES[$value]['onlyAllowedTables']) ? $PAGES_TYPES[$value]['onlyAllowedTables'] : $PAGES_TYPES['default']['onlyAllowedTables'];
                                if ($onlyAllowedTables) {
                                        $theWrongTables = $this->doesPageHaveUnallowedTables($id,$value);
                                        if ($theWrongTables)    {
                                                $propArr = $this->getRecordProperties($table,$id);
                                                $this->log($table,$id,5,0,1,"'doktype' of page '%s' could not be changed because the page contains records from disallowed tables; %s",2,array($propArr['header'],$theWrongTables),$propArr['event_pid']);
                                                return $res;
                                        }
                                }
                        }
                }

                        // Get current value:
                $curValueRec = $this->recordInfo($table,$id,$field);
                $curValue = $curValueRec[$field];

                        // Getting config for the field
                $tcaFieldConf = $TCA[$table]['columns'][$field]['config'];

                        // Preform processing:
                $res = $this->checkValue_SW($res,$value,$tcaFieldConf,$table,$id,$curValue,$status,$realPid,$recFID,$field,$this->uploadedFileArray[$table][$id][$field],$tscPID);

                return $res;
        }

        function checkValue_SW($res,$value,$tcaFieldConf,$table,$id,$curValue,$status,$realPid,$recFID,$field,$uploadedFiles,$tscPID)   {

                $PP = array($table,$id,$curValue,$status,$realPid,$recFID,$tscPID);

                switch ($tcaFieldConf['type']) {
                        case 'text':
                        case 'passthrough':
                        case 'user':
                                $res['value'] = $value;
                        break;
                        case 'input':
                                $res = $this->checkValue_input($res,$value,$tcaFieldConf,$PP,$field);
                        break;
                        case 'check':
                                $res = $this->checkValue_check($res,$value,$tcaFieldConf,$PP);
                        break;
                        case 'radio':
                                $res = $this->checkValue_radio($res,$value,$tcaFieldConf,$PP);
                        break;
                        case 'group':
                        case 'select':
                                $res = $this->checkValue_group_select($res,$value,$tcaFieldConf,$PP,$uploadedFiles,$field);
                        break;
                        case 'flex':
                                if ($field)     {       // FlexForms are only allowed for real fields.
                                        $res = $this->checkValue_flex($res,$value,$tcaFieldConf,$PP,$uploadedFiles,$field);
                                }
                        break;
                        default:
                                #debug(array($tcaFieldConf,$res,$value),'NON existing field type:');
                        break;
                }

                return $res;
        }

        function checkValue_input($res,$value,$tcaFieldConf,$PP,$field='')      {
                list($table,$id,$curValue,$status,$realPid,$recFID) = $PP;

                        // Secures the string-length to be less than max. Will probably make problems with multi-byte strings!
                if (intval($tcaFieldConf['max'])>0)     {$value = substr($value,0,intval($tcaFieldConf['max']));}

                        // Checking range of value:
                if ($tcaFieldConf['range'] && $value!=$tcaFieldConf['checkbox'])        {       // If value is not set to the allowed checkbox-value then it is checked against the ranges
                        if (isset($tcaFieldConf['r