/src/typo3_src-4.2.0alpha1/t3lib/class.t3lib_refindex.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2006 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
require_once(PATH_t3lib.'class.t3lib_tcemain.php');
require_once(PATH_t3lib.'class.t3lib_flexformtools.php');
//require_once(PATH_typo3.'sysext/indexed_search/class.lexer.php'); // Disabled until Kasper finishes this feature. Apart from that, t3lib classes should never require stuff from extensions.



class t3lib_refindex {

        var $temp_flexRelations = array();
        var $errorLog = array();
        var $WSOL = FALSE;
        var $relations = array();

        var $words_strings = array();
        var $words = array();

        var $hashVersion = 1;   // Number which we can increase if a change in the code means we will have to force a re-generation of the index.


        function updateRefIndexTable($table,$uid,$testOnly=FALSE)       {

                        // First, secure that the index table is not updated with workspace tainted relations:
                $this->WSOL = FALSE;

                        // Init:
                $result = array(
                        'keptNodes' => 0,
                        'deletedNodes' => 0,
                        'addedNodes' => 0
                );

                        // Get current index from Database:
                $currentRels = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows(
                        '*',
                        'sys_refindex',
                        'tablename='.$GLOBALS['TYPO3_DB']->fullQuoteStr($table,'sys_refindex').
                                ' AND recuid='.intval($uid),
                        '','','','hash'
                );

                        // First, test to see if the record exists (including deleted-flagged)
                if (t3lib_BEfunc::getRecordRaw($table,'uid='.intval($uid),'uid'))       {

                                // Then, get relations:
                        $relations = $this->generateRefIndexData($table,$uid);

                        if (is_array($relations))       {

                                        // Traverse the generated index:
                                foreach($relations as $k => $datRec)    {
                                        $relations[$k]['hash'] = md5(implode('

                                                // First, check if already indexed and if so, unset that row (so in the end we know which rows to remove!)
                                        if (isset($currentRels[$relations[$k]['hash']]))        {
                                                unset($currentRels[$relations[$k]['hash']]);
                                                $result['keptNodes']++;
                                                $relations[$k]['_ACTION'] = 'KEPT';
                                        } else {
                                                        // If new, add it:
                                                if (!$testOnly) $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_refindex',$relations[$k]);
                                                $result['addedNodes']++;
                                                $relations[$k]['_ACTION'] = 'ADDED';
                                        }
                                }

                                $result['relations'] = $relations;
                        } else return FALSE;    // Weird mistake I would say...

                                // Words:
                        if (!$testOnly) $this->wordIndexing($table,$uid);
                }

                        // If any old are left, remove them:
                if (count($currentRels))        {
                        $hashList = array_keys($currentRels);
                        if (count($hashList))   {
                                $result['deletedNodes'] = count($hashList);
                                $result['deletedNodes_hashList'] = implode(',',$hashList);
                                if (!$testOnly) $GLOBALS['TYPO3_DB']->exec_DELETEquery('sys_refindex','hash IN ('.implode(',',$GLOBALS['TYPO3_DB']->fullQuoteArray($hashList,'sys_refindex')).')');
                        }
                }

                return $result;
        }

        function generateRefIndexData($table,$uid)      {
                global $TCA;

                if (isset($TCA[$table]))        {
                                // Get raw record from DB:
                        list($record) = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows('*',$table,'uid='.intval($uid));

                        if (is_array($record))  {

                                        // Initialize:
                                $this->words_strings = array();
                                $this->words = array();

                                        // Deleted:
                                $deleted = $TCA[$table]['ctrl']['delete'] ? ($record[$TCA[$table]['ctrl']['delete']]?1:0) : 0;

                                        // Get all relations from record:
                                $dbrels = $this->getRelations($table,$record);

                                        // Traverse those relations, compile records to insert in table:
                                $this->relations = array();
                                foreach($dbrels as $fieldname => $dat)  {

                                                // Based on type,
                                        switch((string)$dat['type'])    {
                                                case 'db':
                                                        $this->createEntryData_dbRels($table,$uid,$fieldname,'',$deleted,$dat['itemArray']);
                                                break;
                                                case 'file':
                                                        $this->createEntryData_fileRels($table,$uid,$fieldname,'',$deleted,$dat['newValueFiles']);
                                                break;
                                                case 'flex':
                                                                // DB references:
                                                        if (is_array($dat['flexFormRels']['db']))       {
                                                                foreach($dat['flexFormRels']['db'] as $flexpointer => $subList) {
                                                                        $this->createEntryData_dbRels($table,$uid,$fieldname,$flexpointer,$deleted,$subList);
                                                                }
                                                        }
                                                                // File references (NOT TESTED!)
                                                        if (is_array($dat['flexFormRels']['file']))     {       // Not tested
                                                                foreach($dat['flexFormRels']['file'] as $flexpointer => $subList)       {
                                                                        $this->createEntryData_fileRels($table,$uid,$fieldname,$flexpointer,$deleted,$subList);
                                                                }
                                                        }
                                                                // Soft references in flexforms (NOT TESTED!)
                                                        if (is_array($dat['flexFormRels']['softrefs'])) {
                                                                foreach($dat['flexFormRels']['softrefs'] as $flexpointer => $subList)   {
                                                                        $this->createEntryData_softreferences($table,$uid,$fieldname,$flexpointer,$deleted,$subList['keys']);
                                                                }
                                                        }
                                                break;
                                        }

                                                // Softreferences in the field:
                                        if (is_array($dat['softrefs'])) {
                                                $this->createEntryData_softreferences($table,$uid,$fieldname,'',$deleted,$dat['softrefs']['keys']);
                                        }
                                }

                                        // Word indexing:
                                t3lib_div::loadTCA($table);
                                foreach($TCA[$table]['columns'] as $field => $conf)     {
                                        if (t3lib_div::inList('input,text',$conf['config']['type']) && strcmp($record[$field],'') && !t3lib_div::testInt($record[$field])) {
                                                $this->words_strings[$field] = $record[$field];
                                        }
                                }

                                return $this->relations;
                        }
                }
        }

        function createEntryData($table,$uid,$field,$flexpointer,$deleted,$ref_table,$ref_uid,$ref_string='',$sort=-1,$softref_key='',$softref_id='')   {
                return array(
                        'tablename' => $table,
                        'recuid' => $uid,
                        'field' => $field,
                        'flexpointer' => $flexpointer,
                        'softref_key' => $softref_key,
                        'softref_id' => $softref_id,
                        'sorting' => $sort,
                        'deleted' => $deleted,
                        'ref_table' => $ref_table,
                        'ref_uid' => $ref_uid,
                        'ref_string' => $ref_string,
                );
        }

        function createEntryData_dbRels($table,$uid,$fieldname,$flexpointer,$deleted,$items)    {
                foreach($items as $sort => $i)  {
                        $this->relations[] = $this->createEntryData($table,$uid,$fieldname,$flexpointer,$deleted,$i['table'],$i['id'],'',$sort);
                }
        }

        function createEntryData_fileRels($table,$uid,$fieldname,$flexpointer,$deleted,$items)  {
                foreach($items as $sort => $i)  {
                        $filePath = $i['ID_absFile'];
                        if (t3lib_div::isFirstPartOfStr($filePath,PATH_site))   {
                                $filePath = substr($filePath,strlen(PATH_site));
                        }
                        $this->relations[] = $this->createEntryData($table,$uid,$fieldname,$flexpointer,$deleted,'_FILE',0,$filePath,$sort);
                }
        }

        function createEntryData_softreferences($table,$uid,$fieldname,$flexpointer,$deleted,$keys)     {
                if (is_array($keys))    {
                        foreach($keys as $spKey => $elements)   {
                                if (is_array($elements))        {
                                        foreach($elements as $subKey => $el)    {
                                                if (is_array($el['subst']))     {
                                                        switch((string)$el['subst']['type'])    {
                                                                 case 'db':
                                                                        list($tableName,$recordId) = explode(':',$el['subst']['recordRef']);
                                                                        $this->relations[] = $this->createEntryData($table,$uid,$fieldname,$flexpointer,$deleted,$tableName,$recordId,'',-1,$spKey,$subKey);
                                                                 break;
                                                                 case 'file':
                                                                        $this->relations[] = $this->createEntryData($table,$uid,$fieldname,$flexpointer,$deleted,'_FILE',0,$el['subst']['relFileName'],-1,$spKey,$subKey);
                                                                 break;
                                                                 case 'string':
                                                                        $this->relations[] = $this->createEntryData($table,$uid,$fieldname,$flexpointer,$deleted,'_STRING',0,$el['subst']['tokenValue'],-1,$spKey,$subKey);
                                                                 break;
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }















        /*******************************
         *
         * Get relations from table row
         *
         *******************************/

        function getRelations($table,$row,$onlyField='')        {
                global $TCA;

                        // Load full table description
                t3lib_div::loadTCA($table);

                        // Initialize:
                $uid = $row['uid'];
                $nonFields = explode(',','uid,perms_userid,perms_groupid,perms_user,perms_group,perms_everybody,pid');

                $outRow = array();
                foreach($row as $field => $value)       {
                        if (!in_array($field,$nonFields) && is_array($TCA[$table]['columns'][$field]) && (!$onlyField || $onlyField===$field))  {
                                $conf = $TCA[$table]['columns'][$field]['config'];

                                        // Add files
                                if ($result = $this->getRelations_procFiles($value, $conf, $uid))       {
                                                // Creates an entry for the field with all the files:
                                        $outRow[$field] = array(
                                                'type' => 'file',
                                                'newValueFiles' => $result,
                                        );
                                }

                                        // Add DB:
                                if ($result = $this->getRelations_procDB($value, $conf, $uid, $table))  {
                                                // Create an entry for the field with all DB relations:
                                        $outRow[$field] = array(
                                                'type' => 'db',
                                                'itemArray' => $result,
                                        );
                                }

                                        // For "flex" fieldtypes we need to traverse the structure looking for file and db references of course!
                                if ($conf['type']=='flex')      {

                                                // Get current value array:
                                                // NOTICE: failure to resolve Data Structures can lead to integrity problems with the reference index. Please look up the note in the JavaDoc documentation for the function t3lib_BEfunc::getFlexFormDS()
                                        $dataStructArray = t3lib_BEfunc::getFlexFormDS($conf, $row, $table,'',$this->WSOL);
                                        $currentValueArray = t3lib_div::xml2array($value);

                                                // Traversing the XML structure, processing files:
                                        if (is_array($currentValueArray))       {
                                                $this->temp_flexRelations = array(
                                                        'db' => array(),
                                                        'file' => array(),
                                                        'softrefs' => array()
                                                );

                                                        // Create and call iterator object:
                                                $flexObj = t3lib_div::makeInstance('t3lib_flexformtools');
                                                $flexObj->traverseFlexFormXMLData($table,$field,$row,$this,'getRelations_flexFormCallBack');

                                                        // Create an entry for the field:
                                                $outRow[$field] = array(
                                                        'type' => 'flex',
                                                        'flexFormRels' => $this->temp_flexRelations,
                                                );
                                        }
                                }

                                        // Soft References:
                                if (strlen($value) && $softRefs = t3lib_BEfunc::explodeSoftRefParserList($conf['softref']))     {
                                        $softRefValue = $value;
                                        foreach($softRefs as $spKey => $spParams)       {
                                                $softRefObj = &t3lib_BEfunc::softRefParserObj($spKey);
                                                if (is_object($softRefObj))     {
                                                        $resultArray = $softRefObj->findRef($table, $field, $uid, $softRefValue, $spKey, $spParams);
                                                        if (is_array($resultArray))     {
                                                                $outRow[$field]['softrefs']['keys'][$spKey] = $resultArray['elements'];
                                                                if (strlen($resultArray['content'])) {
                                                                        $softRefValue = $resultArray['content'];
                                                                }
                                                        }
                                                }
                                        }

                                        if (is_array($outRow[$field]['softrefs']) && count($outRow[$field]['softrefs']) && strcmp($value,$softRefValue) && strstr($softRefValue,'{softref:'))   {
                                                $outRow[$field]['softrefs']['tokenizedContent'] = $softRefValue;
                                        }
                                }
                        }
                }

                return $outRow;
        }

        function getRelations_flexFormCallBack($dsArr, $dataValue, $PA, $structurePath, &$pObj) {
                $structurePath = substr($structurePath,5).'/';  // removing "data/" in the beginning of path (which points to location in data array)

                $dsConf = $dsArr['TCEforms']['config'];

                        // Implode parameter values:
                list($table, $uid, $field) = array($PA['table'],$PA['uid'],$PA['field']);

                        // Add files
                if ($result = $this->getRelations_procFiles($dataValue, $dsConf, $uid)) {

                                // Creates an entry for the field with all the files:
                        $this->temp_flexRelations['file'][$structurePath] = $result;
                }

                        // Add DB:
                if ($result = $this->getRelations_procDB($dataValue, $dsConf, $uid))    {

                                // Create an entry for the field with all DB relations:
                        $this->temp_flexRelations['db'][$structurePath] = $result;
                }

                        // Soft References:
                if (strlen($dataValue) && $softRefs = t3lib_BEfunc::explodeSoftRefParserList($dsConf['softref']))       {
                        $softRefValue = $dataValue;
                        foreach($softRefs as $spKey => $spParams)       {
                                $softRefObj = &t3lib_BEfunc::softRefParserObj($spKey);
                                if (is_object($softRefObj))     {
                                        $resultArray = $softRefObj->findRef($table, $field, $uid, $softRefValue, $spKey, $spParams, $structurePath);
                                        if (is_array($resultArray) && is_array($resultArray['elements']))       {
                                                $this->temp_flexRelations['softrefs'][$structurePath]['keys'][$spKey] = $resultArray['elements'];
                                                if (strlen($resultArray['content'])) $softRefValue = $resultArray['content'];
                                        }
                                }
                        }

                        if (count($this->temp_flexRelations['softrefs']) && strcmp($dataValue,$softRefValue))   {
                                $this->temp_flexRelations['softrefs'][$structurePath]['tokenizedContent'] = $softRefValue;
                        }
                }
        }

        function getRelations_procFiles($value, $conf, $uid)    {
                        // Take care of files...
                if ($conf['type']=='group' && $conf['internal_type']=='file')   {

                                // Collect file values in array:
                        if ($conf['MM'])        {
                                $theFileValues = array();
                                $dbAnalysis = t3lib_div::makeInstance('t3lib_loadDBGroup');
                                $dbAnalysis->start('', 'files', $conf['MM'], $uid);

                                foreach($dbAnalysis->itemArray as $somekey => $someval) {
                                        if ($someval['id'])     {
                                                $theFileValues[] = $someval['id'];
                                        }
                                }
                        } else {
                                $theFileValues = explode(',',$value);
                        }

                                // Traverse the files and add them:
                        $uploadFolder = $conf['uploadfolder'];
                        $dest = $this->destPathFromUploadFolder($uploadFolder);
                        $newValue = array();
                        $newValueFiles = array();

                        foreach($theFileValues as $file)        {
                                if (trim($file))        {
                                        $realFile = $dest.'/'.trim($file);
#                                       if (@is_file($realFile))        {               // Now, the refernece index should NOT look if files exist - just faithfully include them if they are in the records!
                                                $newValueFiles[] = array(
                                                        'filename' => $file,
                                                        'ID' => md5($realFile),
                                                        'ID_absFile' => $realFile
                                                );      // the order should be preserved here because.. (?)
#                                       } else $this->error('Missing file: '.$realFile);
                                }
                        }

                        return $newValueFiles;
                }
        }

        function getRelations_procDB($value, $conf, $uid, $table = '')  {

                        // DB record lists:
                if ($this->isReferenceField($conf))     {
                        $allowedTables = $conf['type']=='group' ? $conf['allowed'] : $conf['foreign_table'].','.$conf['neg_foreign_table'];
                        $prependName = $conf['type']=='group' ? $conf['prepend_tname'] : $conf['neg_foreign_table'];

                        if($conf['MM_opposite_field']) {
                                return array();
                        }

                        $dbAnalysis = t3lib_div::makeInstance('t3lib_loadDBGroup');
                        $dbAnalysis->start($value,$allowedTables,$conf['MM'],$uid,$table,$conf);

                        return $dbAnalysis->itemArray;
                }
        }












        /*******************************
         *
         * Setting values
         *
         *******************************/

        function setReferenceValue($hash,$newValue,$returnDataArray=FALSE,$bypassWorkspaceAdminCheck=FALSE)     {

                if (($GLOBALS['BE_USER']->workspace===0 && $GLOBALS['BE_USER']->isAdmin()) || $bypassWorkspaceAdminCheck)       {

                                // Get current index from Database:
                        list($refRec) = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows(
                                '*',
                                'sys_refindex',
                                'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($hash,'sys_refindex')
                        );

                                // Check if reference existed.
                        if (is_array($refRec))  {
                                if ($GLOBALS['TCA'][$refRec['tablename']])      {

                                                // Get that record from database:
                                        list($record) = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows('*',$refRec['tablename'],'uid='.intval($refRec['recuid']));

                                        if (is_array($record))  {

                                                        // Get all relations from record, filter with fieldname:
                                                $dbrels = $this->getRelations($refRec['tablename'],$record,$refRec['field']);
                                                if ($dat = $dbrels[$refRec['field']])   {

                                                                // Initialize data array that is to be sent to TCEmain afterwards:
                                                        $dataArray = array();

                                                                // Based on type,
                                                        switch((string)$dat['type'])    {
                                                                case 'db':
                                                                        $error = $this->setReferenceValue_dbRels($refRec,$dat['itemArray'],$newValue,$dataArray);
                                                                        if ($error)     return $error;
                                                                break;
                                                                case 'file':
                                                                        $this->setReferenceValue_fileRels($refRec,$dat['newValueFiles'],$newValue,$dataArray);
                                                                        if ($error)     return $error;
                                                                break;
                                                                case 'flex':
                                                                                // DB references:
                                                                        if (is_array($dat['flexFormRels']['db'][$refRec['flexpointer']]))       {
                                                                                $error = $this->setReferenceValue_dbRels($refRec,$dat['flexFormRels']['db'][$refRec['flexpointer']],$newValue,$dataArray,$refRec['flexpointer']);
                                                                                if ($error)     return $error;
                                                                        }
                                                                                // File references
                                                                        if (is_array($dat['flexFormRels']['file'][$refRec['flexpointer']]))     {
                                                                                $this->setReferenceValue_fileRels($refRec,$dat['flexFormRels']['file'][$refRec['flexpointer']],$newValue,$dataArray,$refRec['flexpointer']);
                                                                                if ($error)     return $error;
                                                                        }
                                                                                // Soft references in flexforms
                                                                        if ($refRec['softref_key'] && is_array($dat['flexFormRels']['softrefs'][$refRec['flexpointer']]['keys'][$refRec['softref_key']]))       {
                                                                                $error = $this->setReferenceValue_softreferences($refRec,$dat['flexFormRels']['softrefs'][$refRec['flexpointer']],$newValue,$dataArray,$refRec['flexpointer']);
                                                                                if ($error)     return $error;
                                                                        }
                                                                break;
                                                        }

                                                                // Softreferences in the field:
                                                        if ($refRec['softref_key'] && is_array($dat['softrefs']['keys'][$refRec['softref_key']]))       {
                                                                $error = $this->setReferenceValue_softreferences($refRec,$dat['softrefs'],$newValue,$dataArray);
                                                                if ($error)     return $error;

                                                        }

                                                                // Data Array, now ready to sent to TCEmain
                                                        if ($returnDataArray)   {
                                                                return $dataArray;
                                                        } else {
                
                                                                        // Execute CMD array:
                                                                $tce = t3lib_div::makeInstance('t3lib_TCEmain');
                                                                $tce->stripslashes_values = FALSE;
                                                                $tce->dontProcessTransformations = TRUE;
                                                                $tce->bypassWorkspaceRestrictions = TRUE;
                                                                $tce->bypassFileHandling = TRUE;
                                                                $tce->bypassAccessCheckForRecords = TRUE;       // Otherwise this cannot update things in deleted records...

                                                                $tce->start($dataArray,array());        // check has been done previously that there is a backend user which is Admin and also in live workspace
                                                                $tce->process_datamap();

                                                                        // Return errors if any:
                                                                if (count($tce->errorLog))      {
                                                                        return chr(10).'TCEmain:'.implode(chr(10).'TCEmain:',$tce->errorLog);
                                                                }
                                                        }
                                                }
                                        }
                                } else return 'ERROR: Tablename "'.$refRec['tablename'].'" was not in TCA!';
                        } else return 'ERROR: No reference record with hash="'.$hash.'" was found!';
                } else return 'ERROR: BE_USER object is not admin OR not in workspace 0 (Live)';
        }

        function setReferenceValue_dbRels($refRec,$itemArray,$newValue,&$dataArray,$flexpointer='')     {
                if (!strcmp($itemArray[$refRec['sorting']]['id'],$refRec['ref_uid']) && !strcmp($itemArray[$refRec['sorting']]['table'],$refRec['ref_table']))  {

                                // Setting or removing value:
                        if ($newValue===NULL)   {       // Remove value:
                                unset($itemArray[$refRec['sorting']]);
                        } else {
                                list($itemArray[$refRec['sorting']]['table'],$itemArray[$refRec['sorting']]['id']) = explode(':',$newValue);
                        }

                                // Traverse and compile new list of records:
                        $saveValue = array();
                        foreach($itemArray as $pair)    {
                                $saveValue[] = $pair['table'].'_'.$pair['id'];
                        }

                                // Set in data array:
                        if ($flexpointer)       {
                                $flexToolObj = t3lib_div::makeInstance('t3lib_flexformtools');
                                $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'] = array();
                                $flexToolObj->setArrayValueByPath(substr($flexpointer,0,-1),$dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'],implode(',',$saveValue));
                        } else {
                                $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']] = implode(',',$saveValue);
                        }

                } else return 'ERROR: table:id pair "'.$refRec['ref_table'].':'.$refRec['ref_uid'].'" did not match that of the record ("'.$itemArray[$refRec['sorting']]['table'].':'.$itemArray[$refRec['sorting']]['id'].'") in sorting index "'.$refRec['sorting'].'"';
        }

        function setReferenceValue_fileRels($refRec,$itemArray,$newValue,&$dataArray,$flexpointer='')   {
                if (!strcmp(substr($itemArray[$refRec['sorting']]['ID_absFile'],strlen(PATH_site)),$refRec['ref_string']) && !strcmp('_FILE',$refRec['ref_table']))     {

                                // Setting or removing value:
                        if ($newValue===NULL)   {       // Remove value:
                                unset($itemArray[$refRec['sorting']]);
                        } else {
                                $itemArray[$refRec['sorting']]['filename'] = $newValue;
                        }

                                // Traverse and compile new list of records:
                        $saveValue = array();
                        foreach($itemArray as $fileInfo)        {
                                $saveValue[] = $fileInfo['filename'];
                        }

                                // Set in data array:
                        if ($flexpointer)       {
                                $flexToolObj = t3lib_div::makeInstance('t3lib_flexformtools');
                                $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'] = array();
                                $flexToolObj->setArrayValueByPath(substr($flexpointer,0,-1),$dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'],implode(',',$saveValue));
                        } else {
                                $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']] = implode(',',$saveValue);
                        }

                } else return 'ERROR: either "'.$refRec['ref_table'].'" was not "_FILE" or file PATH_site+"'.$refRec['ref_string'].'" did not match that of the record ("'.$itemArray[$refRec['sorting']]['ID_absFile'].'") in sorting index "'.$refRec['sorting'].'"';
        }

        function setReferenceValue_softreferences($refRec,$softref,$newValue,&$dataArray,$flexpointer='')       {
                if (is_array($softref['keys'][$refRec['softref_key']][$refRec['softref_id']]))  {

                                // Set new value:
                        $softref['keys'][$refRec['softref_key']][$refRec['softref_id']]['subst']['tokenValue'] = ''.$newValue;

                                // Traverse softreferences and replace in tokenized content to rebuild it with new value inside:
                        foreach($softref['keys'] as $sfIndexes) {
                                foreach($sfIndexes as $data)    {
                                        $softref['tokenizedContent'] = str_replace('{softref:'.$data['subst']['tokenID'].'}', $data['subst']['tokenValue'], $softref['tokenizedContent']);
                                }
                        }

                                // Set in data array:
                        if (!strstr($softref['tokenizedContent'],'{softref:'))  {
                                if ($flexpointer)       {
                                        $flexToolObj = t3lib_div::makeInstance('t3lib_flexformtools');
                                        $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'] = array();
                                        $flexToolObj->setArrayValueByPath(substr($flexpointer,0,-1),$dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']]['data'],$softref['tokenizedContent']);
                                } else {
                                        $dataArray[$refRec['tablename']][$refRec['recuid']][$refRec['field']] = $softref['tokenizedContent'];
                                }
                        } else return 'ERROR: After substituting all found soft references there were still soft reference tokens in the text. (theoretically this does not have to be an error if the string "{softref:" happens to be in the field for another reason.)';
                } else return 'ERROR: Soft reference parser key "'.$refRec['softref_key'].'" or the index "'.$refRec['softref_id'].'" was not found.';
        }










        /*******************************
         *
         * Indexing words
         *
         *******************************/

        function wordIndexing($table,$uid)      {
                return; // Disabled until Kasper finishes this feature. If someone else needs it in the meantime you are welcome to complete it. Below my todo list.
                
                // TODO:
                // - Flag to disable indexing
                // - Clean-up to remove words not used anymore  and indexes for records not in the system anymore.
                // - UTF-8 compliant substr()
                $lexer = t3lib_div::makeInstance('tx_indexedsearch_lexer');
                $words = $lexer->split2Words(implode(' ',$this->words_strings));
                foreach($words as $w) {
                        $words[]=substr($w,0,3);
                }
                $words = array_unique($words);
                $this->updateWordIndex($words,$table,$uid);
        }

        function updateWordIndex($words,$table,$uid) {

                        // Submit words to
                $this->submitWords($words);

                        // Result id and remove relations:
                $rid = t3lib_div::md5int($table.':'.$uid);
                $GLOBALS['TYPO3_DB']->exec_DELETEquery('sys_refindex_rel', 'rid='.intval($rid));

                        // Add relations:
                foreach($words as $w)   {
                        $insertFields = array(
                                'rid' => $rid,
                                'wid' => t3lib_div::md5int($w)
                        );

                        $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_refindex_rel', $insertFields);
                }

                        // Add result record:
                $GLOBALS['TYPO3_DB']->exec_DELETEquery('sys_refindex_res', 'rid='.intval($rid));
                $insertFields = array(
                        'rid' => $rid,
                        'tablename' => $table,
                        'recuid' => $uid
                );
                $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_refindex_res', $insertFields);
        }

        function submitWords($wl) {

                $hashArr = array();
                foreach($wl as $w)      {
                        $hashArr[] = t3lib_div::md5int($w);
                }
                $wl = array_flip($wl);

                if (count($hashArr))    {
                        $cwl = implode(',',$hashArr);
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('baseword', 'sys_refindex_words', 'wid IN ('.$cwl.')');

                        if($GLOBALS['TYPO3_DB']->sql_num_rows($res)!=count($wl)) {
                                while($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                        unset($wl[$row['baseword']]);
                                }

                                reset($wl);
                                while(list($key,$val)=each($wl)) {
                                        $insertFields = array(
                                                'wid' => t3lib_div::md5int($key),
                                                'baseword' => $key
                                        );

                                                // A duplicate-key error will occur here if a word is NOT unset in the unset() line. However as long as the words in $wl are NOT longer as 60 chars (the baseword varchar is 60 characters...) this is not a problem.
                                        $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_refindex_words', $insertFields);
                                }
                        }
                }
        }







        /*******************************
         *
         * Helper functions
         *
         *******************************/

        function isReferenceField($conf)        {
                return ($conf['type']=='group' && $conf['internal_type']=='db') || (($conf['type']=='select' || $conf['type']=='inline') && $conf['foreign_table']);
        }

        function destPathFromUploadFolder($folder)      {
                return PATH_site.$folder;
        }

        function error($msg)    {
                $this->errorLog[]=$msg;
        }

        function updateIndex($testOnly,$cli_echo=FALSE) {
                global $TCA, $TYPO3_DB;

                $errors = array();
                $tableNames = array();
                $recCount=0;
                $tableCount=0;

                $headerContent = $testOnly ? 'Reference Index being TESTED (nothing written, use "-e" to update)' : 'Reference Index being Updated';
                if ($cli_echo) echo
                                                '*******************************************'.chr(10).
                                                $headerContent.chr(10).
                                                '*******************************************'.chr(10);

                        // Traverse all tables:
                foreach ($TCA as $tableName => $cfg)    {
                        $tableNames[] = $tableName;
                        $tableCount++;

                                // Traverse all records in tables, including deleted records:
                        $allRecs = $TYPO3_DB->exec_SELECTgetRows('uid',$tableName,'1=1');       //.t3lib_BEfunc::deleteClause($tableName)
                        $uidList = array(0);
                        foreach ($allRecs as $recdat)   {
                                $refIndexObj = t3lib_div::makeInstance('t3lib_refindex');
                                $result = $refIndexObj->updateRefIndexTable($tableName,$recdat['uid'],$testOnly);
                                $uidList[]= $recdat['uid'];
                                $recCount++;

                                if ($result['addedNodes'] || $result['deletedNodes'])   {
                                        $Err = 'Record '.$tableName.':'.$recdat['uid'].' had '.$result['addedNodes'].' added indexes and '.$result['deletedNodes'].' deleted indexes';
                                        $errors[]= $Err;
                                        if ($cli_echo) echo $Err.chr(10);
                                        #$errors[] = t3lib_div::view_array($result);
                                }
                        }

                                // Searching lost indexes for this table:
                        $where = 'tablename='.$TYPO3_DB->fullQuoteStr($tableName,'sys_refindex').' AND recuid NOT IN ('.implode(',',$uidList).')';
                        $lostIndexes = $TYPO3_DB->exec_SELECTgetRows('hash','sys_refindex',$where);
                        if (count($lostIndexes))        {
                                $Err = 'Table '.$tableName.' has '.count($lostIndexes).' lost indexes which are now deleted';
                                $errors[]= $Err;
                                if ($cli_echo) echo $Err.chr(10);
                                if (!$testOnly) $TYPO3_DB->exec_DELETEquery('sys_refindex',$where);
                        }
                }

                        // Searching lost indexes for non-existing tables:
                $where = 'tablename NOT IN ('.implode(',',$TYPO3_DB->fullQuoteArray($tableNames,'sys_refindex')).')';
                $lostTables = $TYPO3_DB->exec_SELECTgetRows('hash','sys_refindex',$where);
                if (count($lostTables)) {
                        $Err = 'Index table hosted '.count($lostTables).' indexes for non-existing tables, now removed';
                        $errors[]= $Err;
                        if ($cli_echo) echo $Err.chr(10);
                        if (!$testOnly) $TYPO3_DB->exec_DELETEquery('sys_refindex',$where);
                }

                $testedHowMuch = $recCount.' records from '.$tableCount.' tables were checked/updated.'.chr(10);

                $bodyContent = $testedHowMuch.(count($errors)?implode(chr(10),$errors):'Index Integrity was perfect!');
                if ($cli_echo) echo $testedHowMuch.(count($errors)?'Updates: '.count($errors):'Index Integrity was perfect!').chr(10);

                return array($headerContent,$bodyContent,count($errors));
        }
}


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

---

This documentation has been generated automatically from TYPO3 source code using Doxygen and is provided as is by Cast Iron Coding as a courtesy to other TYPO3 developers and users. Please consider Cast Iron Coding — a full-service web development agency in Portland, Oregon specializing in TYPO3 extension development — for all of your TYPO3 development and consulting needs!