PHP UsersLastImport类代码示例

 /** 
  * display the form
  */
 public function display()
 {
     global $mod_strings, $current_user, $current_language;
     $this->ss->assign("MOD", $mod_strings);
     $this->ss->assign("IMPORT_MODULE", $_REQUEST['import_module']);
     // lookup this module's $mod_strings to get the correct module name
     $old_mod_strings = $mod_strings;
     $module_mod_strings = return_module_language($current_language, $_REQUEST['import_module']);
     $this->ss->assign("MODULENAME", $module_mod_strings['LBL_MODULE_NAME']);
     // reset old ones afterwards
     $mod_strings = $old_mod_strings;
     $last_import = new UsersLastImport();
     $this->ss->assign('UNDO_SUCCESS', $last_import->undo($_REQUEST['import_module']));
     $this->ss->assign("JAVASCRIPT", $this->_getJS());
     $this->ss->display('modules/Import/tpls/undo.tpl');
 }

 function add_member_of_name()
 {
     // global is defined in UsersLastImport.php
     global $imported_ids;
     global $current_user;
     if ((!isset($this->account_name) || $this->account_name == '') && (!isset($this->parent_id) || $this->parent_id == '')) {
         return;
     }
     $arr = array();
     // check if it already exists
     $focus = new Account();
     $query = '';
     // if user is defining the account id to be associated with this contact..
     if (isset($this->parent_id) && $this->parent_id != '') {
         $this->parent_id = convert_id($this->parent_id);
         $query = "select * from {$focus->table_name} WHERE id='" . PearDatabase::quote($this->parent_id) . "'";
     } else {
         $query = "select * from {$focus->table_name} WHERE name='" . PearDatabase::quote($this->account_name) . "'";
     }
     $GLOBALS['log']->info($query);
     $result = $this->db->query($query) or sugar_die("Error selecting sugarbean: ");
     $row = $this->db->fetchByAssoc($result, -1, false);
     // we found a row with that id
     if (isset($row['id']) && $row['id'] != -1) {
         // if it exists but was deleted, just remove it entirely
         if (isset($row['deleted']) && $row['deleted'] == 1) {
             $query2 = "delete from {$focus->table_name} WHERE id='" . PearDatabase::quote($row['id']) . "'";
             $GLOBALS['log']->info($query2);
             $result2 = $this->db->query($query2) or sugar_die("Error deleting existing sugarbean: ");
         } else {
             $focus->id = $row['id'];
         }
     }
     // if we didnt find the account, so create it
     if (!isset($focus->id) || $focus->id == '') {
         $focus->name = $this->account_name;
         if (isset($this->parent_id)) {
             $focus->parent_id = $this->parent_id;
         } else {
             $focus->parent_id = $current_user->id;
         }
         if (isset($this->modified_date)) {
             $focus->modified_date = $this->modified_date;
         }
         // if we are providing the account id:
         if (isset($this->parent_id) && $this->parent_id != '') {
             $focus->new_with_id = true;
             $focus->id = $this->account_id;
         }
         $focus->save();
         // avoid duplicate mappings:
         if (!isset($imported_ids[$focus->id])) {
             // save the new account as a users_last_import
             $last_import = new UsersLastImport();
             $last_import->assigned_user_id = $current_user->id;
             $last_import->bean_type = "Accounts";
             $last_import->bean_id = $focus->id;
             $last_import->save();
             $imported_ids[$focus->id] = 1;
         }
     }
     // now just link the account
     $this->parent_id = $focus->id;
 }

    $_REQUEST['module'] = 'Home';
}
if (!isset($_REQUEST['return_id'])) {
    $_REQUEST['return_id'] = '';
}
if (!isset($_REQUEST['return_module'])) {
    $_REQUEST['return_module'] = '';
}
if (!isset($_REQUEST['return_action'])) {
    $_REQUEST['return_action'] = '';
}
$parenttab = getParenttab();
$theme_path = "themes/" . $theme . "/";
$image_path = $theme_path . "images/";
$log->info("Import Undo");
$last_import = new UsersLastImport();
$ret_value = $last_import->undo($current_user->id);
// vtlib customization: Invoke undo import function of the module.
$module = $_REQUEST['module'];
$undo_focus = CRMEntity::getInstance($module);
if (method_exists($undo_focus, 'undo_import')) {
    $ret_value += $undo_focus->undo_import($module, $current_user->id);
}
// END
?>

<br>


<table align="center" cellpadding="5" cellspacing="0" width="95%" class="mailClient importLeadUI small">
        <tr>

 /**
  * This function handles the import for uitype 10 fieldtype
  * @param string $module - the current module name
  * @param string fieldname - the related to field name
  */
 function add_related_to($module, $fieldname)
 {
     global $adb, $imported_ids, $current_user;
     $related_to = $this->column_fields[$fieldname];
     if (empty($related_to)) {
         return false;
     }
     //check if the field has module information; if not get the first module
     if (!strpos($related_to, "::::")) {
         $module = getFirstModule($module, $fieldname);
         $value = $related_to;
     } else {
         //check the module of the field
         $arr = array();
         $arr = explode("::::", $related_to);
         $module = $arr[0];
         $value = $arr[1];
     }
     $focus1 = CRMEntity::getInstance($module);
     $entityNameArr = getEntityField($module);
     $entityName = $entityNameArr['fieldname'];
     $query = "SELECT vtiger_crmentity.deleted, {$focus1->table_name}.*\n\t\t\t\t\tFROM {$focus1->table_name}\n\t\t\t\t\tINNER JOIN vtiger_crmentity ON vtiger_crmentity.crmid={$focus1->table_name}.{$focus1->table_index}\n\t\t\t\t\t\twhere {$entityName}=? and vtiger_crmentity.deleted=0";
     $result = $adb->pquery($query, array($value));
     if (!isset($this->checkFlagArr[$module])) {
         $this->checkFlagArr[$module] = isPermitted($module, 'EditView', '') == 'yes';
     }
     if ($adb->num_rows($result) > 0) {
         //record found
         $focus1->id = $adb->query_result($result, 0, $focus1->table_index);
     } elseif ($this->checkFlagArr[$module]) {
         //record not found; create it
         $focus1->column_fields[$focus1->list_link_field] = $value;
         $focus1->column_fields['assigned_user_id'] = $current_user->id;
         $focus1->column_fields['modified_user_id'] = $current_user->id;
         $focus1->save($module);
         $last_import = new UsersLastImport();
         $last_import->assigned_user_id = $current_user->id;
         $last_import->bean_type = $module;
         $last_import->bean_id = $focus1->id;
         $last_import->save();
     } else {
         //record not found and cannot create
         $this->column_fields[$fieldname] = "";
         return false;
     }
     if (!empty($focus1->id)) {
         $this->column_fields[$fieldname] = $focus1->id;
         return true;
     } else {
         $this->column_fields[$fieldname] = "";
         return false;
     }
 }

 /**	function used to create or map with existing account if the contact has mapped with an account during import
  */
 function add_create_account()
 {
     global $adb;
     // global is defined in UsersLastImport.php
     global $imported_ids;
     global $current_user;
     $acc_name = $this->column_fields['account_id'];
     $adb->println("contact add_create acc=" . $acc_name);
     if (!isset($acc_name) || $acc_name == '') {
         return;
     }
     $arr = array();
     // check if it already exists
     $focus = new Accounts();
     $query = '';
     // if user is defining the vtiger_account id to be associated with this contact..
     //Modified to remove the spaces at first and last in vtiger_account name -- after 4.2 patch 2
     $acc_name = trim($acc_name);
     //Modified the query to get the available account only ie., which is not deleted
     $query = "select vtiger_crmentity.deleted, vtiger_account.* from vtiger_account, vtiger_crmentity WHERE accountname=? and vtiger_crmentity.crmid =vtiger_account.accountid and vtiger_crmentity.deleted=0";
     $result = $adb->pquery($query, array($acc_name));
     $row = $this->db->fetchByAssoc($result, -1, false);
     $adb->println("fetched account");
     $adb->println($row);
     // we found a row with that id
     if (isset($row['accountid']) && $row['accountid'] != -1) {
         $focus->id = $row['accountid'];
         $adb->println("Account row exists - using same id=" . $focus->id);
     }
     // if we didnt find the vtiger_account, so create it
     if (!isset($focus->id) || $focus->id == '') {
         $adb->println("Createing new vtiger_account");
         $focus->column_fields['accountname'] = $acc_name;
         $focus->column_fields['assigned_user_id'] = $current_user->id;
         $focus->column_fields['modified_user_id'] = $current_user->id;
         //$focus->saveentity("Accounts");
         $focus->save("Accounts");
         $acc_id = $focus->id;
         $adb->println("New Account created id=" . $focus->id);
         // avoid duplicate mappings:
         if (!isset($imported_ids[$acc_id])) {
             $adb->println("inserting vtiger_users last import for vtiger_accounts");
             // save the new vtiger_account as a vtiger_users_last_import
             $last_import = new UsersLastImport();
             $last_import->assigned_user_id = $current_user->id;
             $last_import->bean_type = "Accounts";
             $last_import->bean_id = $focus->id;
             $last_import->save();
             $imported_ids[$acc_id] = 1;
         }
     }
     $adb->println("prev contact accid=" . $this->column_fields["account_id"]);
     // now just link the vtiger_account
     $this->column_fields["account_id"] = $focus->id;
     $adb->println("curr contact accid=" . $this->column_fields["account_id"]);
 }

if (isset($datarows) && is_array($datarows)) {
    //This file will be included only once at the first time. Will not be included when we redirect from ImportSave
    include "modules/Import/picklist_addition.php";
}
$saved_ids = array();
$firstrow = 0;
if (!isset($datarows)) {
    $error = $mod_strings['LBL_FILE_ALREADY_BEEN_OR'];
    $datarows = array();
}
if ($has_header == 1) {
    $firstrow = array_shift($datarows);
}
//Mark the last imported records as deleted which are imported by the current user in vtiger_users_last_import vtiger_table
if (!isset($_REQUEST['startval'])) {
    $seedUsersLastImport = new UsersLastImport();
    $seedUsersLastImport->mark_deleted_by_user_id($current_user->id);
}
$skip_required_count = 0;
p("processing started ret_field_count=" . $ret_field_count);
$adb->println($datarows);
$error = '';
$focus = new $current_bean_type();
$focus->initRequiredFields($module);
// SAVE MAPPING IF REQUESTED
if (isset($_REQUEST['save_map']) && $_REQUEST['save_map'] == 'on' && isset($_REQUEST['save_map_as']) && $_REQUEST['save_map_as'] != '') {
    p("save map");
    $serialized_mapping = '';
    if ($has_header) {
        foreach ($col_pos_to_field as $pos => $field_name) {
            if (isset($firstrow[$pos]) && isset($field_name)) {

    /**
     * @see SugarView::display()
     */
    public function display()
    {
        global $mod_strings, $app_strings, $current_user, $sugar_config, $app_list_strings, $locale;
        $this->ss->assign("IMPORT_MODULE", $_REQUEST['import_module']);
        $has_header = isset($_REQUEST['has_header']) ? 1 : 0;
        $sugar_config['import_max_records_per_file'] = empty($sugar_config['import_max_records_per_file']) ? 1000 : $sugar_config['import_max_records_per_file'];
        // Clear out this user's last import
        $seedUsersLastImport = new UsersLastImport();
        $seedUsersLastImport->mark_deleted_by_user_id($current_user->id);
        ImportCacheFiles::clearCacheFiles();
        // attempt to lookup a preexisting field map
        // use the custom one if specfied to do so in step 1
        $field_map = array();
        $default_values = array();
        $ignored_fields = array();
        if (!empty($_REQUEST['source_id'])) {
            $mapping_file = new ImportMap();
            $mapping_file->retrieve($_REQUEST['source_id'], false);
            $_REQUEST['source'] = $mapping_file->source;
            $has_header = $mapping_file->has_header;
            if (isset($mapping_file->delimiter)) {
                $_REQUEST['custom_delimiter'] = $mapping_file->delimiter;
            }
            if (isset($mapping_file->enclosure)) {
                $_REQUEST['custom_enclosure'] = htmlentities($mapping_file->enclosure);
            }
            $field_map = $mapping_file->getMapping();
            $default_values = $mapping_file->getDefaultValues();
            $this->ss->assign("MAPNAME", $mapping_file->name);
            $this->ss->assign("CHECKMAP", 'checked="checked" value="on"');
        } else {
            // Try to see if we have a custom mapping we can use
            // based upon the where the records are coming from
            // and what module we are importing into
            $classname = 'ImportMap' . ucfirst($_REQUEST['source']);
            if (file_exists("modules/Import/{$classname}.php")) {
                require_once "modules/Import/{$classname}.php";
            } elseif (file_exists("custom/modules/Import/{$classname}.php")) {
                require_once "custom/modules/Import/{$classname}.php";
            } else {
                require_once "custom/modules/Import/ImportMapOther.php";
                $classname = 'ImportMapOther';
                $_REQUEST['source'] = 'other';
            }
            if (class_exists($classname)) {
                $mapping_file = new $classname();
                if (isset($mapping_file->delimiter)) {
                    $_REQUEST['custom_delimiter'] = $mapping_file->delimiter;
                }
                if (isset($mapping_file->enclosure)) {
                    $_REQUEST['custom_enclosure'] = htmlentities($mapping_file->enclosure);
                }
                $ignored_fields = $mapping_file->getIgnoredFields($_REQUEST['import_module']);
                $field_map = $mapping_file->getMapping($_REQUEST['import_module']);
            }
        }
        $this->ss->assign("CUSTOM_DELIMITER", !empty($_REQUEST['custom_delimiter']) ? $_REQUEST['custom_delimiter'] : ",");
        $this->ss->assign("CUSTOM_ENCLOSURE", !empty($_REQUEST['custom_enclosure']) ? $_REQUEST['custom_enclosure'] : "");
        // handle uploaded file
        $uploadFile = new UploadFile('userfile');
        if (isset($_FILES['userfile']) && $uploadFile->confirm_upload()) {
            $uploadFile->final_move('IMPORT_' . $this->bean->object_name . '_' . $current_user->id);
            $uploadFileName = $uploadFile->get_upload_path('IMPORT_' . $this->bean->object_name . '_' . $current_user->id);
        } else {
            $this->_showImportError($mod_strings['LBL_IMPORT_MODULE_ERROR_NO_UPLOAD'], $_REQUEST['import_module'], 'Step2');
            return;
        }
        // split file into parts
        $splitter = new ImportFileSplitter($uploadFileName, $sugar_config['import_max_records_per_file']);
        $splitter->splitSourceFile($_REQUEST['custom_delimiter'], html_entity_decode($_REQUEST['custom_enclosure'], ENT_QUOTES), $has_header);
        // Now parse the file and look for errors
        $importFile = new ImportFile($uploadFileName, $_REQUEST['custom_delimiter'], html_entity_decode($_REQUEST['custom_enclosure'], ENT_QUOTES));
        if (!$importFile->fileExists()) {
            $this->_showImportError($mod_strings['LBL_CANNOT_OPEN'], $_REQUEST['import_module'], 'Step2');
            return;
        }
        // retrieve first 3 rows
        $rows = array();
        $system_charset = $locale->default_export_charset;
        $user_charset = $locale->getExportCharset();
        $other_charsets = 'UTF-8, UTF-7, ASCII, CP1252, EUC-JP, SJIS, eucJP-win, SJIS-win, JIS, ISO-2022-JP';
        $detectable_charsets = "UTF-8, {$user_charset}, {$system_charset}, {$other_charsets}";
        // Bug 26824 - mb_detect_encoding() thinks CP1252 is IS0-8859-1, so use that instead in the encoding list passed to the function
        $detectable_charsets = str_replace('CP1252', 'ISO-8859-1', $detectable_charsets);
        $charset_for_import = $user_charset;
        //We will set the default import charset option by user's preference.
        $able_to_detect = function_exists('mb_detect_encoding');
        for ($i = 0; $i < 3; $i++) {
            $rows[$i] = $importFile->getNextRow();
            if (!empty($rows[$i]) && $able_to_detect) {
                foreach ($rows[$i] as &$temp_value) {
                    $current_charset = mb_detect_encoding($temp_value, $detectable_charsets);
                    if (!empty($current_charset) && $current_charset != "UTF-8") {
                        $temp_value = $locale->translateCharset($temp_value, $current_charset);
                        // we will use utf-8 for displaying the data on the page.
                        $charset_for_import = $current_charset;
                        //set the default import charset option according to the current_charset.
//.........这里部分代码省略.........

 /**
  * Add this row to the UsersLastImport table
  *
  * @param string $import_module name of the module we are doing the import into
  * @param string $module        name of the bean we are creating for this import
  * @param string $id            id of the recorded created in the $module
  */
 public static function writeRowToLastImport($import_module, $module, $id)
 {
     // cache $last_import instance
     static $last_import;
     if (!$last_import instanceof UsersLastImport) {
         $last_import = new UsersLastImport();
     }
     $last_import->id = null;
     $last_import->deleted = null;
     $last_import->assigned_user_id = $GLOBALS['current_user']->id;
     $last_import->import_module = $import_module;
     if ($module == 'Case') {
         $module = 'aCase';
     }
     $last_import->bean_type = $module;
     $last_import->bean_id = $id;
     return $last_import->save();
 }

    }
} else {
    echo "<br><br>";
    $currentModule = "Import";
    global $limit;
    global $list_max_entries_per_page;
    $implict_account = false;
    $import_modules_array = array("Leads" => "Leads", "Accounts" => "Accounts", "Contacts" => "Contacts", "Potentials" => "Potentials", "Products" => "Products", "HelpDesk" => "ImportTicket", "Vendors" => "ImportVendors");
    // vtlib customization: Hook provide to include custom modules
    $module = $_REQUEST['modulename'];
    checkFileAccess("modules/{$module}/{$module}.php");
    require_once "modules/{$module}/{$module}.php";
    $import_modules_array[$module] = $module;
    // END
    foreach ($import_modules_array as $module_name => $object_name) {
        $seedUsersLastImport = new UsersLastImport();
        $seedUsersLastImport->bean_type = $module_name;
        $list_query = $seedUsersLastImport->create_list_query($o, $w);
        $current_module_strings = return_module_language($current_language, $module_name);
        $object = new $object_name();
        $seedUsersLastImport->list_fields = $object->list_fields;
        $list_result = $adb->query($list_query);
        //Retreiving the no of rows
        $noofrows = $adb->num_rows($list_result);
        if ($noofrows >= 1) {
            if ($module_name != 'Accounts') {
                $implict_account = true;
            }
            if ($module_name == 'Accounts' && $implict_account == true) {
                $display_header_msg = "Newly created Accounts";
            } else {

 /**
  * If a bean save is not done for some reason, this method will undo any of the beans that were created
  *
  * @param array $ids ids of user_last_import records created
  */
 protected function _undoCreatedBeans(array $ids)
 {
     $focus = new UsersLastImport();
     foreach ($ids as $id) {
         $focus->undoById($id);
     }
 }

//.........这里部分代码省略.........
            }
        }
        p("do save=" . $do_save);
        if ($do_save) {
            p("saving..");
            if (!isset($focus->column_fields["assigned_user_id"]) || $focus->column_fields["assigned_user_id"] == '') {
                //$focus->column_fields["assigned_user_id"] = $current_user->id;
                //MWC
                $focus->column_fields["assigned_user_id"] = $my_userid;
            }
            //handle uitype 10
            foreach ($focus->importable_fields as $fieldname => $uitype) {
                $uitype = $focus->importable_fields[$fieldname];
                if ($uitype == 10) {
                    //added to handle security permissions for related modules :: for e.g. Accounts/Contacts in Potentials
                    if (method_exists($focus, "add_related_to")) {
                        if (!$focus->add_related_to($module, $fieldname)) {
                            if (array_key_exists($fieldname, $focus->required_fields)) {
                                $do_save = 0;
                                $skip_required_count++;
                                continue 2;
                            }
                        }
                    }
                }
            }
            // now do any special processing for ex., map account with contact and potential
            if ($process_fields == 'false') {
                $focus->process_special_fields();
            }
            $focus->saveentity($module);
            //$focus->saveentity($module);
            $return_id = $focus->id;
            $last_import = new UsersLastImport();
            $last_import->assigned_user_id = $current_user->id;
            $last_import->bean_type = $_REQUEST['module'];
            $last_import->bean_id = $focus->id;
            $last_import->save();
            $count++;
        }
        $ii++;
    }
    $_REQUEST['count'] = $ii;
    if (isset($_REQUEST['module'])) {
        $modulename = vtlib_purify($_REQUEST['module']);
    }
    $end = $start + $recordcount;
    $START = $start + $recordcount;
    $RECORDCOUNT = $recordcount;
    $dup_check_type = $_REQUEST['dup_type'];
    $auto_dup_type = $_REQUEST['auto_type'];
    if ($end >= $totalnoofrows) {
        $module = 'Import';
        //$_REQUEST['module'];
        $action = 'ImportSteplast';
        //exit;
        $imported_records = $totalnoofrows - $skip_required_count;
        if ($imported_records == $totalnoofrows) {
            $skip_required_count = 0;
        }
        if ($dup_check_type == "auto") {
            if ($auto_dup_type == "ignore") {
                $dup_info = $mod_strings['Duplicate_Records_Skipped_Info'] . $dup_count;
                $imported_records -= $dup_count;
            } else {
                if ($auto_dup_type == "overwrite") {

 public function testGetBeansByImport()
 {
     foreach (UsersLastImport::getBeansByImport('Notes') as $objectName) {
         $this->assertEquals($objectName, 'Note');
     }
 }

 /**
  * @see SugarView::display()
  */
 public function display()
 {
     global $mod_strings, $app_strings, $current_user, $sugar_config, $current_language;
     $this->ss->assign("IMPORT_MODULE", $_REQUEST['import_module']);
     $this->ss->assign("TYPE", $_REQUEST['type']);
     $this->ss->assign("HEADER", $app_strings['LBL_IMPORT'] . " " . $mod_strings['LBL_MODULE_NAME']);
     $this->ss->assign("MODULE_TITLE", $this->getModuleTitle(false));
     // lookup this module's $mod_strings to get the correct module name
     $module_mod_strings = return_module_language($current_language, $_REQUEST['import_module']);
     $this->ss->assign("MODULENAME", $module_mod_strings['LBL_MODULE_NAME']);
     // read status file to get totals for records imported, errors, and duplicates
     $count = 0;
     $errorCount = 0;
     $dupeCount = 0;
     $createdCount = 0;
     $updatedCount = 0;
     $fp = sugar_fopen(ImportCacheFiles::getStatusFileName(), 'r');
     while (($row = fgetcsv($fp, 8192)) !== FALSE) {
         $count += (int) $row[0];
         $errorCount += (int) $row[1];
         $dupeCount += (int) $row[2];
         $createdCount += (int) $row[3];
         $updatedCount += (int) $row[4];
     }
     fclose($fp);
     $this->ss->assign("showUndoButton", FALSE);
     if ($createdCount > 0) {
         $this->ss->assign("showUndoButton", TRUE);
     }
     if ($errorCount > 0 && ($createdCount <= 0 && $updatedCount <= 0)) {
         $activeTab = 2;
     } else {
         if ($dupeCount > 0 && ($createdCount <= 0 && $updatedCount <= 0)) {
             $activeTab = 1;
         } else {
             $activeTab = 0;
         }
     }
     $this->ss->assign("JAVASCRIPT", $this->_getJS($activeTab));
     $this->ss->assign("errorCount", $errorCount);
     $this->ss->assign("dupeCount", $dupeCount);
     $this->ss->assign("createdCount", $createdCount);
     $this->ss->assign("updatedCount", $updatedCount);
     $this->ss->assign("errorFile", ImportCacheFiles::convertFileNameToUrl(ImportCacheFiles::getErrorFileName()));
     $this->ss->assign("errorrecordsFile", ImportCacheFiles::convertFileNameToUrl(ImportCacheFiles::getErrorRecordsWithoutErrorFileName()));
     $this->ss->assign("dupeFile", ImportCacheFiles::convertFileNameToUrl(ImportCacheFiles::getDuplicateFileName()));
     if ($this->bean->object_name == "Prospect") {
         $this->ss->assign("PROSPECTLISTBUTTON", $this->_addToProspectListButton());
     } else {
         $this->ss->assign("PROSPECTLISTBUTTON", "");
     }
     $resultsTable = "";
     foreach (UsersLastImport::getBeansByImport($_REQUEST['import_module']) as $beanname) {
         // load bean
         if (!$this->bean instanceof $beanname) {
             $this->bean = new $beanname();
         }
         $resultsTable .= $this->getListViewResults();
     }
     if (empty($resultsTable)) {
         $resultsTable = $this->getListViewResults();
     }
     $this->ss->assign("RESULTS_TABLE", $resultsTable);
     $this->ss->assign("ERROR_TABLE", $this->getListViewTableFromFile(ImportCacheFiles::getErrorRecordsFileName(), 'errors'));
     $this->ss->assign("DUP_TABLE", $this->getListViewTableFromFile(ImportCacheFiles::getDuplicateFileDisplayName(), 'dup'));
     $content = $this->ss->fetch('modules/Import/tpls/last.tpl');
     $this->ss->assign("CONTENT", $content);
     $this->ss->display('modules/Import/tpls/wizardWrapper.tpl');
 }

 /** 
  * @see SugarView::display()
  */
 public function display()
 {
     global $mod_strings, $app_strings, $current_user, $sugar_config, $current_language;
     $this->ss->assign("MOD", $mod_strings);
     $this->ss->assign("APP", $app_strings);
     $this->ss->assign("IMPORT_MODULE", $_REQUEST['import_module']);
     $this->ss->assign("TYPE", $_REQUEST['type']);
     $this->ss->assign("HEADER", $app_strings['LBL_IMPORT'] . " " . $mod_strings['LBL_MODULE_NAME']);
     $this->ss->assign("MODULE_TITLE", $this->getModuleTitle());
     // lookup this module's $mod_strings to get the correct module name
     $language = isset($current_language) ? $current_language : $sugar_config['default_language'];
     $module_mod_strings = return_module_language($current_language, $_REQUEST['import_module']);
     $this->ss->assign("MODULENAME", $module_mod_strings['LBL_MODULE_NAME']);
     $this->ss->assign("JAVASCRIPT", $this->_getJS());
     // read status file to get totals for records imported, errors, and duplicates
     $count = 0;
     $errorCount = 0;
     $dupeCount = 0;
     $createdCount = 0;
     $updatedCount = 0;
     $fp = sugar_fopen(ImportCacheFiles::getStatusFileName(), 'r');
     while (($row = fgetcsv($fp, 8192)) !== FALSE) {
         $count += (int) $row[0];
         $errorCount += (int) $row[1];
         $dupeCount += (int) $row[2];
         $createdCount += (int) $row[3];
         $updatedCount += (int) $row[4];
     }
     fclose($fp);
     $this->ss->assign("errorCount", $errorCount);
     $this->ss->assign("dupeCount", $dupeCount);
     $this->ss->assign("createdCount", $createdCount);
     $this->ss->assign("updatedCount", $updatedCount);
     $this->ss->assign("errorFile", ImportCacheFiles::getErrorFileName());
     $this->ss->assign("errorrecordsFile", ImportCacheFiles::getErrorRecordsFileName());
     $this->ss->assign("dupeFile", ImportCacheFiles::getDuplicateFileName());
     // load bean
     $focus = loadImportBean($_REQUEST['import_module']);
     if (!$focus) {
         showImportError($mod_strings['LBL_ERROR_IMPORTS_NOT_SET_UP'], $_REQUEST['import_module']);
         return;
     }
     if ($focus->object_name == "Prospect") {
         $this->ss->assign("PROSPECTLISTBUTTON", $this->_addToProspectListButton());
     } else {
         $this->ss->assign("PROSPECTLISTBUTTON", "");
     }
     $this->ss->display('modules/Import/tpls/last.tpl');
     foreach (UsersLastImport::getBeansByImport($_REQUEST['import_module']) as $beanname) {
         // load bean
         if (!$focus instanceof $beanname) {
             require_once $GLOBALS['beanFiles'][$beanname];
             $focus = new $beanname();
         }
         // build listview to show imported records
         require_once 'include/ListView/ListViewFacade.php';
         $lvf = new ListViewFacade($focus, $focus->module_dir, 0);
         $params = array();
         if (!empty($_REQUEST['orderBy'])) {
             $params['orderBy'] = $_REQUEST['orderBy'];
             $params['overrideOrder'] = true;
             if (!empty($_REQUEST['sortOrder'])) {
                 $params['sortOrder'] = $_REQUEST['sortOrder'];
             }
         }
         $beanname = $focus->object_name == 'Case' ? 'aCase' : $focus->object_name;
         // add users_last_import joins so we only show records done in this import
         $params['custom_from'] = ', users_last_import';
         $params['custom_where'] = " AND users_last_import.assigned_user_id = '{$GLOBALS['current_user']->id}' \n                AND users_last_import.bean_type = '{$beanname}' \n                AND users_last_import.bean_id = {$focus->table_name}.id \n                AND users_last_import.deleted = 0 \n                AND {$focus->table_name}.deleted = 0";
         $where = " {$focus->table_name}.id IN ( \n                        SELECT users_last_import.bean_id\n                            FROM users_last_import\n                            WHERE users_last_import.assigned_user_id = '{$GLOBALS['current_user']->id}' \n                                AND users_last_import.bean_type = '{$beanname}' \n                                AND users_last_import.deleted = 0 )";
         $lbl_last_imported = $mod_strings['LBL_LAST_IMPORTED'];
         $lvf->lv->mergeduplicates = false;
         $module_mod_strings = return_module_language($current_language, $focus->module_dir);
         $lvf->setup('', $where, $params, $module_mod_strings, 0, -1, '', strtoupper($beanname), array(), 'id');
         $lvf->display($lbl_last_imported . ": " . $module_mod_strings['LBL_MODULE_NAME']);
     }
 }

 /**
  * @see SugarView::display()
  */
 public function display()
 {
     global $mod_strings, $app_strings, $current_user;
     global $sugar_config, $locale;
     $this->ss->assign("IMPORT_MODULE", $_REQUEST['import_module']);
     $this->ss->assign("TYPE", !empty($_REQUEST['type']) ? $_REQUEST['type'] : "import");
     $this->ss->assign("SOURCE_ID", $_REQUEST['source_id']);
     $this->instruction = 'LBL_SELECT_PROPERTY_INSTRUCTION';
     $this->ss->assign('INSTRUCTION', $this->getInstruction());
     $this->ss->assign("MODULE_TITLE", $this->getModuleTitle(false), ENT_NOQUOTES);
     $this->ss->assign("CURRENT_STEP", $this->currentStep);
     $sugar_config['import_max_records_per_file'] = empty($sugar_config['import_max_records_per_file']) ? 1000 : $sugar_config['import_max_records_per_file'];
     $importSource = isset($_REQUEST['source']) ? $_REQUEST['source'] : 'csv';
     // Clear out this user's last import
     $seedUsersLastImport = new UsersLastImport();
     $seedUsersLastImport->mark_deleted_by_user_id($current_user->id);
     ImportCacheFiles::clearCacheFiles();
     // handle uploaded file
     $uploadFile = new UploadFile('userfile');
     if (isset($_FILES['userfile']) && $uploadFile->confirm_upload()) {
         $uploadFile->final_move('IMPORT_' . $this->bean->object_name . '_' . $current_user->id);
         $uploadFileName = $uploadFile->get_upload_path('IMPORT_' . $this->bean->object_name . '_' . $current_user->id);
     } elseif (!empty($_REQUEST['tmp_file'])) {
         $uploadFileName = "upload://" . basename($_REQUEST['tmp_file']);
     } else {
         $this->_showImportError($mod_strings['LBL_IMPORT_MODULE_ERROR_NO_UPLOAD'], $_REQUEST['import_module'], 'Step2', true, null, true);
         return;
     }
     //check the file size, we dont want to process an empty file
     if (isset($_FILES['userfile']['size']) && $_FILES['userfile']['size'] == 0) {
         //this file is empty, throw error message
         $this->_showImportError($mod_strings['LBL_NO_LINES'], $_REQUEST['import_module'], 'Step2', false, null, true);
         return;
     }
     $mimeTypeOk = true;
     //check to see if the file mime type is not a form of text or application octed streramand fire error if not
     if (isset($_FILES['userfile']['type']) && strpos($_FILES['userfile']['type'], 'octet-stream') === false && strpos($_FILES['userfile']['type'], 'text') === false && strpos($_FILES['userfile']['type'], 'application/vnd.ms-excel') === false) {
         //this file does not have a known text or application type of mime type, issue the warning
         $error_msgs[] = $mod_strings['LBL_MIME_TYPE_ERROR_1'];
         $error_msgs[] = $mod_strings['LBL_MIME_TYPE_ERROR_2'];
         $this->_showImportError($error_msgs, $_REQUEST['import_module'], 'Step2', true, $mod_strings['LBL_OK']);
         $mimeTypeOk = false;
     }
     $this->ss->assign("FILE_NAME", $uploadFileName);
     // Now parse the file and look for errors
     $importFile = new ImportFile($uploadFileName, $_REQUEST['custom_delimiter'], html_entity_decode($_REQUEST['custom_enclosure'], ENT_QUOTES), FALSE);
     if ($this->shouldAutoDetectProperties($importSource)) {
         $GLOBALS['log']->debug("Auto detecing csv properties...");
         $autoDetectOk = $importFile->autoDetectCSVProperties();
         $importFileMap = array();
         $this->ss->assign("SOURCE", 'csv');
         if ($autoDetectOk === FALSE) {
             //show error only if previous mime type check has passed
             if ($mimeTypeOk) {
                 $this->ss->assign("AUTO_DETECT_ERROR", $mod_strings['LBL_AUTO_DETECT_ERROR']);
             }
         } else {
             $dateFormat = $importFile->getDateFormat();
             $timeFormat = $importFile->getTimeFormat();
             if ($dateFormat) {
                 $importFileMap['importlocale_dateformat'] = $dateFormat;
             }
             if ($timeFormat) {
                 $importFileMap['importlocale_timeformat'] = $timeFormat;
             }
         }
     } else {
         $impotMapSeed = $this->getImportMap($importSource);
         $importFile->setImportFileMap($impotMapSeed);
         $importFileMap = $impotMapSeed->getMapping($_REQUEST['import_module']);
     }
     $delimeter = $importFile->getFieldDelimeter();
     $enclosure = $importFile->getFieldEnclosure();
     $hasHeader = $importFile->hasHeaderRow();
     $encodeOutput = TRUE;
     //Handle users navigating back through the wizard.
     if (!empty($_REQUEST['previous_action']) && $_REQUEST['previous_action'] == 'Confirm') {
         $encodeOutput = FALSE;
         $importFileMap = $this->overloadImportFileMapFromRequest($importFileMap);
         $delimeter = !empty($_REQUEST['custom_delimiter']) ? $_REQUEST['custom_delimiter'] : $delimeter;
         $enclosure = isset($_REQUEST['custom_enclosure']) ? $_REQUEST['custom_enclosure'] : $enclosure;
         $enclosure = html_entity_decode($enclosure, ENT_QUOTES);
         $hasHeader = !empty($_REQUEST['has_header']) ? $_REQUEST['has_header'] : $hasHeader;
         if ($hasHeader == 'on') {
             $hasHeader = true;
         } else {
             if ($hasHeader == 'off') {
                 $hasHeader = false;
             }
         }
     }
     $this->ss->assign("IMPORT_ENCLOSURE_OPTIONS", $this->getEnclosureOptions($enclosure));
     $this->ss->assign("IMPORT_DELIMETER_OPTIONS", $this->getDelimeterOptions($delimeter));
     $this->ss->assign("CUSTOM_DELIMITER", $delimeter);
     $this->ss->assign("CUSTOM_ENCLOSURE", htmlentities($enclosure, ENT_QUOTES));
     $hasHeaderFlag = $hasHeader ? " CHECKED" : "";
     $this->ss->assign("HAS_HEADER_CHECKED", $hasHeaderFlag);
//.........这里部分代码省略.........