Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.tx_impexp.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2005 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_diff.php');
require_once (PATH_t3lib.'class.t3lib_parsehtml.php');

require_once (PATH_t3lib.'class.t3lib_basicfilefunc.php');
require_once (PATH_t3lib.'class.t3lib_extfilefunc.php');
require_once (PATH_t3lib.'class.t3lib_refindex.php');

@ini_set('max_execution_time',600);
@ini_set('memory_limit','256m');







class tx_impexp {

                // Configuration, general
        var $showStaticRelations = FALSE;               // If set, static relations (not exported) will be shown in overview as well
        var $fileadminFolderName = 'fileadmin'; // Name of the "fileadmin" folder where files for export/import should be located

        var $mode = '';                                                 // Whether "import" or "export" mode of object. Set through init() function
        var $update = FALSE;                                    // Updates all records that has same UID instead of creating new!
        var $doesImport = FALSE;                                // Is set by importData() when an import has been done.

                // Configuration, import
        var $display_import_pid_record = '';            // If set to a page-record, then the preview display of the content will expect this page-record to be the target for the import and accordingly display validation information. This triggers the visual view of the import/export memory to validate if import is possible
        var $suggestedInsertUids = array();             // Used to register the forged UID values for imported records that we want to create with the same UIDs as in the import file. Admin-only feature.
        var $import_mode = array();                             // Setting import modes during update state: as_new, exclude, force_uid
        var $global_ignore_pid = FALSE;                 // If set, PID correct is ignored globally
        var $force_all_UIDS = FALSE;                    // If set, all UID values are forced! (update or import)
        var $showDiff = FALSE;                                  // If set, a diff-view column is added to the overview.
        var $allowPHPScripts = FALSE;                   // If set, and if the user is admin, allow the writing of PHP scripts to fileadmin/ area.
        var $enableLogging = FALSE;                             // Disable logging when importing
        var $softrefInputValues = array();              // Array of values to substitute in editable softreferences.
        var $fileIDMap = array();                               // Mapping between the fileID from import memory and the final filenames they are written to.

                // Configuration, export
        var $maxFileSize = 1000000;             // 1MB max file size
        var $maxRecordSize = 1000000;   // 1MB max record size
        var $maxExportSize = 10000000;  // 10MB max export size
        var $relOnlyTables = array();   // add table names here which are THE ONLY ones which will be included into export if found as relations. '_ALL' will allow all tables.
        var $relStaticTables = array(); // add tables names here which should not be exported with the file. (Where relations should be mapped to same UIDs in target system).
        var $excludeMap = array();              // Exclude map. Keys are table:uid  pairs and if set, records are not added to the export.
        var $softrefCfg = array();              // Soft Reference Token ID modes.
        var $extensionDependencies = array();           // Listing extension dependencies.
        var $dontCompress = 0;                  // Set  by user: If set, compression in t3d files is disabled
        var $includeExtFileResources = 0;       // Boolean, if set, HTML file resources are included.
        var $extFileResourceExtensions = 'html,htm,css';        // Files with external media (HTML/css style references inside)

                // Internal, dynamic:
        var $import_mapId = array();            // After records are written this array is filled with [table][original_uid] = [new_uid]
        var $import_newId = array();            // Keys are [tablename]:[new NEWxxx ids (or when updating it is uids)] while values are arrays with table/uid of the original record it is based on. By the array keys the new ids can be looked up inside tcemain
        var $import_newId_pids = array();       // Page id map for page tree (import)
        var $import_data = array();                     // Internal data accumulation for writing records during import
        var $errorLog = array();                        // Error log.
        var $cache_getRecordPath = array();     // Cache for record paths
        var $checkPID_cache = array();          // Cache of checkPID values.

        var $compress = 0;                                      // Set internally if the gzcompress function exists
        var $dat = array();                                     // Internal import/export memory
        var $fileProcObj = '';                          // File processing object



        /**************************
         *
         * Initialize
         *
         *************************/

        function init($dontCompress=0,$mode='') {
                $this->compress = function_exists('gzcompress');
                $this->dontCompress = $dontCompress;

                $this->mode = $mode;
        }














        /**************************
         *
         * Export / Init + Meta Data
         *
         *************************/

        function setHeaderBasics()      {

                        // Initializing:
                if (is_array($this->softrefCfg))        {
                        foreach($this->softrefCfg as $key => $value)    {
                                if (!strlen($value['mode']))    unset($this->softrefCfg[$key]);
                        }
                }

                        // Setting in header memory:
                $this->dat['header']['XMLversion'] = '1.0';             // Version of file format
                $this->dat['header']['meta'] = array();                 // Initialize meta data array (to put it in top of file)
                $this->dat['header']['relStaticTables'] = $this->relStaticTables;       // Add list of tables to consider static
                $this->dat['header']['excludeMap'] = $this->excludeMap;                         // The list of excluded records
                $this->dat['header']['softrefCfg'] = $this->softrefCfg;                 // Soft Reference mode for elements
                $this->dat['header']['extensionDependencies'] = $this->extensionDependencies;           // List of extensions the import depends on.
        }

        function setCharset($charset)   {
                $this->dat['header']['charset'] = $charset;
        }

        function setMetaData($title,$description,$notes,$packager_username,$packager_name,$packager_email)      {
                $this->dat['header']['meta'] = array(
                        'title' => $title,
                        'description' => $description,
                        'notes' => $notes,
                        'packager_username' => $packager_username,
                        'packager_name' => $packager_name,
                        'packager_email' => $packager_email,
                        'TYPO3_version' => TYPO3_version,
#                       'loaded_extensions' => $GLOBALS['TYPO3_CONF_VARS']['EXT']['extList'],
                        'created' => strftime('%A %e. %B %Y', time())
                );
        }

        function addThumbnail($imgFilepath)     {
                if (@is_file($imgFilepath))     {
                        $imgInfo = @getimagesize($imgFilepath);
                        if (is_array($imgInfo)) {
                                $fileContent = t3lib_div::getUrl($imgFilepath);
                                $this->dat['header']['thumbnail'] = array(
                                        'imgInfo' => $imgInfo,
                                        'content' => $fileContent,
                                        'filesize' => strlen($fileContent),
                                        'filemtime' => filemtime($imgFilepath),
                                        'filename' => basename($imgFilepath)
                                );
                        }
                }
        }











        /**************************
         *
         * Export / Init Page tree
         *
         *************************/

        function setPageTree($idH)      {
                $this->dat['header']['pagetree'] = $this->unsetExcludedSections($idH);
                return $this->flatInversePageTree($this->dat['header']['pagetree']);
        }

        function unsetExcludedSections($idH)    {
                if (is_array($idH))     {
                        reset($idH);
                        while(list($k,$v) = each($idH)) {
                                if ($this->excludeMap['pages:'.$idH[$k]['uid']])        {
                                        unset($idH[$k]);
                                } elseif (is_array($idH[$k]['subrow'])) {
                                        $idH[$k]['subrow'] = $this->unsetExcludedSections($idH[$k]['subrow']);
                                }
                        }
                }
                return $idH;
        }

        function flatInversePageTree($idH,$a=array())   {
                if (is_array($idH))     {
                        $idH = array_reverse($idH);
                        reset($idH);
                        while(list($k,$v) = each($idH)) {
                                $a[$v['uid']] = $v['uid'];
                                if (is_array($v['subrow']))     {
                                        $a = $this->flatInversePageTree($v['subrow'],$a);
                                }
                        }
                }
                return $a;
        }

        function flatInversePageTree_pid($idH,$a=array(),$pid=-1)       {
                if (is_array($idH))     {
                        $idH = array_reverse($idH);
                        reset($idH);
                        while(list($k,$v) = each($idH)) {
                                $a[$v['uid']] = $pid;
                                if (is_array($v['subrow']))     {
                                        $a = $this->flatInversePageTree_pid($v['subrow'],$a,$v['uid']);
                                }
                        }
                }
                return $a;
        }











        /**************************
         *
         * Export
         *
         *************************/

        function export_addRecord($table,$row,$relationLevel=0) {

                t3lib_BEfunc::workspaceOL($table,$row);

                if (strcmp($table,'') && is_array($row) && $row['uid']>0 && !$this->excludeMap[$table.':'.$row['uid']]) {
                        if ($this->checkPID($table==='pages' ? $row['uid'] : $row['pid']))      {
                                if (!isset($this->dat['records'][$table.':'.$row['uid']]))      {

                                                // Prepare header info:
                                        $headerInfo = array();
                                        $headerInfo['uid'] = $row['uid'];
                                        $headerInfo['pid'] = $row['pid'];
                                        $headerInfo['title'] = t3lib_div::fixed_lgd_cs(t3lib_BEfunc::getRecordTitle($table,$row),40);
                                        $headerInfo['size'] = strlen(serialize($row));
                                        if ($relationLevel)     {
                                                $headerInfo['relationLevel'] = $relationLevel;
                                        }

                                                // If record content is not too large in size, set the header content and add the rest:
                                        if ($headerInfo['size']<$this->maxRecordSize)   {

                                                        // Set the header summary:
                                                $this->dat['header']['records'][$table][$row['uid']] = $headerInfo;

                                                        // Create entry in the PID lookup:
                                                $this->dat['header']['pid_lookup'][$row['pid']][$table][$row['uid']]=1;

                                                        // Initialize reference index object:
                                                $refIndexObj = t3lib_div::makeInstance('t3lib_refindex');
                                                $refIndexObj->WSOL = TRUE;      // Yes to workspace overlays for exporting....

                                                        // Data:
                                                $this->dat['records'][$table.':'.$row['uid']] = array();
                                                $this->dat['records'][$table.':'.$row['uid']]['data'] = $row;
                                                $this->dat['records'][$table.':'.$row['uid']]['rels'] = $refIndexObj->getRelations($table,$row);
                                                $this->errorLog = array_merge($this->errorLog,$refIndexObj->errorLog);  // Merge error logs.

                                                        // Add information about the relations in the record in the header:
                                                $this->dat['header']['records'][$table][$row['uid']]['rels'] = $this->flatDBrels($this->dat['records'][$table.':'.$row['uid']]['rels']);

                                                        // Add information about the softrefs to header:
                                                $this->dat['header']['records'][$table][$row['uid']]['softrefs'] = $this->flatSoftRefs($this->dat['records'][$table.':'.$row['uid']]['rels']);

                                        } else $this->error('Record '.$table.':'.$row['uid'].' was larger than maxRecordSize ('.t3lib_div::formatSize($this->maxRecordSize).')');
                                } else $this->error('Record '.$table.':'.$row['uid'].' already added.');
                        } else $this->error('Record '.$table.':'.$row['uid'].' was outside your DB mounts!');
                }
        }

        function export_addDBRelations($relationLevel=0)        {
                global $TCA;

                        // Initialize:
                $addR = array();

                        // Traverse all "rels" registered for "records"
                if (is_array($this->dat['records']))    {
                        reset($this->dat['records']);
                        while(list($k) = each($this->dat['records']))   {
                                if (is_array($this->dat['records'][$k]))        {
                                        reset($this->dat['records'][$k]['rels']);
                                        while(list($fieldname,$vR) = each($this->dat['records'][$k]['rels']))   {
#debug($vR);
                                                        // For all DB types of relations:
                                                if ($vR['type']=='db')  {
                                                        foreach($vR['itemArray'] as $fI)        {
                                                                $this->export_addDBRelations_registerRelation($fI, $addR);
                                                        }
                                                }

                                                        // For all flex/db types of relations:
                                                if ($vR['type']=='flex')        {
                                                                // DB relations in flex form fields:
                                                        if (is_array($vR['flexFormRels']['db']))        {
                                                                foreach($vR['flexFormRels']['db'] as $subList)  {
                                                                        foreach($subList as $fI)        {
                                                                                $this->export_addDBRelations_registerRelation($fI, $addR);
                                                                        }
                                                                }
                                                        }
                                                                // DB oriented soft references in flex form fields:
                                                        if (is_array($vR['flexFormRels']['softrefs']))  {
                                                                foreach($vR['flexFormRels']['softrefs'] as $subList)    {
                                                                        foreach($subList['keys'] as $spKey => $elements)        {
                                                                                foreach($elements as $el)       {
                                                                                        if ($el['subst']['type'] === 'db' && $this->includeSoftref($el['subst']['tokenID']))    {
                                                                                                list($tempTable, $tempUid) = explode(':', $el['subst']['recordRef']);
                                                                                                $fI = array(
                                                                                                        'table' => $tempTable,
                                                                                                        'id' => $tempUid
                                                                                                );
                                                                                                $this->export_addDBRelations_registerRelation($fI, $addR, $el['subst']['tokenID']);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }

                                                        // In any case, if there are soft refs:
                                                if (is_array($vR['softrefs']['keys']))  {
                                                        foreach($vR['softrefs']['keys'] as $spKey => $elements) {
                                                                foreach($elements as $el)       {
                                                                        if ($el['subst']['type'] === 'db' && $this->includeSoftref($el['subst']['tokenID']))    {
                                                                                list($tempTable, $tempUid) = explode(':', $el['subst']['recordRef']);
                                                                                $fI = array(
                                                                                        'table' => $tempTable,
                                                                                        'id' => $tempUid
                                                                                );
                                                                                $this->export_addDBRelations_registerRelation($fI, $addR, $el['subst']['tokenID']);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                } else $this->error('There were no records available.');

                        // Now, if there were new records to add, do so:
                if (count($addR))       {
                        foreach($addR as $fI)   {

                                        // Get and set record:
                                $row = t3lib_BEfunc::getRecord($fI['table'],$fI['id']);
                                if (is_array($row))     {
                                        $this->export_addRecord($fI['table'],$row,$relationLevel+1);
                                }

                                        // Set status message
                                if ($fI['id']>0)        {       // Relation pointers always larger than zero except certain "select" types with negative values pointing to uids - but that is not supported here.
                                        $rId = $fI['table'].':'.$fI['id'];
                                        if (!isset($this->dat['records'][$rId]))        {
                                                $this->dat['records'][$rId] = 'NOT_FOUND';
                                                $this->error('Relation record '.$rId.' was not found!');
                                        }
                                }
                        }
                }

                        // Return overview of relations found and added
                return $addR;
        }

        function export_addDBRelations_registerRelation($fI, &$addR, $tokenID='')       {
                global $TCA;

                $rId = $fI['table'].':'.$fI['id'];
                if (isset($TCA[$fI['table']])
                                && !$this->isTableStatic($fI['table'])
                                && !$this->isExcluded($fI['table'],$fI['id'])
                                && (!$tokenID || $this->includeSoftref($tokenID))
                                && $this->inclRelation($fI['table'])
                                )       {
                        if (!isset($this->dat['records'][$rId]))        {
                                        // Set this record to be included since it is not already.
                                $addR[$rId] = $fI;
                        }
                }
        }

        function export_addFilesFromRelations() {

                        // Traverse all "rels" registered for "records"
                if (is_array($this->dat['records']))    {
                        reset($this->dat['records']);
                        while(list($k)=each($this->dat['records']))     {
                                if (is_array($this->dat['records'][$k]['rels']))        {
                                        reset($this->dat['records'][$k]['rels']);
                                        while(list($fieldname,$vR)=each($this->dat['records'][$k]['rels']))     {

                                                        // For all file type relations:
                                                if ($vR['type']=='file')        {
                                                        foreach($vR['newValueFiles'] as $key => $fI)    {
                                                                $this->export_addFile($fI, $k, $fieldname);
                                                                        // Remove the absolute reference to the file so it doesn't expose absolute paths from source server:
                                                                unset($this->dat['records'][$k]['rels'][$fieldname]['newValueFiles'][$key]['ID_absFile']);
                                                        }
                                                }

                                                        // For all flex type relations:
                                                if ($vR['type']=='flex')        {
                                                        if (is_array($vR['flexFormRels']['file']))      {
                                                                foreach($vR['flexFormRels']['file'] as $key => $subList)        {
                                                                        foreach($subList as $subKey => $fI)     {
                                                                                $this->export_addFile($fI, $k, $fieldname);
                                                                                        // Remove the absolute reference to the file so it doesn't expose absolute paths from source server:
                                                                                unset($this->dat['records'][$k]['rels'][$fieldname]['flexFormRels']['file'][$key][$subKey]['ID_absFile']);
                                                                        }
                                                                }
                                                        }

                                                                // DB oriented soft references in flex form fields:
                                                        if (is_array($vR['flexFormRels']['softrefs']))  {
                                                                foreach($vR['flexFormRels']['softrefs'] as $key => $subList)    {
                                                                        foreach($subList['keys'] as $spKey => $elements)        {
                                                                                foreach($elements as $subKey => $el)    {
                                                                                        if ($el['subst']['type'] === 'file' && $this->includeSoftref($el['subst']['tokenID']))  {

                                                                                                        // Create abs path and ID for file:
                                                                                                $ID_absFile = t3lib_div::getFileAbsFileName(PATH_site.$el['subst']['relFileName']);
                                                                                                $ID = md5($ID_absFile);

                                                                                                if ($ID_absFile)        {
                                                                                                        if (!$this->dat['files'][$ID])  {
                                                                                                                $fI = array(
                                                                                                                        'filename' => basename($ID_absFile),
                                                                                                                        'ID_absFile' => $ID_absFile,
                                                                                                                        'ID' => $ID,
                                                                                                                        'relFileName' => $el['subst']['relFileName']
                                                                                                                );
                                                                                                                $this->export_addFile($fI, '_SOFTREF_');
                                                                                                        }
                                                                                                        $this->dat['records'][$k]['rels'][$fieldname]['flexFormRels']['softrefs'][$key]['keys'][$spKey][$subKey]['file_ID'] = $ID;
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }

                                                        // In any case, if there are soft refs:
                                                if (is_array($vR['softrefs']['keys']))  {
                                                        foreach($vR['softrefs']['keys'] as $spKey => $elements) {
                                                                foreach($elements as $subKey => $el)    {
                                                                        if ($el['subst']['type'] === 'file' && $this->includeSoftref($el['subst']['tokenID']))  {

                                                                                        // Create abs path and ID for file:
                                                                                $ID_absFile = t3lib_div::getFileAbsFileName(PATH_site.$el['subst']['relFileName']);
                                                                                $ID = md5($ID_absFile);

                                                                                if ($ID_absFile)        {
                                                                                        if (!$this->dat['files'][$ID])  {
                                                                                                $fI = array(
                                                                                                        'filename' => basename($ID_absFile),
                                                                                                        'ID_absFile' => $ID_absFile,
                                                                                                        'ID' => $ID,
                                                                                                        'relFileName' => $el['subst']['relFileName']
                                                                                                );
                                                                                                $this->export_addFile($fI, '_SOFTREF_');
                                                                                        }
                                                                                        $this->dat['records'][$k]['rels'][$fieldname]['softrefs']['keys'][$spKey][$subKey]['file_ID'] = $ID;
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                } else $this->error('There were no records available.');
        }

        function export_addFile($fI, $recordRef='', $fieldname='')      {
                if (@is_file($fI['ID_absFile']))        {
                        if (filesize($fI['ID_absFile']) < $this->maxFileSize)   {
                                $fileRec = array();
                                $fileRec['filesize'] = filesize($fI['ID_absFile']);
                                $fileRec['filename'] = basename($fI['ID_absFile']);
                                $fileRec['filemtime'] = filemtime($fI['ID_absFile']);
                                if ($recordRef) {
                                        $fileRec['record_ref'] = $recordRef.'/'.$fieldname;
                                }
                                if ($fI['relFileName']) {
                                        $fileRec['relFileName'] = $fI['relFileName'];
                                }

                                        // Setting this data in the header
                                $this->dat['header']['files'][$fI['ID']] = $fileRec;

                                        // ... and for the recordlisting, why not let us know WHICH relations there was...
                                if ($recordRef && $recordRef!=='_SOFTREF_')     {
                                        $refParts = explode(':',$recordRef,2);
                                        if (!is_array($this->dat['header']['records'][$refParts[0]][$refParts[1]]['filerefs'])) {
                                                $this->dat['header']['records'][$refParts[0]][$refParts[1]]['filerefs'] = array();
                                        }
                                        $this->dat['header']['records'][$refParts[0]][$refParts[1]]['filerefs'][] = $fI['ID'];
                                }

                                        // ... and finally add the heavy stuff:
                                $fileRec['content'] = t3lib_div::getUrl($fI['ID_absFile']);
                                $fileRec['content_md5'] = md5($fileRec['content']);
                                $this->dat['files'][$fI['ID']] = $fileRec;


                                        // For soft references, do further processing:
                                if ($recordRef === '_SOFTREF_') {

                                                // RTE files?
                                        if ($RTEoriginal = $this->getRTEoriginalFilename(basename($fI['ID_absFile'])))  {
                                                $RTEoriginal_absPath = dirname($fI['ID_absFile']).'/'.$RTEoriginal;
                                                if (@is_file($RTEoriginal_absPath))     {

                                                        $RTEoriginal_ID = md5($RTEoriginal_absPath);

                                                        $fileRec = array();
                                                        $fileRec['filesize'] = filesize($RTEoriginal_absPath);
                                                        $fileRec['filename'] = basename($RTEoriginal_absPath);
                                                        $fileRec['filemtime'] = filemtime($RTEoriginal_absPath);
                                                        $fileRec['record_ref'] = '_RTE_COPY_ID:'.$fI['ID'];
                                                        $this->dat['header']['files'][$fI['ID']]['RTE_ORIG_ID'] = $RTEoriginal_ID;

                                                                // Setting this data in the header
                                                        $this->dat['header']['files'][$RTEoriginal_ID] = $fileRec;

                                                                // ... and finally add the heavy stuff:
                                                        $fileRec['content'] = t3lib_div::getUrl($RTEoriginal_absPath);
                                                        $fileRec['content_md5'] = md5($fileRec['content']);
                                                        $this->dat['files'][$RTEoriginal_ID] = $fileRec;
                                                } else {
                                                        $this->error('RTE original file "'.substr($RTEoriginal_absPath,strlen(PATH_site)).'" was not found!');
                                                }
                                        }

                                                // Files with external media?
                                                // This is only done with files grabbed by a softreference parser since it is deemed improbable that hard-referenced files should undergo this treatment.
                                        $html_fI = pathinfo(basename($fI['ID_absFile']));
                                        if ($this->includeExtFileResources && t3lib_div::inList($this->extFileResourceExtensions,strtolower($html_fI['extension'])))    {
                                                $uniquePrefix = '###'.md5(time()).'###';

                                                if (strtolower($html_fI['extension'])==='css')  {
                                                        $prefixedMedias = explode($uniquePrefix, eregi_replace('(url[[:space:]]*\([[:space:]]*["\']?)([^"\')]*)(["\']?[[:space:]]*\))', '\1'.$uniquePrefix.'\2'.$uniquePrefix.'\3', $fileRec['content']));
                                                } else {        // html, htm:
                                                        $htmlParser = t3lib_div::makeInstance('t3lib_parsehtml');
                                                        $prefixedMedias = explode($uniquePrefix, $htmlParser->prefixResourcePath($uniquePrefix,$fileRec['content'],array(),$uniquePrefix));
                                                }

                                                $htmlResourceCaptured = FALSE;
                                                foreach($prefixedMedias as $k => $v)    {
                                                        if ($k%2)       {
                                                                $EXTres_absPath = t3lib_div::resolveBackPath(dirname($fI['ID_absFile']).'/'.$v);
                                                                $EXTres_absPath = t3lib_div::getFileAbsFileName($EXTres_absPath);
                                                                if ($EXTres_absPath && t3lib_div::isFirstPartOfStr($EXTres_absPath,PATH_site.$this->fileadminFolderName.'/') && @is_file($EXTres_absPath))      {

                                                                        $htmlResourceCaptured = TRUE;
                                                                        $EXTres_ID = md5($EXTres_absPath);
                                                                        $this->dat['header']['files'][$fI['ID']]['EXT_RES_ID'][] = $EXTres_ID;
                                                                        $prefixedMedias[$k] = '{EXT_RES_ID:'.$EXTres_ID.'}';

                                                                                // Add file to memory if it is not set already:
                                                                        if (!isset($this->dat['header']['files'][$EXTres_ID]))          {
                                                                                $fileRec = array();
                                                                                $fileRec['filesize'] = filesize($EXTres_absPath);
                                                                                $fileRec['filename'] = basename($EXTres_absPath);
                                                                                $fileRec['filemtime'] = filemtime($EXTres_absPath);
                                                                                $fileRec['record_ref'] = '_EXT_PARENT_:'.$fI['ID'];

                                                                                $fileRec['parentRelFileName'] = $v;             // Media relative to the HTML file.

                                                                                        // Setting this data in the header
                                                                                $this->dat['header']['files'][$EXTres_ID] = $fileRec;

                                                                                        // ... and finally add the heavy stuff:
                                                                                $fileRec['content'] = t3lib_div::getUrl($EXTres_absPath);
                                                                                $fileRec['content_md5'] = md5($fileRec['content']);
                                                                                $this->dat['files'][$EXTres_ID] = $fileRec;
                                                                        }
                                                                }
                                                        }
                                                }

                                                if ($htmlResourceCaptured)      {
                                                        $this->dat['files'][$fI['ID']]['tokenizedContent'] = implode('', $prefixedMedias);
                                                }
                                        }
                                }

                        } else  $this->error($fI['ID_absFile'].' was larger ('.t3lib_div::formatSize(filesize($fI['ID_absFile'])).') than the maxFileSize ('.t3lib_div::formatSize($this->maxFileSize).')! Skipping.');
                } else $this->error($fI['ID_absFile'].' was not a file! Skipping.');
        }

        function flatDBrels($dbrels)    {
                $list = array();

                foreach($dbrels as $dat)        {
                        if ($dat['type']=='db') {
                                foreach($dat['itemArray'] as $i)        {
                                        $list[$i['table'].':'.$i['id']] = $i;
                                }
                        }
                        if ($dat['type']=='flex' && is_array($dat['flexFormRels']['db']))       {
                                foreach($dat['flexFormRels']['db'] as $subList) {
                                        foreach($subList as $i) {
                                                $list[$i['table'].':'.$i['id']] = $i;
                                        }
                                }
                        }
                }
                return $list;
        }

        function flatSoftRefs($dbrels)  {
                $list = array();
#debug($dbrels);
                foreach($dbrels as $field => $dat)      {
                        if (is_array($dat['softrefs']['keys'])) {
                                foreach($dat['softrefs']['keys'] as $spKey => $elements)        {
                                        if (is_array($elements))        {
                                                foreach($elements as $subKey => $el)    {
                                                        $lKey = $field.':'.$spKey.':'.$subKey;
                                                        $list[$lKey] = array_merge(array('field' => $field, 'spKey' => $spKey),$el);

                                                                // Add file_ID key to header - slightly "risky" way of doing this because if the calculation changes for the same value in $this->records[...] this will not work anymore!
                                                        if ($el['subst'] && $el['subst']['relFileName'])        {
                                                                $list[$lKey]['file_ID'] = md5(PATH_site.$el['subst']['relFileName']);
                                                        }
                                                }
                                        }
                                }
                        }
                        if ($dat['type']=='flex' && is_array($dat['flexFormRels']['softrefs'])) {
                                foreach($dat['flexFormRels']['softrefs'] as $structurePath => $subSoftrefs)     {
                                        if (is_array($subSoftrefs['keys']))     {
                                                foreach($subSoftrefs['keys'] as $spKey => $elements)    {
                                                        foreach($elements as $subKey => $el)    {
                                                                $lKey = $field.':'.$structurePath.':'.$spKey.':'.$subKey;
                                                                $list[$lKey] = array_merge(array('field' => $field, 'spKey' => $spKey, 'structurePath' => $structurePath),$el);

                                                                        // Add file_ID key to header - slightly "risky" way of doing this because if the calculation changes for the same value in $this->records[...] this will not work anymore!
                                                                if ($el['subst'] && $el['subst']['relFileName'])        {
                                                                        $list[$lKey]['file_ID'] = md5(PATH_site.$el['subst']['relFileName']);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

#debug($list);
                return $list;
        }











        /**************************
         *
         * File Output
         *
         *************************/

        function compileMemoryToFileContent($type='')   {

                if ($type=='xml')       {
                        $out = $this->createXML();
                } else {
                        $compress = $this->doOutputCompress();
                        $out = '';

                        // adding header:
                        $out.= $this->addFilePart(serialize($this->dat['header']),$compress);

                        // adding records:
                        $out.= $this->addFilePart(serialize($this->dat['records']),$compress);

                        // adding files:
                        $out.= $this->addFilePart(serialize($this->dat['files']),$compress);
                }

                return $out;
        }

        function createXML()    {

                        // Options:
                $options = array(
                        'alt_options' => array(
                                '/header' => array(
                                        'disableTypeAttrib' => TRUE,
                                        'clearStackPath' => TRUE,
                                        'parentTagMap' => array(
                                                'files' => 'file',
                                                'records' => 'table',
                                                'table' => 'rec',
                                                'rec:rels' => 'relations',
                                                'relations' => 'element',
                                                'filerefs' => 'file',
                                                'pid_lookup' => 'page_contents',
                                                'header:relStaticTables' => 'static_tables',
                                                'static_tables' => 'tablename',
                                                'excludeMap' => 'item',
                                                'softrefCfg' => 'softrefExportMode',
                                                'extensionDependencies' => 'extkey',
                                                'softrefs' => 'softref_element',
                                        ),
                                        'alt_options' => array(
                                                '/pagetree' => array(
                                                        'disableTypeAttrib' => TRUE,
                                                        'useIndexTagForNum' => 'node',
                                                        'parentTagMap' => array(
                                                                'node:subrow' => 'node'
                                                        )
                                                ),
                                                '/pid_lookup/page_contents' => array(
                                                        'disableTypeAttrib' => TRUE,
                                                        'parentTagMap' => array(
                                                                'page_contents' => 'table'
                                                        ),
                                                        'grandParentTagMap' => array(
                                                                'page_contents/table' => 'item'
                                                        )
                                                )
                                        )
                                ),
                                '/records' => array(
                                        'disableTypeAttrib' => TRUE,
                                        'parentTagMap' => array(
                                                'records' => 'tablerow',
                                                'tablerow:data' => 'fieldlist',
                                                'tablerow:rels' => 'related',
                                                'related' => 'field',
                                                'field:itemArray' => 'relations',
                                                'field:newValueFiles' => 'filerefs',
                                                'field:flexFormRels' => 'flexform',
                                                'relations' => 'element',
                                                'filerefs' => 'file',
                                                'flexform:db' => 'db_relations',
                                                'flexform:file' => 'file_relations',
                                                'flexform:softrefs' => 'softref_relations',
                                                'softref_relations' => 'structurePath',
                                                'db_relations' => 'path',
                                                'file_relations' => 'path',
                                                'path' => 'element',
                                                'keys' => 'softref_key',
                                                'softref_key' => 'softref_element',
                                        ),
                                        'alt_options' => array(
                                                '/records/tablerow/fieldlist' => array(
                                                        'useIndexTagForAssoc' => 'field',
                                                )
                                        )
                                ),
                                '/files' => array(
                                        'disableTypeAttrib' => TRUE,
                                        'parentTagMap' => array(
                                                'files' => 'file',
                                        ),
                                ),
                        )
                );

                        // Creating XML file from $outputArray:
                $charset = $this->dat['header']['charset'] ? $this->dat['header']['charset'] : 'iso-8859-1';
                $XML = '<?xml version="1.0" encoding="'.$charset.'" standalone="yes" ?>'.chr(10);
                $XML.= t3lib_div::array2xml($this->dat,'',0,'T3RecordDocument',0,$options);

                return $XML;
        }

        function doOutputCompress()     {
                return $this->compress && !$this->dontCompress;
        }

        function addFilePart($data, $compress=FALSE)    {
                if ($compress)  $data = gzcompress($data);
                return md5($data).':'.
                                ($compress?'1':'0').':'.
                                str_pad(strlen($data),10,'0',STR_PAD_LEFT).':'.
                                $data.':';
        }














        /***********************
         *
         * Import
         *
         ***********************/

        function importData($pid)       {

                        // Set this flag to indicate that an import is being/has been done.
                $this->doesImport = 1;

                        // Initialize:
                        // These vars MUST last for the whole section not being cleared. They are used by the method setRelations() which are called at the end of the import session.
                $this->import_mapId = array();
                $this->import_newId = array();
                $this->import_newId_pids = array();

                        // Temporary files stack initialized:
                $this->unlinkFiles = array();
                $this->alternativeFileName = array();

                        // Write records, first pages, then the rest
                        // Fields with "hard" relations to database, files and flexform fields are kept empty during this run
                $this->writeRecords_pages($pid);
                $this->writeRecords_records($pid);

                        // Finally all the file and DB record references must be fixed. This is done after all records have supposedly been written to database:
                        // $this->import_mapId will indicate two things: 1) that a record WAS written to db and 2) that it has got a new id-number.
                $this->setRelations();

                        // And when all DB relations are in place, we can fix file and DB relations in flexform fields (since data structures often depends on relations to a DS record):
                $this->setFlexFormRelations();

                        // Unlink temporary files:
                $this->unlinkTempFiles();

                        // Finally, traverse all records and process softreferences with substitution attributes.
                $this->processSoftReferences();
        }

        function writeRecords_pages($pid)       {

                        // First, write page structure if any:
                if (is_array($this->dat['header']['records']['pages'])) {

                                // $pageRecords is a copy of the pages array in the imported file. Records here are unset one by one when the addSingle function is called.
                        $pageRecords = $this->dat['header']['records']['pages'];
                        $this->import_data = array();
#debug($pageRecords);
                                // First add page tree if any
                        if (is_array($this->dat['header']['pagetree'])) {
                                $pagesFromTree = $this->flatInversePageTree($this->dat['header']['pagetree']);
                                foreach($pagesFromTree as $uid) {
                                        $thisRec = $this->dat['header']['records']['pages'][$uid];
                                                // PID: Set the main $pid, unless a NEW-id is found
                                        $setPid = isset($this->import_newId_pids[$thisRec['pid']])      ? $this->import_newId_pids[$thisRec['pid']] : $pid;
                                        $this->addSingle('pages',$uid,$setPid);
                                        unset($pageRecords[$uid]);
                                }
                        }
#debug($pageRecords);
                                // Then add all remaining pages not in tree on root level:
                        if (count($pageRecords))        {
                                $remainingPageUids = array_keys($pageRecords);
                                foreach($remainingPageUids as $pUid)    {
                                        $this->addSingle('pages',$pUid,$pid);
                                }
                        }

                                // Now write to database:
                        $tce = $this->getNewTCE();
                        $tce->suggestedInsertUids = $this->suggestedInsertUids;
                        $tce->start($this->import_data,Array());
                        $tce->process_datamap();
#debug($this->import_data,'PAGES');

                                // post-processing: Registering new ids (end all tcemain sessions with this)
                        $this->addToMapId($tce->substNEWwithIDs);

                                // In case of an update, order pages from the page tree correctly:
                        if ($this->update && is_array($this->dat['header']['pagetree']))        {
                                $this->writeRecords_pages_order($pid);
                        }
                }
        }

        function writeRecords_pages_order($pid) {
                $cmd_data = array();

                        // Get uid-pid relations and traverse them in order to map to possible new IDs
                $pidsFromTree = $this->flatInversePageTree_pid($this->dat['header']['pagetree']);
#debug($this->dat['header']['pagetree'],'pagetree');
#debug($pidsFromTree,'$pidsFromTree');
#debug($this->import_newId_pids,'import_newId_pids');
                foreach($pidsFromTree as $origPid => $newPid)   {
                        if ($newPid>=0 && $this->dontIgnorePid('pages', $origPid))      {
                                if (substr($this->import_newId_pids[$origPid],0,3)==='NEW')     {       // If the page had a new id (because it was created) use that instead!

                                        if ($this->import_mapId['pages'][$origPid])     {
                                                $mappedPid = $this->import_mapId['pages'][$origPid];
                                                $cmd_data['pages'][$mappedPid]['move'] = $newPid;
                                        }
                                } else {
                                        $cmd_data['pages'][$origPid]['move'] = $newPid;
                                }
                        }
                }

                        // Execute the move commands if any:
                if (count($cmd_data))   {
                        $tce = $this->getNewTCE();
                        $tce->start(Array(),$cmd_data);
                        $tce->process_cmdmap();
                }
#debug($cmd_data,'$cmd_data');
        }

        function writeRecords_records($pid)     {
                global $TCA;

                        // Write the rest of the records
                $this->import_data = array();
                if (is_array($this->dat['header']['records']))  {
                        reset($this->dat['header']['records']);
                        while(list($table,$recs) = each($this->dat['header']['records']))       {
                                if ($table!='pages')    {
                                        reset($recs);
                                        while(list($uid,$thisRec)=each($recs))  {
                                                        // PID: Set the main $pid, unless a NEW-id is found
                                                $setPid = isset($this->import_mapId['pages'][$thisRec['pid']]) ? $this->import_mapId['pages'][$thisRec['pid']] : $pid;
                                                if (is_array($TCA[$table]) && $TCA[$table]['ctrl']['rootLevel'])        {
                                                        $setPid = 0;
                                                }

                                                        // Add record:
                                                $this->addSingle($table,$uid,$setPid);
                                        }
                                }
                        }
                } else $this->error('Error: No records defined in internal data array.');

                        // Now write to database:
                $tce = $this->getNewTCE();
                $tce->suggestedInsertUids = $this->suggestedInsertUids;
                $tce->reverseOrder=1;   // Because all records are being submitted in their correct order with positive pid numbers - and so we should reverse submission order internally.
                $tce->start($this->import_data,Array());
                $tce->process_datamap();
#debug($this->import_data,'RECORDS');

                        // post-processing: Removing files and registering new ids (end all tcemain sessions with this)
                $this->addToMapId($tce->substNEWwithIDs);

                        // In case of an update, order pages from the page tree correctly:
                if ($this->update)      {
                        $this->writeRecords_records_order($pid);
                }
        }

        function writeRecords_records_order($mainPid)   {
                $cmd_data = array();

                if (is_array($this->dat['header']['pagetree'])) {
                        $pagesFromTree = $this->flatInversePageTree($this->dat['header']['pagetree']);
                } else $pagesFromTree = array();

#debug($this->dat['header']['pid_lookup'],'pid_lookup');
                if (is_array($this->dat['header']['pid_lookup']))       {
                        foreach($this->dat['header']['pid_lookup'] as $pid => $recList) {
                                $newPid = isset($this->import_mapId['pages'][$pid]) ? $this->import_mapId['pages'][$pid] : $mainPid;
#debug(array($pid,$newPid),'$pid / $newPid');

                                if (t3lib_div::testInt($newPid))        {
                                        foreach($recList as $tableName => $uidList)     {