TYPO3 Core

* Copyright notice

*

* (c) 1999-2010 Kasper Sk?rh?j (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!

***************************************************************/

* 367: function start($data,$cmd,$altUserObject='')

* 406: function setMirror($mirror)

* 431: function setDefaultsFromUserTS($userTS)

* 454: function process_uploads($postFiles)

* 492: function process_uploads_traverseArray(&$outputArr,$inputArr,$keyToSet)

* SECTION: PROCESSING DATA

* 528: function process_datamap()

* 886: function placeholderShadowing($table,$id)

* 929: function fillInFieldArray($table,$id,$fieldArray,$incomingFieldArray,$realPid,$status,$tscPID)

* SECTION: Evaluation of input values

* 1152: function checkValue($table,$field,$value,$id,$status,$realPid,$tscPID)

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

* 1261: function checkValue_input($res,$value,$tcaFieldConf,$PP,$field='')

* 1299: function checkValue_check($res,$value,$tcaFieldConf,$PP)

* 1322: function checkValue_radio($res,$value,$tcaFieldConf,$PP)

* 1348: function checkValue_group_select($res,$value,$tcaFieldConf,$PP,$uploadedFiles,$field)

* 1458: function checkValue_group_select_file($valueArray,$tcaFieldConf,$curValue,$uploadedFileArray,$status,$table,$id,$recFID)

* 1632: function checkValue_flex($res,$value,$tcaFieldConf,$PP,$uploadedFiles,$field)

* 1709: function checkValue_flexArray2Xml($array, $addPrologue=FALSE)

* 1721: function _DELETE_FLEX_FORMdata(&$valueArrayToRemoveFrom,$deleteCMDS)

* 1743: function _MOVE_FLEX_FORMdata(&$valueArrayToMoveIn, $moveCMDS, $direction)

* 1783: function checkValue_inline($res,$value,$tcaFieldConf,$PP,$field)

* 1825: function checkValue_checkMax($tcaFieldConf, $valueArray)

* SECTION: Helper functions for evaluation functions.

* 1877: function getUnique($table,$field,$value,$id,$newPid=0)

* 1915: function checkValue_input_Eval($value,$evalArray,$is_in)

* 2012: function checkValue_group_select_processDBdata($valueArray,$tcaFieldConf,$id,$status,$type,$currentTable)

* 2058: function checkValue_group_select_explodeSelectGroupValue($value)

* 2082: function checkValue_flex_procInData($dataPart,$dataPart_current,$uploadedFiles,$dataStructArray,$pParams,$callBackFunc='')

* 2121: function checkValue_flex_procInData_travDS(&$dataValues,$dataValues_current,$uploadedFiles,$DSelements,$pParams,$callBackFunc,$structurePath)

* SECTION: PROCESSING COMMANDS

* 2267: function process_cmdmap()

* SECTION: Cmd: Copying

* 2407: function copyRecord($table,$uid,$destPid,$first=0,$overrideValues=array(),$excludeFields='')

* 2529: function copyPages($uid,$destPid)

* 2583: function copySpecificPage($uid,$destPid,$copyTablesArray,$first=0)

* 2617: function copyRecord_raw($table,$uid,$pid,$overrideArray=array())

* 2681: function rawCopyPageContent($old_pid,$new_pid,$copyTablesArray)

* 2705: function insertNewCopyVersion($table,$fieldArray,$realPid)

* 2757: function copyRecord_procBasedOnFieldType($table,$uid,$field,$value,$row,$conf,$realDestPid)

* 2836: function copyRecord_flexFormCallBack($pParams, $dsConf, $dataValue, $dataValue_ext1, $dataValue_ext2)

* 2864: function copyRecord_procFilesRefs($conf, $uid, $value)

* SECTION: Cmd: Moving, Localizing

* 2933: function moveRecord($table,$uid,$destPid)

* 3128: function moveRecord_procFields($table,$uid,$destPid)

* 3148: function moveRecord_procBasedOnFieldType($table,$uid,$destPid,$field,$value,$conf)

* 3182: function localize($table,$uid,$language)

* SECTION: Cmd: Deleting

* 3296: function deleteAction($table, $id)

* 3343: function deleteEl($table, $uid, $noRecordCheck=FALSE, $forceHardDelete=FALSE)

* 3360: function deleteVersionsForRecord($table, $uid, $forceHardDelete)

* 3382: function undeleteRecord($table,$uid)

* 3399: function deleteRecord($table,$uid, $noRecordCheck=FALSE, $forceHardDelete=FALSE,$undeleteRecord=FALSE)

* 3512: function deleteRecord_flexFormCallBack($dsArr, $dataValue, $PA, $structurePath, &$pObj)

* 3539: function deletePages($uid,$force=FALSE,$forceHardDelete=FALSE)

* 3567: function deleteSpecificPage($uid,$forceHardDelete=FALSE)

* 3592: function canDeletePage($uid)

* 3619: function cannotDeleteRecord($table,$id)

* 3638: function deleteRecord_procFields($table, $uid, $undeleteRecord = false)

* 3661: function deleteRecord_procBasedOnFieldType($table, $uid, $field, $value, $conf, $undeleteRecord = false)

* SECTION: Cmd: Versioning

* 3722: function versionizeRecord($table,$id,$label,$delete=FALSE,$versionizeTree=-1)

* 3798: function versionizePages($uid,$label,$versionizeTree)

* 3861: function version_swap($table,$id,$swapWith,$swapIntoWS=0)

* 4032: function version_clearWSID($table,$id)

* 4066: function version_setStage($table,$id,$stageId,$comment='')

* SECTION: Cmd: Helper functions

* 4111: function remapListedDBRecords()

* 4192: function remapListedDBRecords_flexFormCallBack($pParams, $dsConf, $dataValue, $dataValue_ext1, $dataValue_ext2)

* 4219: function remapListedDBRecords_procDBRefs($conf, $value, $MM_localUid, $table)

* 4265: function remapListedDBRecords_procInline($conf, $value, $uid, $table)

* SECTION: Access control / Checking functions

* 4308: function checkModifyAccessList($table)

* 4320: function isRecordInWebMount($table,$id)

* 4334: function isInWebMount($pid)

* 4348: function checkRecordUpdateAccess($table,$id)

* 4372: function checkRecordInsertAccess($insertTable,$pid,$action=1)

* 4406: function isTableAllowedForThisPage($page_uid, $checkTable)

* 4439: function doesRecordExist($table,$id,$perms)

* 4504: function doesRecordExist_pageLookUp($id, $perms)

* 4530: function doesBranchExist($inList,$pid,$perms,$recurse)

* 4564: function tableReadOnly($table)

* 4576: function tableAdminOnly($table)

* 4590: function destNotInsideSelf($dest,$id)

* 4622: function getExcludeListArray()

* 4645: function doesPageHaveUnallowedTables($page_uid,$doktype)

* SECTION: Information lookup

* 4694: function pageInfo($id,$field)

* 4714: function recordInfo($table,$id,$fieldList)

* 4735: function getRecordProperties($table,$id,$noWSOL=FALSE)

* 4751: function getRecordPropertiesFromRow($table,$row)

* SECTION: Storing data to Database Layer

* 4794: function updateDB($table,$id,$fieldArray)

* 4846: function insertDB($table,$id,$fieldArray,$newVersion=FALSE,$suggestedUid=0,$dontSetNewIdIndex=FALSE)

* 4919: function checkStoredRecord($table,$id,$fieldArray,$action)

* 4956: function setHistory($table,$id,$logId)

* 4989: function clearHistory($maxAgeSeconds=604800,$table)

* 5003: function updateRefIndex($table,$id)

* SECTION: Misc functions

* 5035: function getSortNumber($table,$uid,$pid)

* 5108: function resorting($table,$pid,$sortRow, $return_SortNumber_After_This_Uid)

* 5139: function setTSconfigPermissions($fieldArray,$TSConfig_p)

* 5156: function newFieldArray($table)

* 5188: function addDefaultPermittedLanguageIfNotSet($table,&$incomingFieldArray)

* 5212: function overrideFieldArray($table,$data)

* 5228: function compareFieldArrayWithCurrentAndUnset($table,$id,$fieldArray)

* 5274: function assemblePermissions($string)

* 5291: function rmComma($input)

* 5301: function convNumEntityToByteValue($input)

* 5323: function destPathFromUploadFolder($folder)

* 5333: function deleteClause($table)

* 5349: function getTCEMAIN_TSconfig($tscPID)

* 5364: function getTableEntries($table,$TSconfig)

* 5377: function getPID($table,$uid)

* 5390: function dbAnalysisStoreExec()

* 5406: function removeRegisteredFiles()

* 5418: function removeCacheFiles()

* 5432: function int_pageTreeInfo($CPtable,$pid,$counter, $rootID)

* 5453: function compileAdminTables()

* 5470: function fixUniqueInPid($table,$uid)

* 5506: function fixCopyAfterDuplFields($table,$uid,$prevUid,$update, $newData=array())

* 5531: function extFileFields($table)

* 5552: function getUniqueFields($table)

* 5577: function isReferenceField($conf)

* 5588: function getInlineFieldType($conf)

* 5611: function getCopyHeader($table,$pid,$field,$value,$count,$prevTitle='')

* 5640: function prependLabel($table)

* 5657: function resolvePid($table,$pid)

* 5687: function clearPrefixFromValue($table,$value)

* 5702: function extFileFunctions($table,$field,$filelist,$func)

* 5732: function noRecordsFromUnallowedTables($inList)

* 5758: function notifyStageChange($stat,$stageId,$table,$id,$comment)

* 5853: function notifyStageChange_getEmails($listOfUsers,$noTablePrefix=FALSE)

* SECTION: Clearing cache

* 5899: function clear_cache($table,$uid)

* 6009: function clear_cacheCmd($cacheCmd)

* SECTION: Logging

* 6113: function log($table,$recuid,$action,$recpid,$error,$details,$details_nr=-1,$data=array(),$event_pid=-1,$NEWid='')

* 6130: function newlog($message, $error=0)

* 6140: function printLogErrorMessages($redirect)

* SECTION: Internal (do not use outside Core!)

* 6202: function internal_clearPageCache()

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 $clear_flexFormData_vDEFbase = FALSE; // Boolean: If set, .vDEFbase values are unset in flexforms.

var $updateModeL10NdiffData = TRUE; // Boolean/Mixed: TRUE: (traditional) Updates when record is saved. For flexforms, updates if change is made to the localized value. FALSE: Will not update anything. "FORCE_FFUPD" (string): Like TRUE, but will force update to the FlexForm Field

var $updateModeL10NdiffDataClear = FALSE; // Boolean: If true, the translation diff. fields will in fact be reset so that they indicate that all needs to change again! It's meant as the opposite of declaring the record translated.

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 $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!

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!

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 $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 $alternativeFilePath = array(); // Array [filename]=alternative_filepath: Same as alternativeFileName but with relative path to the file

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 $newRelatedIDs = array(); // Holds the tables and there the ids of newly created child records from IRRE

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 $RTEmagic_copyIndex = array(); // Contains [table][id][field] of fiels where RTEmagic images was copied. Holds old filename as key and new filename as value.

var $errorLog = array(); // Errors are collected in this variable.

// *********************

// Internal Variables, do not touch.

// *********************

// Variables set in init() function:

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

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

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

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

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 $registerDBPids = array(); // Used for tracking references that might need correction in pid field after operations (e.g. IRRE)

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.

var $remapStack = array(); // array used for remapping uids and values at the end of process_datamap

var $remapStackRecords = array(); // array used for remapping uids and values at the end of process_datamap (e.g. $remapStackRecords[<table>][<uid>] = <index in $remapStack>)

protected $remapStackChildIds = array(); // array used for checking whether new children need to be remapped

protected $remapStackActions = array(); // array used for executing addition actions after remapping happened (sett processRemapStack())

protected $remapStackRefIndex = array(); // array used for executing post-processing on the reference index

var $updateRefIndexStack = array(); // array used for additional calls to $this->updateRefIndex

var $callFromImpExp = FALSE; // tells, that this TCEmain was called from tx_impext - this variable is set by tx_impexp

var $newIndexMap = array(); // Array for new flexform index mapping

// 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.

protected $disableDeleteClause = FALSE; // Disable delete clause

if ($GLOBALS['TYPO3_CONF_VARS']['BE']['explicitConfirmationOfTranslation'] && $this->updateModeL10NdiffData === TRUE) {

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'];

}

if (is_array($cmd)) {

function setMirror($mirror) {

if (is_array($mirror)) {

if (isset($this->datamap[$table])) {

if (isset($this->datamap[$table][$id])) {

$theIdsInArray = t3lib_div::trimExplode(',', $uidList, 1);

function setDefaultsFromUserTS($userTS) {

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);

function process_uploads($postFiles) {

if (is_array($postFiles)) {

if ($this->BE_USER->workspace !== 0 && $this->BE_USER->workspaceRec['freeze']) {

$this->newlog('All editing in this workspace has been frozen!', 1);

if (is_array($subA)) {

if (is_array($subA['name']) && is_array($subA['type']) && is_array($subA['tmp_name']) && is_array($subA['size'])) {

$this->uploadedFileArray = array();

foreach ($subA as $key => $values) {

$this->process_uploads_traverseArray($this->uploadedFileArray, $values, $key);

$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);

$outputArr[$keyToSet] = $inputArr;

foreach ($hookObjectsArr as $hookObj) {

// 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:

if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['checkModifyAccessList'])) {

foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['checkModifyAccessList'] as $classData) {

if (!($hookObject instanceof t3lib_TCEmain_checkModifyAccessListHook)) {

if ($this->BE_USER->workspace !== 0 && $this->BE_USER->workspaceRec['freeze']) {

$this->newlog('All editing in this workspace has been frozen!', 1);

if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'])) {

$orderOfTables = array();

if (isset($this->datamap['pages'])) { // Set pages first.

$orderOfTables[] = 'pages';

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

*/

if (!$modifyAccessList) {

$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) {

foreach ($this->datamap[$table] as $id => $incomingFieldArray) {

if (is_array($incomingFieldArray)) {

foreach ($hookObjectsArr as $hookObj) {

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.

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.

$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.

if ($OK) {

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

} 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'];

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) {

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) {

$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']) {

$this->newlog('Record could not be created in this workspace in this branch', 1);

$status = 'new'; // Yes new record, change $record_status to 'insert'

} else { // Nope... $id is a number

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' : ''));

// Use the new id of the versionized record we're trying to write to:

// Checking access in case of offline workspace:

} elseif (!$this->bypassWorkspaceRestrictions && $errorCode = $this->BE_USER->workspaceCannotEditRecord($table, $tempdata)) {

$recordAccess = FALSE; // Versioning is required and it must be offline version!

if ($this->BE_USER->workspaceAllowAutoCreation($table, $id, $theRealPid)) {

'treeLevels' => -1, // Default is to create a version of the individual records... element versioning that is.

'label' => 'Auto-created for WS #' . $this->BE_USER->workspace

$tce->start(array(), $cmd);

$this->errorLog = array_merge($this->errorLog, $tce->errorLog);

if ($tce->copyMappingArray[$table][$id]) {

$this->RTEmagic_copyIndex = t3lib_div::array_merge_recursive_overrule($this->RTEmagic_copyIndex, $tce->RTEmagic_copyIndex); // See where RTEmagic_copyIndex is used inside fillInFieldArray() for more information...

} 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 ($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.

if ($status == 'new' && $table == 'pages' && is_array($TSConfig['permissions.'])) {

$fieldArray = $this->setTSconfigPermissions($fieldArray, $TSConfig['permissions.']);

if ($createNewVersion) {

$fieldArray = $this->fillInFieldArray($table, $id, $fieldArray, $incomingFieldArray, $theRealPid, $status, $tscPID);

$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);

if ($status == 'new') {

if ($TCA[$table]['ctrl']['crdate']) {

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)) {

foreach ($hookObjectsArr as $hookObj) {

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_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'

$fieldArray['t3ver_state'] = -1; // Setting placeholder state value for version (so it can know it is currently a new version...)

if ($table === 'pages') { // Swap mode set to "branch" so we can build branches for pages.

$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) {

} 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']);

$this->updateDB($table, $id, $fieldArray);

$this->placeholderShadowing($table, $id);

/*

* Hook: processDatamap_afterDatabaseOperations

*

* Note: When using the hook after INSERT operations, you will only get the temporary NEW... id passed to your hook as $id,

* but you can easily translate it to the real uid of the inserted record using the $this->substNEWwithIDs array.

*/

} // if ($recordAccess) {

} // if (is_array($incomingFieldArray)) {

foreach ($hookObjectsArr as $hookObj) {

function placeholderShadowing($table, $id) {

if ($liveRec = t3lib_BEfunc::getLiveVersionOfRecord($table, $id, '*')) {

if ((int) $liveRec['t3ver_state'] > 0) {

$justStoredRecord = t3lib_BEfunc::getRecord($table, $id);

$shadowCols .= ',' . $TCA[$table]['ctrl']['languageField'];

$shadowCols .= ',' . $TCA[$table]['ctrl']['transOrigPointerField'];

$shadowCols .= ',' . $TCA[$table]['ctrl']['type'];

$shadowCols .= ',' . $TCA[$table]['ctrl']['label'];

$shadowColumns = array_unique(t3lib_div::trimExplode(',', $shadowCols, 1));

foreach ($shadowColumns as $fieldName) {

if (strcmp($justStoredRecord[$fieldName], $liveRec[$fieldName]) && isset($TCA[$table]['columns'][$fieldName]) && $fieldName !== 'uid' && $fieldName !== 'pid') {

if (count($newRecord)) {

$this->newlog2('Shadowing done on fields <i>' . implode(',', array_keys($newRecord)) . '</i> in placeholder record ' . $table . ':' . $liveRec['uid'] . ' (offline version UID=' . $id . ')', $table, $liveRec['uid'], $liveRec['pid']);

$this->updateDB($table, $liveRec['uid'], $newRecord);

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

if (strstr($id, 'NEW')) {

$currentRecord = $checkValueRecord = $fieldArray; // must have the 'current' array - not the values after processing below...

if (is_array($incomingFieldArray) && is_array($checkValueRecord)) {

$currentRecord = $checkValueRecord = $this->recordInfo($table, $id, '*'); // We must use the current values as basis for this!

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.

&& $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) {

$originalLanguageRecord = $this->recordInfo($lookUpTable, $currentRecord[$TCA[$table]['ctrl']['transOrigPointerField']], '*');

t3lib_BEfunc::workspaceOL($lookUpTable, $originalLanguageRecord);

/*

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.

if (!$languageDeny) {

if ($this->stripslashes_values) {

if (is_array($fieldValue)) {

} else {

$fieldValue = stripslashes($fieldValue);

}

}

switch ($field) {

if ($table == 'pages' && ($this->admin || $status == 'new' || $this->pageInfo($id, 'perms_userid') == $this->userid)) {

$value = intval($fieldValue);

switch ($field) {

$fieldArray[$field] = $value;

$fieldArray[$field] = $value;

if ($value >= 0 && $value < pow(2, 5)) {

$fieldArray[$field] = $value;

if (isset($TCA[$table]['columns'][$field])) {

$res = $this->checkValue($table, $field, $fieldValue, $id, $status, $realPid, $tscPID);

if (isset($res['value'])) {

if ($this->updateModeL10NdiffData && $TCA[$table]['ctrl']['transOrigDiffSourceField']) {

if ($this->autoVersioningUpdate === TRUE) {

if (is_array($this->RTEmagic_copyIndex[$table][$id][$field])) {

foreach ($this->RTEmagic_copyIndex[$table][$id][$field] as $oldRTEmagicName => $newRTEmagicName) {

$fieldArray[$field] = str_replace(' src="' . $oldRTEmagicName . '"', ' src="' . $newRTEmagicName . '"', $fieldArray[$field]);

} elseif ($TCA[$table]['ctrl']['origUid'] === $field) { // Allow value for original UID to pass by...

} // Checking language.

} // Check exclude fields / disabled fields...

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);

$types_fieldConfig = t3lib_BEfunc::getTCAtypes($table, $currentRecord);