PHP t3lib_BEfunc::getTCAtypes方法代码示例

 /**
  * This function performs processing on the input $row array and stores internally a corresponding array which contains processed values, ready to pass on to the TCEforms rendering in the frontend!
  * The objective with this function is to prepare the content for handling in TCEforms.
  * In opposite to renderRecord() this function do not prepare things like fetching TSconfig and others.
  * The resulting, processed row will be returned.
  *
  * @param	string		The table name
  * @param	string		The uid value of the record (integer). Can also be a string (NEW-something) if the record is a NEW record.
  * @param	integer		The pid integer. For existing records this is of course the row's "pid" field. For new records it can be either a page id (positive) or a pointer to another record from the SAME table (negative) after which the record should be inserted (or on same page)
  * @param	array		The row of the current record. If NEW record, then it may be loaded with default values (by eg. fetchRecord()).
  * @param	array		Tsconfig array
  * @param	integer		PAGE TSconfig pid
  * @return	array		Processed record data
  * @see renderRecord()
  */
 function renderRecordRaw($table, $id, $pid, $row, $TSconfig = '', $tscPID = 0)
 {
     global $TCA;
     if (!is_array($TSconfig)) {
         $TSconfig = array();
     }
     // Create blank accumulation array:
     $totalRecordContent = array();
     // Traverse the configured columns for the table (TCA):
     // For each column configured, we will perform processing if needed based on the type (eg. for "group" and "select" types this is needed)
     t3lib_div::loadTCA($table);
     $copyOfColumns = $TCA[$table]['columns'];
     foreach ($copyOfColumns as $field => $fieldConfig) {
         // Set $data variable for the field, either inputted value from $row - or if not found, the default value as defined in the "config" array
         if (isset($row[$field])) {
             $data = $row[$field];
         } else {
             $data = $fieldConfig['config']['default'];
         }
         $data = $this->renderRecord_SW($data, $fieldConfig, $TSconfig, $table, $row, $field);
         // Set the field in the accumulation array IF the $data variabel is set:
         $totalRecordContent[$field] = isset($data) ? $data : '';
     }
     // Further processing may apply for each field in the record depending on the settings in the "types" configuration (the list of fields to currently display for a record in TCEforms).
     // For instance this could be processing instructions for the Rich Text Editor.
     $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table, $totalRecordContent);
     if (is_array($types_fieldConfig)) {
         $totalRecordContent = $this->renderRecord_typesProc($totalRecordContent, $types_fieldConfig, $tscPID, $table, $pid);
     }
     // Register items, mostly for external use (overriding the regItem() function)
     foreach ($totalRecordContent as $field => $data) {
         $this->regItem($table, $id, $field, $data);
     }
     // Finally, store the result:
     reset($totalRecordContent);
     return $totalRecordContent;
 }

//.........这里部分代码省略.........
                     case 't3ver_wsid':
                     case 't3ver_state':
                     case 't3ver_swapmode':
                     case 't3ver_count':
                     case 't3ver_stage':
                     case 't3ver_tstamp':
                         // t3ver_label is not here because it CAN be edited as a regular field!
                         break;
                     default:
                         if (isset($TCA[$table]['columns'][$field])) {
                             // Evaluating the value
                             $res = $this->checkValue($table, $field, $fieldValue, $id, $status, $realPid, $tscPID);
                             if (isset($res['value'])) {
                                 $fieldArray[$field] = $res['value'];
                             }
                             // Add the value of the original record to the diff-storage content:
                             if ($this->updateModeL10NdiffData && $TCA[$table]['ctrl']['transOrigDiffSourceField']) {
                                 $originalLanguage_diffStorage[$field] = $this->updateModeL10NdiffDataClear ? '' : $originalLanguageRecord[$field];
                                 $diffStorageFlag = TRUE;
                             }
                             // If autoversioning is happening we need to perform a nasty hack. The case is parallel to a similar hack inside checkValue_group_select_file().
                             // When a copy or version is made of a record, a search is made for any RTEmagic* images in fields having the "images" soft reference parser applied. That should be true for RTE fields. If any are found they are duplicated to new names and the file reference in the bodytext is updated accordingly.
                             // However, with auto-versioning the submitted content of the field will just overwrite the corrected values. This leaves a) lost RTEmagic files and b) creates a double reference to the old files.
                             // The only solution I can come up with is detecting when auto versioning happens, then see if any RTEmagic images was copied and if so make a stupid string-replace of the content !
                             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...
                             $fieldArray[$field] = $fieldValue;
                         }
                         break;
                 }
             }
             // Checking language.
         }
         // Check exclude fields / disabled fields...
     }
     // Add diff-storage information:
     if ($diffStorageFlag && !isset($fieldArray[$TCA[$table]['ctrl']['transOrigDiffSourceField']])) {
         // If the field is set it would probably be because of an undo-operation - in which case we should not update the field of course...
         $fieldArray[$TCA[$table]['ctrl']['transOrigDiffSourceField']] = serialize($originalLanguage_diffStorage);
     }
     // Checking for RTE-transformations of fields:
     $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table, $currentRecord);
     $theTypeString = t3lib_BEfunc::getTCAtypeValue($table, $currentRecord);
     if (is_array($types_fieldConfig)) {
         foreach ($types_fieldConfig as $vconf) {
             // Write file configuration:
             $eFile = t3lib_parsehtml_proc::evalWriteFile($vconf['spec']['static_write'], array_merge($currentRecord, $fieldArray));
             // inserted array_merge($currentRecord,$fieldArray) 170502
             // RTE transformations:
             if (!$this->dontProcessTransformations) {
                 if (isset($fieldArray[$vconf['field']])) {
                     // Look for transformation flag:
                     switch ((string) $incomingFieldArray['_TRANSFORM_' . $vconf['field']]) {
                         case 'RTE':
                             $RTEsetup = $this->BE_USER->getTSConfig('RTE', t3lib_BEfunc::getPagesTSconfig($tscPID));
                             $thisConfig = t3lib_BEfunc::RTEsetup($RTEsetup['properties'], $table, $vconf['field'], $theTypeString);
                             // Set alternative relative path for RTE images/links:
                             $RTErelPath = is_array($eFile) ? dirname($eFile['relEditFile']) : '';
                             // Get RTE object, draw form and set flag:
                             $RTEobj = t3lib_BEfunc::RTEgetObj();
                             if (is_object($RTEobj)) {
                                 $fieldArray[$vconf['field']] = $RTEobj->transformContent('db', $fieldArray[$vconf['field']], $table, $vconf['field'], $currentRecord, $vconf['spec'], $thisConfig, $RTErelPath, $currentRecord['pid']);
                             } else {
                                 debug('NO RTE OBJECT FOUND!');
                             }
                             break;
                     }
                 }
             }
             // Write file configuration:
             if (is_array($eFile)) {
                 $mixedRec = array_merge($currentRecord, $fieldArray);
                 $SW_fileContent = t3lib_div::getUrl($eFile['editFile']);
                 $parseHTML = t3lib_div::makeInstance('t3lib_parsehtml_proc');
                 /* @var $parseHTML t3lib_parsehtml_proc */
                 $parseHTML->init('', '');
                 $eFileMarker = $eFile['markerField'] && trim($mixedRec[$eFile['markerField']]) ? trim($mixedRec[$eFile['markerField']]) : '###TYPO3_STATICFILE_EDIT###';
                 $insertContent = str_replace($eFileMarker, '', $mixedRec[$eFile['contentField']]);
                 // must replace the marker if present in content!
                 $SW_fileNewContent = $parseHTML->substituteSubpart($SW_fileContent, $eFileMarker, LF . $insertContent . LF, 1, 1);
                 t3lib_div::writeFile($eFile['editFile'], $SW_fileNewContent);
                 // Write status:
                 if (!strstr($id, 'NEW') && $eFile['statusField']) {
                     $GLOBALS['TYPO3_DB']->exec_UPDATEquery($table, 'uid=' . intval($id), array($eFile['statusField'] => $eFile['relEditFile'] . ' updated ' . date('d-m-Y H:i:s') . ', bytes ' . strlen($mixedRec[$eFile['contentField']])));
                 }
             } elseif ($eFile && is_string($eFile)) {
                 $this->log($table, $id, 2, 0, 1, "Write-file error: '%s'", 13, array($eFile), $realPid);
             }
         }
     }
     // Return fieldArray
     return $fieldArray;
 }

 /**
  * Check if the field is an RTE in the Backend, for a given row of data
  *
  * @param  string  $key          Key is a combination of table, uid, field and structure path, identifying the field
  * @param  array   $TCEformsCfg  TCA configuration for field
  * @param  array   $contentRow   The table row being handled
  * @return boolean
  */
 protected function _isRTEField($key, $TCEformsCfg, $contentRow)
 {
     $isRTE = FALSE;
     if (is_array($contentRow)) {
         list($table, $uid, $field) = explode(':', $key);
         // Check if the RTE is explicitly declared in the defaultExtras configuration
         if (isset($TCEformsCfg['defaultExtras']) && strpos($TCEformsCfg['defaultExtras'], 'richtext') !== FALSE) {
             $isRTE = TRUE;
             // If not, then we must check per type configuration
         } else {
             $typesDefinition = t3lib_BEfunc::getTCAtypes($table, $contentRow, TRUE);
             $isRTE = !empty($typesDefinition[$field]['spec']['richtext']);
         }
     }
     return $isRTE;
 }

 /**
  * Returns "special" configuration from the "types" configuration in TCA for the record given by tablename/fieldname.
  * Used by isRTEforField() in the process of finding whether a field has RTE enabled or not.
  *
  * @param	string		Table name
  * @param	array		Record array
  * @param	string		Field name
  * @return	array		Spec. conf (if available)
  * @access private
  * @see isRTEforField()
  */
 function getSpecConfForField($table, $row, $field)
 {
     // Get types-configuration for the record:
     $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table, $row);
     // Find the given field and return the spec key value if found:
     if (is_array($types_fieldConfig)) {
         foreach ($types_fieldConfig as $vconf) {
             if ($vconf['field'] == $field) {
                 return $vconf['spec'];
             }
         }
     }
 }

 /**
  * Returns the "special" configuration (from the "types" "showitem" list) for a fieldname based on input table/record
  * (Not used anywhere...?)
  *
  * @param	string		The table name
  * @param	array		The table row (Should at least contain the "uid" value, even if "NEW..." string. The "pid" field is important as well, and negative values will be intepreted as pointing to a record from the same table.)
  * @param	string		Specify the field name.
  * @return	array
  * @see getSpecConfFromString(), t3lib_BEfunc::getTCAtypes()
  */
 function getSpecConfForField($table, $row, $field)
 {
     // Finds the current "types" configuration for the table/row:
     $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table, $row);
     // If this is an array, then traverse it:
     if (is_array($types_fieldConfig)) {
         foreach ($types_fieldConfig as $vconf) {
             // If the input field name matches one found in the 'types' list, then return the 'special' configuration.
             if ($vconf['field'] == $field) {
                 return $vconf['spec'];
             }
         }
     }
 }