TYPO3: tslib_cObj Class Reference

00001 <?php
00002 /***************************************************************
00003 *  Copyright notice
00004 *
00005 *  (c) 1999-2007 Kasper Skaarhoj (kasperYYYY@typo3.com)
00006 *  All rights reserved
00007 *
00008 *  This script is part of the TYPO3 project. The TYPO3 project is
00009 *  free software; you can redistribute it and/or modify
00010 *  it under the terms of the GNU General Public License as published by
00011 *  the Free Software Foundation; either version 2 of the License, or
00012 *  (at your option) any later version.
00013 *
00014 *  The GNU General Public License can be found at
00015 *  http://www.gnu.org/copyleft/gpl.html.
00016 *  A copy is found in the textfile GPL.txt and important notices to the license
00017 *  from the author is found in LICENSE.txt distributed with these scripts.
00018 *
00019 *
00020 *  This script is distributed in the hope that it will be useful,
00021 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00022 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023 *  GNU General Public License for more details.
00024 *
00025 *  This copyright notice MUST APPEAR in all copies of the script!
00026 ***************************************************************/
00208 // *******************************
00209 // Including necessary libraries
00210 // *******************************
00211 require_once (PATH_t3lib.'class.t3lib_loaddbgroup.php');
00212 require_once (PATH_t3lib.'class.t3lib_parsehtml_proc.php');
00213 require_once (PATH_t3lib.'class.t3lib_stdgraphic.php');
00214 require_once (PATH_t3lib.'class.t3lib_basicfilefunc.php');
00215 require_once (PATH_t3lib.'class.t3lib_refindex.php');
00216 require_once (PATH_t3lib.'class.t3lib_flexformtools.php');
00217 
00218 
00219 
00220 
00221 
00222 
00223 
00224 
00225 
00226 
00227 
00242 class t3lib_TCEmain     {
00243 
00244 
00245                 // *********************
00246                 // Public variables you can configure before using the class:
00247                 // *********************
00248 
00249         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.
00250         var $enableLogging = TRUE;                              // Boolean: If true, actions are logged to sys_log.
00251         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.
00252         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.
00253         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!
00254         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
00255         var $checkStoredRecords_loose = TRUE;   // Boolean: If set, values '' and 0 will equal each other when the stored records are checked.
00256         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
00257         var $neverHideAtCopy = FALSE;                   // Boolean. If set, then the 'hideAtCopy' flag for tables will be ignored.
00258         var $dontProcessTransformations = FALSE;        // Boolean: If set, then transformations are NOT performed on the input.
00259         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!
00260         var $bypassFileHandling = FALSE;                        // Boolean: If true, file handling of attached files (addition, deletion etc) is bypassed - the value is saved straight away. YOU MUST KNOW what you are doing with this feature!
00261         var $bypassAccessCheckForRecords = FALSE;       // Boolean: If true, access check, check for deleted etc. for records is bypassed. YOU MUST KNOW what you are doing if you use this feature!
00262 
00263         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)
00264         var $generalComment = '';                               // General comment, eg. for staging in workspaces.
00265 
00266         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
00267 
00268         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)
00269         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!
00270         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.
00271         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.
00272         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)
00273 
00274         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.
00275 
00276 
00277 
00278 
00279                 // *********************
00280                 // Internal variables (mapping arrays) which can be used (read-only) from outside
00281                 // *********************
00282         var $autoVersionIdMap = Array();                        // Contains mapping of auto-versionized records.
00283         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
00284         var $substNEWwithIDs_table = Array();           // Like $substNEWwithIDs, but where each old "NEW..." id is mapped to the table it was from.
00285         var $newRelatedIDs = Array();                           // Holds the tables and there the ids of newly created child records from IRRE
00286         var $copyMappingArray_merged = Array();         // This array is the sum of all copying operations in this class. May be READ from outside, thus partly public.
00287         var $copiedFileMap = Array();                           // A map between input file name and final destination for files being attached to records.
00288         var     $errorLog = Array();                                    // Errors are collected in this variable.
00289 
00290 
00291 
00292                 // *********************
00293                 // Internal Variables, do not touch.
00294                 // *********************
00295 
00296                 // Variables set in init() function:
00297         var $BE_USER;           // The user-object the script uses. If not set from outside, this is set to the current global $BE_USER.
00298         var $userid;            // will be set to uid of be_user executing this script
00299         var $username;          // will be set to username of be_user executing this script
00300         var $admin;                     // will be set if user is admin
00301 
00302         var $defaultPermissions = array(                // Can be overridden from $TYPO3_CONF_VARS
00303                 'user' => 'show,edit,delete,new,editcontent',
00304                 'group' => 'show,edit,new,editcontent',
00305                 'everybody' => ''
00306         );
00307 
00308         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.
00309         var $datamap = Array();         // Set with incoming data array
00310         var $cmdmap = Array();          // Set with incoming cmd array
00311 
00312                 // Internal static:
00313         var $pMap = Array(              // Permission mapping
00314                 'show' => 1,                    // 1st bit
00315                 'edit' => 2,                    // 2nd bit
00316                 'delete' => 4,                  // 3rd bit
00317                 'new' => 8,                             // 4th bit
00318                 'editcontent' => 16             // 5th bit
00319         );
00320         var $sortIntervals = 256;                                       // Integer: The interval between sorting numbers used with tables with a 'sorting' field defined. Min 1
00321 
00322                 // Internal caching arrays
00323         var $recUpdateAccessCache = Array();            // Used by function checkRecordUpdateAccess() to store whether a record is updateable or not.
00324         var $recInsertAccessCache = Array();            // User by function checkRecordInsertAccess() to store whether a record can be inserted on a page id
00325         var $isRecordInWebMount_Cache=array();          // Caching array for check of whether records are in a webmount
00326         var $isInWebMount_Cache=array();                        // Caching array for page ids in webmounts
00327         var $cachedTSconfig = array();                          // Caching for collecting TSconfig for page ids
00328         var $pageCache = Array();                                       // Used for caching page records in pageInfo()
00329         var $checkWorkspaceCache = Array();                     // Array caching workspace access for BE_USER
00330 
00331                 // Other arrays:
00332         var $dbAnalysisStore=array();                           // For accumulation of MM relations that must be written after new records are created.
00333         var $removeFilesStore=array();                          // For accumulation of files which must be deleted after processing of all input content
00334         var $uploadedFileArray = array();                       // Uploaded files, set by process_uploads()
00335         var $registerDBList=array();                            // Used for tracking references that might need correction after operations
00336         var $registerDBPids=array();                            // Used for tracking references that might need correction in pid field after operations (e.g. IRRE)
00337         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.
00338         var $remapStack = array();                                      // array used for remapping uids and values at the end of process_datamap
00339         var $remapStackRecords = array();                       // array used for remapping uids and values at the end of process_datamap (e.g. $remapStackRecords[<table>][<uid>] = <index in $remapStack>)
00340         var $updateRefIndexStack = array();                     // array used for additional calls to $this->updateRefIndex
00341         var $callFromImpExp = false;                            // tells, that this TCEmain was called from tx_impext - this variable is set by tx_impexp
00342 
00343                 // Various
00344         var $fileFunc;                                                          // For "singleTon" file-manipulation object
00345         var $checkValue_currentRecord=array();          // Set to "currentRecord" during checking of values.
00346         var $autoVersioningUpdate = FALSE;                      // A signal flag used to tell file processing that autoversioning has happend and hence certain action should be applied.
00347 
00348 
00349 
00350 
00351 
00352 
00353 
00354 
00355 
00356 
00357 
00358 
00369         function start($data,$cmd,$altUserObject='')    {
00370 
00371                         // Initializing BE_USER
00372                 $this->BE_USER = is_object($altUserObject) ? $altUserObject : $GLOBALS['BE_USER'];
00373                 $this->userid = $this->BE_USER->user['uid'];
00374                 $this->username = $this->BE_USER->user['username'];
00375                 $this->admin = $this->BE_USER->user['admin'];
00376 
00377                 if ($GLOBALS['BE_USER']->uc['recursiveDelete'])    {
00378                         $this->deleteTree = 1;
00379                 }
00380 
00381                         // Initializing default permissions for pages
00382                 $defaultPermissions = $GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPermissions'];
00383                 if (isset($defaultPermissions['user']))         {$this->defaultPermissions['user'] = $defaultPermissions['user'];}
00384                 if (isset($defaultPermissions['group']))                {$this->defaultPermissions['group'] = $defaultPermissions['group'];}
00385                 if (isset($defaultPermissions['everybody']))            {$this->defaultPermissions['everybody'] = $defaultPermissions['everybody'];}
00386 
00387                         // generates the excludelist, based on TCA/exclude-flag and non_exclude_fields for the user:
00388                 $this->exclude_array = $this->admin ? array() : $this->getExcludeListArray();
00389 
00390                         // Setting the data and cmd arrays
00391                 if (is_array($data)) {
00392                         reset($data);
00393                         $this->datamap = $data;
00394                 }
00395                 if (is_array($cmd))     {
00396                         reset($cmd);
00397                         $this->cmdmap = $cmd;
00398                 }
00399         }
00400 
00408         function setMirror($mirror)     {
00409                 if (is_array($mirror))  {
00410                         reset($mirror);
00411                         while(list($table,$uid_array)=each($mirror))    {
00412                                 if (isset($this->datamap[$table]))      {
00413                                         reset($uid_array);
00414                                         while (list($id,$uidList) = each($uid_array))   {
00415                                                 if (isset($this->datamap[$table][$id])) {
00416                                                         $theIdsInArray = t3lib_div::trimExplode(',',$uidList,1);
00417                                                         while(list(,$copyToUid)=each($theIdsInArray))   {
00418                                                                 $this->datamap[$table][$copyToUid] = $this->datamap[$table][$id];
00419                                                         }
00420                                                 }
00421                                         }
00422                                 }
00423                         }
00424                 }
00425         }
00426 
00433         function setDefaultsFromUserTS($userTS) {
00434                 global $TCA;
00435                 if (is_array($userTS))  {
00436                         foreach($userTS as $k => $v)    {
00437                                 $k = substr($k,0,-1);
00438                                 if ($k && is_array($v) && isset($TCA[$k]))      {
00439                                         if (is_array($this->defaultValues[$k])) {
00440                                                 $this->defaultValues[$k] = array_merge($this->defaultValues[$k],$v);
00441                                         } else {
00442                                                 $this->defaultValues[$k] = $v;
00443                                         }
00444                                 }
00445                         }
00446                 }
00447         }
00448 
00456         function process_uploads($postFiles)    {
00457 
00458                 if (is_array($postFiles))       {
00459 
00460                                 // Editing frozen:
00461                         if ($this->BE_USER->workspace!==0 && $this->BE_USER->workspaceRec['freeze'])    {
00462                                 $this->newlog('All editing in this workspace has been frozen!',1);
00463                                 return FALSE;
00464                         }
00465 
00466                         reset($postFiles);
00467                         $subA = current($postFiles);
00468                         if (is_array($subA))    {
00469                                 if (is_array($subA['name']) && is_array($subA['type']) && is_array($subA['tmp_name']) && is_array($subA['size']))       {
00470                                                 // Initialize the uploadedFilesArray:
00471                                         $this->uploadedFileArray=array();
00472 
00473                                                 // For each entry:
00474                                         foreach($subA as $key => $values)       {
00475                                                 $this->process_uploads_traverseArray($this->uploadedFileArray,$values,$key);
00476                                         }
00477                                 } else {
00478                                         $this->uploadedFileArray=$subA;
00479                                 }
00480                         }
00481                 }
00482         }
00483 
00494         function process_uploads_traverseArray(&$outputArr,$inputArr,$keyToSet) {
00495                 if (is_array($inputArr))        {
00496                         foreach($inputArr as $key => $value)    {
00497                                 $this->process_uploads_traverseArray($outputArr[$key],$inputArr[$key],$keyToSet);
00498                         }
00499                 } else {
00500                         $outputArr[$keyToSet]=$inputArr;
00501                 }
00502         }
00503 
00504 
00505 
00506 
00507 
00508 
00509 
00510 
00511 
00512 
00513 
00514 
00515 
00516 
00517 
00518         /*********************************************
00519          *
00520          * HOOKS
00521          *
00522          *********************************************/
00523 
00538         function hook_processDatamap_afterDatabaseOperations(&$hookObjectsArr, &$status, &$table, &$id, &$fieldArray) {
00539                         // Process hook directly:
00540                 if (!isset($this->remapStackRecords[$table][$id])) {
00541                         foreach($hookObjectsArr as $hookObj)    {
00542                                 if (method_exists($hookObj, 'processDatamap_afterDatabaseOperations')) {
00543                                         $hookObj->processDatamap_afterDatabaseOperations($status, $table, $id, $fieldArray, $this);
00544                                 }
00545                         }
00546                         // If this record is in remapStack (e.g. when using IRRE), values will be updated/remapped later on. So the hook will also be called later:
00547                 } else {
00548                         $this->remapStackRecords[$table][$id]['processDatamap_afterDatabaseOperations'] = array(
00549                                 'status' => $status,
00550                                 'fieldArray' => $fieldArray,
00551                                 'hookObjectsArr' => $hookObjectsArr,
00552                         );
00553                 }
00554         }
00555 
00556 
00557 
00558 
00559 
00560 
00561 
00562 
00563 
00564 
00565 
00566 
00567 
00568 
00569         /*********************************************
00570          *
00571          * PROCESSING DATA
00572          *
00573          *********************************************/
00574 
00581         function process_datamap() {
00582                 global $TCA, $TYPO3_CONF_VARS;
00583 
00584                         // Editing frozen:
00585                 if ($this->BE_USER->workspace!==0 && $this->BE_USER->workspaceRec['freeze'])    {
00586                         $this->newlog('All editing in this workspace has been frozen!',1);
00587                         return FALSE;
00588                 }
00589 
00590                         // First prepare user defined objects (if any) for hooks which extend this function:
00591                 $hookObjectsArr = array();
00592                 if (is_array ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'])) {
00593                         foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'] as $classRef) {
00594                                 $hookObjectsArr[] = &t3lib_div::getUserObj($classRef);
00595                         }
00596                 }
00597 
00598                         // 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.
00599                 $orderOfTables = Array();
00600                 if (isset($this->datamap['pages']))     {               // Set pages first.
00601                         $orderOfTables[]='pages';
00602                 }
00603                 reset($this->datamap);
00604                 while (list($table,) = each($this->datamap))    {
00605                         if ($table!='pages')    {
00606                                 $orderOfTables[]=$table;
00607                         }
00608                 }
00609 
00610                         // Process the tables...
00611                 foreach($orderOfTables as $table)       {
00612                                 /* Check if
00613                                         - table is set in $TCA,
00614                                         - table is NOT readOnly
00615                                         - the table is set with content in the data-array (if not, there's nothing to process...)
00616                                         - permissions for tableaccess OK
00617                                 */
00618                         $modifyAccessList = $this->checkModifyAccessList($table);
00619                         if (!$modifyAccessList) {
00620                                 $id = 0;
00621                                 $this->log($table,$id,2,0,1,"Attempt to modify table '%s' without permission",1,array($table));
00622                         }
00623                         if (isset($TCA[$table]) && !$this->tableReadOnly($table) && is_array($this->datamap[$table]) && $modifyAccessList)      {
00624                                 if ($this->reverseOrder)        {
00625                                         $this->datamap[$table] = array_reverse($this->datamap[$table], 1);
00626                                 }
00627 
00628                                         // For each record from the table, do:
00629                                         // $id is the record uid, may be a string if new records...
00630                                         // $incomingFieldArray is the array of fields
00631                                 foreach($this->datamap[$table] as $id => $incomingFieldArray)   {
00632                                         if (is_array($incomingFieldArray))      {
00633 
00634                                                         // Hook: processDatamap_preProcessIncomingFieldArray
00635                                                 foreach($hookObjectsArr as $hookObj)    {
00636                                                         if (method_exists($hookObj, 'processDatamap_preProcessFieldArray')) {
00637                                                                 $hookObj->processDatamap_preProcessFieldArray($incomingFieldArray, $table, $id, $this);
00638                                                         }
00639                                                 }
00640 
00641                                                         // ******************************
00642                                                         // Checking access to the record
00643                                                         // ******************************
00644                                                 $createNewVersion = FALSE;
00645                                                 $recordAccess = FALSE;
00646                                                 $old_pid_value = '';
00647                                                 $resetRejected = FALSE;
00648                                                 $this->autoVersioningUpdate = FALSE;
00649 
00650                                                 if (!t3lib_div::testInt($id)) {               // Is it a new record? (Then Id is a string)
00651                                                         $fieldArray = $this->newFieldArray($table);     // Get a fieldArray with default values
00652                                                         if (isset($incomingFieldArray['pid']))  {       // A pid must be set for new records.
00653                                                                         // $value = the pid
00654                                                                 $pid_value = $incomingFieldArray['pid'];
00655 
00656                                                                         // Checking and finding numerical pid, it may be a string-reference to another value
00657                                                                 $OK = 1;
00658                                                                 if (strstr($pid_value,'NEW'))   {       // If a NEW... id
00659                                                                         if (substr($pid_value,0,1)=='-') {$negFlag=-1;$pid_value=substr($pid_value,1);} else {$negFlag=1;}
00660                                                                         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.
00661                                                                                 $old_pid_value = $pid_value;
00662                                                                                 $pid_value=intval($negFlag*$this->substNEWwithIDs[$pid_value]);
00663                                                                         } else {$OK = 0;}       // If not found in the substArray we must stop the process...
00664                                                                 } 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.
00665                                                                         if ($WSdestPage = t3lib_BEfunc::getWorkspaceVersionOfRecord($this->BE_USER->workspace, 'pages', $pid_value, 'uid,t3ver_swapmode'))      {       // Looks for workspace version of page.
00666                                                                                 if ($WSdestPage['t3ver_swapmode']==0)   {       // if swapmode is zero, then change pid value.
00667                                                                                         $pid_value = $WSdestPage['uid'];
00668                                                                                 }
00669                                                                         }
00670                                                                 }
00671                                                                 $pid_value = intval($pid_value);
00672 
00673                                                                         // The $pid_value is now the numerical pid at this point
00674                                                                 if ($OK)        {
00675                                                                         $sortRow = $TCA[$table]['ctrl']['sortby'];
00676                                                                         if ($pid_value>=0)      {       // Points to a page on which to insert the element, possibly in the top of the page
00677                                                                                 if ($sortRow)   {       // If this table is sorted we better find the top sorting number
00678                                                                                         $fieldArray[$sortRow] = $this->getSortNumber($table,0,$pid_value);
00679                                                                                 }
00680                                                                                 $fieldArray['pid'] = $pid_value;        // The numerical pid is inserted in the data array
00681                                                                         } else {        // points to another record before ifself
00682                                                                                 if ($sortRow)   {       // If this table is sorted we better find the top sorting number
00683                                                                                         $tempArray=$this->getSortNumber($table,0,$pid_value);   // Because $pid_value is < 0, getSortNumber returns an array
00684                                                                                         $fieldArray['pid'] = $tempArray['pid'];
00685                                                                                         $fieldArray[$sortRow] = $tempArray['sortNumber'];
00686                                                                                 } else {        // Here we fetch the PID of the record that we point to...
00687                                                                                         $tempdata = $this->recordInfo($table,abs($pid_value),'pid');
00688                                                                                         $fieldArray['pid']=$tempdata['pid'];
00689                                                                                 }
00690                                                                         }
00691                                                                 }
00692                                                         }
00693                                                         $theRealPid = $fieldArray['pid'];
00694 
00695                                                                 // Now, check if we may insert records on this pid.
00696                                                         if ($theRealPid>=0)     {
00697                                                                 $recordAccess = $this->checkRecordInsertAccess($table,$theRealPid);             // Checks if records can be inserted on this $pid.
00698                                                                 if ($recordAccess)      {
00699                                                                         $this->addDefaultPermittedLanguageIfNotSet($table,$incomingFieldArray);
00700                                                                         $recordAccess = $this->BE_USER->recordEditAccessInternals($table,$incomingFieldArray,TRUE);
00701                                                                         if (!$recordAccess)             {
00702                                                                                 $this->newlog("recordEditAccessInternals() check failed. [".$this->BE_USER->errorMsg."]",1);
00703                                                                         } elseif(!$this->bypassWorkspaceRestrictions)   {
00704                                                                                         // Workspace related processing:
00705                                                                                 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
00706                                                                                         if ($res<0)     {
00707                                                                                                 $recordAccess = FALSE;
00708                                                                                                 $this->newlog('Stage for versioning root point and users access level did not allow for editing',1);
00709                                                                                         }
00710                                                                                 } else {        // So, if no live records were allowed, we have to create a new version of this record:
00711                                                                                         if ($TCA[$table]['ctrl']['versioningWS'])       {
00712                                                                                                 $createNewVersion = TRUE;
00713                                                                                         } else {
00714                                                                                                 $recordAccess = FALSE;
00715                                                                                                 $this->newlog('Record could not be created in this workspace in this branch',1);
00716                                                                                         }
00717                                                                                 }
00718                                                                         }
00719                                                                 }
00720                                                         } else {
00721                                                                 debug('Internal ERROR: pid should not be less than zero!');
00722                                                         }
00723                                                         $status = 'new';                                                // Yes new record, change $record_status to 'insert'
00724                                                 } else {        // Nope... $id is a number
00725                                                         $fieldArray = array();
00726                                                         $recordAccess = $this->checkRecordUpdateAccess($table,$id);
00727                                                         if (!$recordAccess)             {
00728                                                                 $propArr = $this->getRecordProperties($table,$id);
00729                                                                 $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']);
00730                                                         } else {        // Next check of the record permissions (internals)
00731                                                                 $recordAccess = $this->BE_USER->recordEditAccessInternals($table,$id);
00732                                                                 if (!$recordAccess)             {
00733                                                                         $propArr = $this->getRecordProperties($table,$id);
00734                                                                         $this->newlog("recordEditAccessInternals() check failed. [".$this->BE_USER->errorMsg."]",1);
00735                                                                 } else {        // Here we fetch the PID of the record that we point to...
00736                                                                         $tempdata = $this->recordInfo($table,$id,'pid'.($TCA[$table]['ctrl']['versioningWS']?',t3ver_wsid,t3ver_stage':''));
00737                                                                         $theRealPid = $tempdata['pid'];
00738 
00739                                                                                 // Prepare the reset of the rejected flag if set:
00740                                                                         if ($TCA[$table]['ctrl']['versioningWS'] && $tempdata['t3ver_stage']<0) {
00741                                                                                 $resetRejected = TRUE;
00742                                                                         }
00743 
00744                                                                                 // Checking access in case of offline workspace:
00745                                                                         if (!$this->bypassWorkspaceRestrictions && $errorCode = $this->BE_USER->workspaceCannotEditRecord($table,$tempdata))    {
00746                                                                                 $recordAccess = FALSE;          // Versioning is required and it must be offline version!
00747 
00748                                                                                         // 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.
00749                                                                                 if ($this->BE_USER->workspaceAllowAutoCreation($table,$id,$theRealPid)) {
00750                                                                                         $tce = t3lib_div::makeInstance('t3lib_TCEmain');
00751                                                                                         $tce->stripslashes_values = 0;
00752 
00753                                                                                                 // Setting up command for creating a new version of the record:
00754                                                                                         $cmd = array();
00755                                                                                         $cmd[$table][$id]['version'] = array(
00756                                                                                                 'action' => 'new',
00757                                                                                                 'treeLevels' => -1,     // Default is to create a version of the individual records...
00758                                                                                                 'label' => 'Auto-created for WS #'.$this->BE_USER->workspace
00759                                                                                         );
00760                                                                                         $tce->start(array(),$cmd);
00761                                                                                         $tce->process_cmdmap();
00762                                                                                         $this->errorLog = array_merge($this->errorLog,$tce->errorLog);
00763 
00764                                                                                         if ($tce->copyMappingArray[$table][$id])        {
00765                                                                                                 $this->uploadedFileArray[$table][$tce->copyMappingArray[$table][$id]] = $this->uploadedFileArray[$table][$id];
00766                                                                                                 $id = $this->autoVersionIdMap[$table][$id] = $tce->copyMappingArray[$table][$id];
00767                                                                                                 $recordAccess = TRUE;
00768                                                                                                 $this->autoVersioningUpdate = TRUE;
00769                                                                                         } else $this->newlog("Could not be edited in offline workspace in the branch where found (failure state: '".$errorCode."'). Auto-creation of version failed!",1);
00770                                                                                 } 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);
00771                                                                         }
00772                                                                 }
00773                                                         }
00774                                                         $status = 'update';     // the default is 'update'
00775                                                 }
00776 
00777                                                         // If access was granted above, proceed to create or update record:
00778                                                 if ($recordAccess)      {
00779 
00780                                                         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.
00781                                                         $TSConfig = $this->getTCEMAIN_TSconfig($tscPID);
00782                                                         if ($status=='new' && $table=='pages' && is_array($TSConfig['permissions.']))   {
00783                                                                 $fieldArray = $this->setTSconfigPermissions($fieldArray,$TSConfig['permissions.']);
00784                                                         }
00785                                                         if ($createNewVersion)  {
00786                                                                 $newVersion_placeholderFieldArray = $fieldArray;
00787                                                         }
00788 
00789                                                                 // Processing of all fields in incomingFieldArray and setting them in $fieldArray
00790                                                         $fieldArray = $this->fillInFieldArray($table,$id,$fieldArray,$incomingFieldArray,$theRealPid,$status,$tscPID);
00791 
00792                                                                 // NOTICE! All manipulation beyond this point bypasses both "excludeFields" AND possible "MM" relations / file uploads to field!
00793 
00794                                                                 // Forcing some values unto field array:
00795                                                         $fieldArray = $this->overrideFieldArray($table,$fieldArray);    // NOTICE: This overriding is potentially dangerous; permissions per field is not checked!!!
00796                                                         if ($createNewVersion)  {
00797                                                                 $newVersion_placeholderFieldArray = $this->overrideFieldArray($table,$newVersion_placeholderFieldArray);
00798                                                         }
00799 
00800                                                                 // Setting system fields
00801                                                         if ($status=='new')     {
00802                                                                 if ($TCA[$table]['ctrl']['crdate'])     {
00803                                                                         $fieldArray[$TCA[$table]['ctrl']['crdate']]=time();
00804                                                                         if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['crdate']]=time();
00805                                                                 }
00806                                                                 if ($TCA[$table]['ctrl']['cruser_id'])  {
00807                                                                         $fieldArray[$TCA[$table]['ctrl']['cruser_id']]=$this->userid;
00808                                                                         if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['cruser_id']]=$this->userid;
00809                                                                 }
00810                                                         } elseif ($this->checkSimilar) {        // Removing fields which are equal to the current value:
00811                                                                 $fieldArray = $this->compareFieldArrayWithCurrentAndUnset($table,$id,$fieldArray);
00812                                                         }
00813                                                         if ($TCA[$table]['ctrl']['tstamp'] && count($fieldArray))       {
00814                                                                 $fieldArray[$TCA[$table]['ctrl']['tstamp']]=time();
00815                                                                 if ($createNewVersion)  $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['tstamp']]=time();
00816                                                         }
00817                                                         if ($resetRejected)     {
00818                                                                 $fieldArray['t3ver_stage'] = 0;
00819                                                         }
00820 
00821                                                                 // Hook: processDatamap_postProcessFieldArray
00822                                                         foreach($hookObjectsArr as $hookObj)    {
00823                                                                 if (method_exists($hookObj, 'processDatamap_postProcessFieldArray')) {
00824                                                                         $hookObj->processDatamap_postProcessFieldArray($status, $table, $id, $fieldArray, $this);
00825                                                                 }
00826                                                         }
00827 
00828                                                                 // Performing insert/update. If fieldArray has been unset by some userfunction (see hook above), don't do anything
00829                                                                 // Kasper: Unsetting the fieldArray is dangerous; MM relations might be saved already and files could have been uploaded that are now "lost"
00830                                                         if (is_array($fieldArray)) {
00831                                                                 if ($status=='new')     {
00832                                                                         if ($createNewVersion)  {       // This creates a new version of the record with online placeholder and offline version
00833                                                                                 $versioningType = $table==='pages' ? $this->BE_USER->workspaceVersioningTypeGetClosest(t3lib_div::intInRange($TYPO3_CONF_VARS['BE']['newPagesVersioningType'],-1,1)) : -1;
00834                                                                                 if ($this->BE_USER->workspaceVersioningTypeAccess($versioningType))     {
00835                                                                                         $newVersion_placeholderFieldArray['t3ver_label'] = 'INITIAL PLACEHOLDER';
00836                                                                                         $newVersion_placeholderFieldArray['t3ver_state'] = 1;   // Setting placeholder state value for temporary record
00837                                                                                         $newVersion_placeholderFieldArray['t3ver_wsid'] = $this->BE_USER->workspace;    // Setting workspace - only so display of place holders can filter out those from other workspaces.
00838                                                                                         $newVersion_placeholderFieldArray[$TCA[$table]['ctrl']['label']] = '[PLACEHOLDER, WS#'.$this->BE_USER->workspace.']';
00839                                                                                         $this->insertDB($table,$id,$newVersion_placeholderFieldArray,FALSE);    // Saving placeholder as 'original'
00840 
00841                                                                                                 // For the actual new offline version, set versioning values to point to placeholder:
00842                                                                                         $fieldArray['pid'] = -1;
00843                                                                                         $fieldArray['t3ver_oid'] = $this->substNEWwithIDs[$id];
00844                                                                                         $fieldArray['t3ver_id'] = 1;
00845                                                                                         $fieldArray['t3ver_state'] = -1;        // Setting placeholder state value for version (so it can know it is currently a new version...)
00846                                                                                         $fieldArray['t3ver_label'] = 'First draft version';
00847                                                                                         $fieldArray['t3ver_wsid'] = $this->BE_USER->workspace;
00848                                                                                         if ($table==='pages') {         // Swap mode set to "branch" so we can build branches for pages.
00849                                                                                                 $fieldArray['t3ver_swapmode'] = $versioningType;
00850                                                                                         }
00851                                                                                         $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!
00852                                                                                         if ($phShadowId)        {
00853                                                                                                 $this->placeholderShadowing($table,$phShadowId);
00854                                                                                         }
00855                                                                                 } else $this->newlog('Versioning type "'.$versioningType.'" was not allowed, so could not create new record.',1);
00856                                                                         } else {
00857                                                                                 $this->insertDB($table,$id,$fieldArray,FALSE,$incomingFieldArray['uid']);
00858                                                                         }
00859                                                                 } else {
00860                                                                         $this->updateDB($table,$id,$fieldArray);
00861                                                                         $this->placeholderShadowing($table,$id);
00862                                                                 }
00863                                                         }
00864 
00865                                                                 /*
00866                                                                  * Hook: processDatamap_afterDatabaseOperations
00867                                                                  *
00868                                                                  * Note: When using the hook after INSERT operations, you will only get the temporary NEW... id passed to your hook as $id,
00869                                                                  *               but you can easily translate it to the real uid of the inserted record using the $this->substNEWwithIDs array.
00870                                                                  */
00871                                                                 $this->hook_processDatamap_afterDatabaseOperations($hookObjectsArr, $status, $table, $id, $fieldArray);
00872                                                 }       // if ($recordAccess)   {
00873                                         }       // if (is_array($incomingFieldArray))   {
00874                                 }
00875                         }
00876                 }
00877 
00878                         // Process the stack of relations to remap/correct
00879                 $this->processRemapStack();
00880 
00881                 $this->dbAnalysisStoreExec();
00882                 $this->removeRegisteredFiles();
00883         }
00884 
00892         function placeholderShadowing($table,$id)       {
00893                 global $TCA;
00894 
00895                 t3lib_div::loadTCA($table);
00896                 if ($liveRec = t3lib_BEfunc::getLiveVersionOfRecord($table,$id,'*'))    {
00897                         if ((int)$liveRec['t3ver_state']===1)   {
00898                                 $justStoredRecord = t3lib_BEfunc::getRecord($table,$id);
00899                                 $newRecord = array();
00900 
00901                                 $shadowCols = $TCA[$table]['ctrl']['shadowColumnsForNewPlaceholders'];
00902                                 $shadowCols.= ','.$TCA[$table]['ctrl']['languageField'];
00903                                 $shadowCols.= ','.$TCA[$table]['ctrl']['transOrigPointerField'];
00904                                 $shadowCols.= ','.$TCA[$table]['ctrl']['type'];
00905                                 $shadowCols.= ','.$TCA[$table]['ctrl']['label'];
00906 
00907                                 $shadowColumns = array_unique(t3lib_div::trimExplode(',', $shadowCols,1));
00908                                 foreach($shadowColumns as $fieldName)   {
00909                                         if (strcmp($justStoredRecord[$fieldName],$liveRec[$fieldName]) && isset($TCA[$table]['columns'][$fieldName]) && $fieldName!=='uid' && $fieldName!=='pid')       {
00910                                                 $newRecord[$fieldName] = $justStoredRecord[$fieldName];
00911                                         }
00912                                 }
00913 
00914                                 if (count($newRecord))  {
00915                                         $this->newlog('Shadowing done on fields '.implode(',',array_keys($newRecord)).' in Placeholder record '.$table.':'.$liveRec['uid'].' (offline version UID='.$id.')');
00916                                         $this->updateDB($table,$liveRec['uid'],$newRecord);
00917                                 }
00918                         }
00919                 }
00920         }
00921 
00935         function fillInFieldArray($table,$id,$fieldArray,$incomingFieldArray,$realPid,$status,$tscPID)  {
00936                 global $TCA;
00937 
00938                         // Initialize:
00939                 t3lib_div::loadTCA($table);
00940                 $originalLanguageRecord = NULL;
00941                 $originalLanguage_diffStorage = NULL;
00942                 $diffStorageFlag = FALSE;
00943 
00944                         // Setting 'currentRecord' and 'checkValueRecord':
00945                 if (strstr($id,'NEW'))  {
00946                         $currentRecord = $checkValueRecord = $fieldArray;       // must have the 'current' array - not the values after processing below...
00947 
00948                                 // IF $incomingFieldArray is an array, overlay it.
00949                                 // 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...
00950                         if (is_array($incomingFieldArray) && is_array($checkValueRecord))       {
00951                                 $checkValueRecord = t3lib_div::array_merge_recursive_overrule($checkValueRecord, $incomingFieldArray);
00952                         }
00953                 } else {
00954                         $currentRecord = $checkValueRecord = $this->recordInfo($table,$id,'*'); // We must use the current values as basis for this!
00955 
00956                         t3lib_BEfunc::fixVersioningPid($table,$currentRecord);  // This is done to make the pid positive for offline versions; Necessary to have diff-view for pages_language_overlay in workspaces.
00957 
00958                                 // Get original language record if available:
00959                         if (is_array($currentRecord)
00960                                         && $TCA[$table]['ctrl']['transOrigDiffSourceField']
00961                                         && $TCA[$table]['ctrl']['languageField']
00962                                         && $currentRecord[$TCA[$table]['ctrl']['languageField']] > 0
00963                                         && $TCA[$table]['ctrl']['transOrigPointerField']
00964                                         && intval($currentRecord[$TCA[$table]['ctrl']['transOrigPointerField']]) > 0)   {
00965 
00966                                 $lookUpTable = $TCA[$table]['ctrl']['transOrigPointerTable'] ? $TCA[$table]['ctrl']['transOrigPointerTable'] : $table;
00967                                 $originalLanguageRecord = $this->recordInfo($lookUpTable,$currentRecord[$TCA[$table]['ctrl']['transOrigPointerField']],'*');
00968                                 t3lib_BEfunc::workspaceOL($lookUpTable,$originalLanguageRecord);
00969                                 $originalLanguage_diffStorage = unserialize($currentRecord[$TCA[$table]['ctrl']['transOrigDiffSourceField']]);
00970                         }
00971                 }
00972                 $this->checkValue_currentRecord = $checkValueRecord;
00973 
00974                         /*
00975                                 In the following all incoming value-fields are tested:
00976                                 - Are the user allowed to change the field?
00977                                 - Is the field uid/pid (which are already set)
00978                                 - perms-fields for pages-table, then do special things...
00979                                 - If the field is nothing of the above and the field is configured in TCA, the fieldvalues are evaluated by ->checkValue
00980 
00981                                 If everything is OK, the field is entered into $fieldArray[]
00982                         */
00983                 foreach($incomingFieldArray as $field => $fieldValue)   {
00984                         if (!in_array($table.'-'.$field, $this->exclude_array) && !$this->data_disableFields[$table][$id][$field])      {       // The field must be editable.
00985 
00986                                         // Checking if a value for language can be changed:
00987                                 $languageDeny = $TCA[$table]['ctrl']['languageField'] && !strcmp($TCA[$table]['ctrl']['languageField'], $field) && !$this->BE_USER->checkLanguageAccess($fieldValue);
00988 
00989                                 if (!$languageDeny)     {
00990                                                 // Stripping slashes - will probably be removed the day $this->stripslashes_values is removed as an option...
00991                                         if ($this->stripslashes_values) {
00992                                                 if (is_array($fieldValue))      {
00993                                                         t3lib_div::stripSlashesOnArray($fieldValue);
00994                                                 } else $fieldValue = stripslashes($fieldValue);
00995                                         }
00996 
00997                                         switch ($field) {
00998                                                 case 'uid':
00999                                                 case 'pid':
01000                                                         // Nothing happens, already set
01001                                                 break;
01002                                                 case 'perms_userid':
01003                                                 case 'perms_groupid':
01004                                                 case 'perms_user':
01005                                                 case 'perms_group':
01006                                                 case 'perms_everybody':
01007                                                                 // Permissions can be edited by the owner or the administrator
01008                                                         if ($table=='pages' && ($this->admin || $status=='new' || $this->pageInfo($id,'perms_userid')==$this->userid) ) {
01009                                                                 $value=intval($fieldValue);
01010                                                                 switch($field)  {
01011                                                                         case 'perms_userid':
01012                                                                                 $fieldArray[$field]=$value;
01013                                                                         break;
01014                                                                         case 'perms_groupid':
01015                                                                                 $fieldArray[$field]=$value;
01016                                                                         break;
01017                                                                         default:
01018                                                                                 if ($value>=0 && $value<pow(2,5))       {
01019                                                                                         $fieldArray[$field]=$value;
01020                                                                                 }
01021                                                                         break;
01022                                                                 }
01023                                                         }
01024                                                 break;
01025                                                 case 't3ver_oid':
01026                                                 case 't3ver_id':
01027                                                 case 't3ver_wsid':
01028                                                 case 't3ver_state':
01029                                                 case 't3ver_swapmode':
01030                                                 case 't3ver_count':
01031                                                 case 't3ver_stage':
01032                                                 case 't3ver_tstamp':
01033                                                         // t3ver_label is not here because it CAN be edited as a regular field!
01034                                                 break;
01035                                                 default:
01036                                                         if (isset($TCA[$table]['columns'][$field]))     {
01037                                                                         // Evaluating the value.
01038                                                                 $res = $this->checkValue($table,$field,$fieldValue,$id,$status,$realPid,$tscPID);
01039                                                                 if (isset($res['value']))       {
01040                                                                         $fieldArray[$field]=$res['value'];
01041 
01042                                                                                 // Add the value of the original record to the diff-storage content:
01043                                                                         if ($TCA[$table]['ctrl']['transOrigDiffSourceField'])   {
01044                                                                                 $originalLanguage_diffStorage[$field] = $originalLanguageRecord[$field];
01045                                                                                 $diffStorageFlag = TRUE;
01046                                                                         }
01047                                                                 }
01048                                                         } elseif ($TCA[$table]['ctrl']['origUid']===$field) {   // Allow value for original UID to pass by...
01049                                                                 $fieldArray[$field] = $fieldValue;
01050                                                         }
01051                                                 break;
01052                                         }
01053                                 }       // Checking language.
01054                         }       // Check exclude fields / disabled fields...
01055                 }
01056 
01057                         // Add diff-storage information:
01058                 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...
01059                          $fieldArray[$TCA[$table]['ctrl']['transOrigDiffSourceField']] = serialize($originalLanguage_diffStorage);
01060                 }
01061 
01062                         // Checking for RTE-transformations of fields:
01063                 $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table,$currentRecord);
01064                 $theTypeString = t3lib_BEfunc::getTCAtypeValue($table,$currentRecord);
01065                 if (is_array($types_fieldConfig))       {
01066                         reset($types_fieldConfig);
01067                         while(list(,$vconf) = each($types_fieldConfig)) {
01068                                         // Write file configuration:
01069                                 $eFile = t3lib_parsehtml_proc::evalWriteFile($vconf['spec']['static_write'],array_merge($currentRecord,$fieldArray));   // inserted array_merge($currentRecord,$fieldArray) 170502
01070 
01071                                         // RTE transformations:
01072                                 if (!$this->dontProcessTransformations) {
01073                                         if (isset($fieldArray[$vconf['field']]))        {
01074                                                         // Look for transformation flag:
01075                                                 switch((string)$incomingFieldArray['_TRANSFORM_'.$vconf['field']])      {
01076                                                         case 'RTE':
01077                                                                 $RTEsetup = $this->BE_USER->getTSConfig('RTE',t3lib_BEfunc::getPagesTSconfig($tscPID));
01078                                                                 $thisConfig = t3lib_BEfunc::RTEsetup($RTEsetup['properties'],$table,$vconf['field'],$theTypeString);
01079 
01080                                                                         // Set alternative relative path for RTE images/links:
01081                                                                 $RTErelPath = is_array($eFile) ? dirname($eFile['relEditFile']) : '';
01082 
01083                                                                         // Get RTE object, draw form and set flag:
01084                                                                 $RTEobj = &t3lib_BEfunc::RTEgetObj();
01085                                                                 if (is_object($RTEobj)) {
01086                                                                         $fieldArray[$vconf['field']] = $RTEobj->transformContent('db',$fieldArray[$vconf['field']],$table,$vconf['field'],$currentRecord,$vconf['spec'],$thisConfig,$RTErelPath,$currentRecord['pid']);
01087                                                                 } else {
01088                                                                         debug('NO RTE OBJECT FOUND!');
01089                                                                 }
01090                                                         break;
01091                                                 }
01092                                         }
01093                                 }
01094 
01095                                         // Write file configuration:
01096                                 if (is_array($eFile))   {
01097                                         $mixedRec = array_merge($currentRecord,$fieldArray);
01098                                         $SW_fileContent = t3lib_div::getUrl($eFile['editFile']);
01099                                         $parseHTML = t3lib_div::makeInstance('t3lib_parsehtml_proc');
01100                                         $parseHTML->init('','');
01101 
01102                                         $eFileMarker = $eFile['markerField']&&trim($mixedRec[$eFile['markerField']]) ? trim($mixedRec[$eFile['markerField']]) : '###TYPO3_STATICFILE_EDIT###';
01103                                         $insertContent = str_replace($eFileMarker,'',$mixedRec[$eFile['contentField']]);        // must replace the marker if present in content!
01104 
01105                                         $SW_fileNewContent = $parseHTML->substituteSubpart($SW_fileContent, $eFileMarker, chr(10).$insertContent.chr(10), 1, 1);
01106                                         t3lib_div::writeFile($eFile['editFile'],$SW_fileNewContent);
01107 
01108                                                 // Write status:
01109                                         if (!strstr($id,'NEW') && $eFile['statusField'])        {
01110                                                 $GLOBALS['TYPO3_DB']->exec_UPDATEquery(
01111                                                         $table,
01112                                                         'uid='.intval($id),
01113                                                         array(
01114                                                                 $eFile['statusField'] => $eFile['relEditFile'].' updated '.date('d-m-Y H:i:s').', bytes '.strlen($mixedRec[$eFile['contentField']])
01115                                                         )
01116                                                 );
01117                                         }
01118                                 } elseif ($eFile && is_string($eFile))  {
01119                                         $this->log($table,$id,2,0,1,"Write-file error: '%s'",13,array($eFile),$realPid);
01120                                 }
01121                         }
01122                 }
01123                         // Return fieldArray
01124                 return $fieldArray;
01125         }
01126 
01127 
01128 
01129 
01130 
01131 
01132 
01133 
01134 
01135 
01136 
01137 
01138         /*********************************************
01139          *
01140          * Evaluation of input values
01141          *
01142          ********************************************/
01143 
01158<
/src/typo3_src-4.1.2/t3lib/class.t3lib_tcemain.php
