modules/Import/Importer.php

   1 <?php
   2 if(!defined('sugarEntry') || !sugarEntry) die('Not A Valid Entry Point');
   3
   4 /*********************************************************************************
   5  * SugarCRM Community Edition is a customer relationship management program developed by
   6  * SugarCRM, Inc. Copyright (C) 2004-2012 SugarCRM Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it under
   9  * the terms of the GNU Affero General Public License version 3 as published by the
  10  * Free Software Foundation with the addition of the following permission added
  11  * to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED WORK
  12  * IN WHICH THE COPYRIGHT IS OWNED BY SUGARCRM, SUGARCRM DISCLAIMS THE WARRANTY
  13  * OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
  14  *
  15  * This program is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17  * FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU Affero General Public License along with
  21  * this program; if not, see http://www.gnu.org/licenses or write to the Free
  22  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23  * 02110-1301 USA.
  24  *
  25  * You can contact SugarCRM, Inc. headquarters at 10050 North Wolfe Road,
  26  * SW2-130, Cupertino, CA 95014, USA. or at email address contact@sugarcrm.com.
  27  *
  28  * The interactive user interfaces in modified source and object code versions
  29  * of this program must display Appropriate Legal Notices, as required under
  30  * Section 5 of the GNU Affero General Public License version 3.
  31  *
  32  * In accordance with Section 7(b) of the GNU Affero General Public License version 3,
  33  * these Appropriate Legal Notices must retain the display of the "Powered by
  34  * SugarCRM" logo. If the display of the logo is not reasonably feasible for
  35  * technical reasons, the Appropriate Legal Notices must display the words
  36  * "Powered by SugarCRM".
  37  ********************************************************************************/
  38
  39
  40 require_once('modules/Import/ImportCacheFiles.php');
  41 require_once('modules/Import/ImportFieldSanitize.php');
  42 require_once('modules/Import/ImportDuplicateCheck.php');
  43
  44
  45 class Importer
  46 {
  47     /**
  48      * @var ImportFieldSanitizer
  49      */
  50     protected $ifs;
  51
  52     /**
  53      * @var Currency
  54      */
  55     protected $defaultUserCurrency;
  56
  57     /**
  58      * @var importColumns
  59      */
  60     protected $importColumns;
  61
  62     /**
  63      * @var importSource
  64      */
  65     protected $importSource;
  66
  67     /**
  68      * @var $isUpdateOnly
  69      */
  70     protected $isUpdateOnly;
  71
  72     /**
  73      * @var  $bean
  74      */
  75     protected $bean;
  76
  77     /**
  78      * @var sugarToExternalSourceFieldMap
  79      */
  80     protected $sugarToExternalSourceFieldMap = array();
  81
  82
  83     public function __construct($importSource, $bean)
  84     {
  85         global $mod_strings, $sugar_config;
  86
  87         $this->importSource = $importSource;
  88
  89         //Vanilla copy of the bean object.
  90         $this->bean = $bean;
  91
  92         // use our own error handler
  93         set_error_handler(array('Importer','handleImportErrors'),E_ALL);
  94
  95          // Increase the max_execution_time since this step can take awhile
  96         ini_set("max_execution_time", max($sugar_config['import_max_execution_time'],3600));
  97
  98         // stop the tracker
  99         TrackerManager::getInstance()->pause();
 100
 101         // set the default locale settings
 102         $this->ifs = $this->getFieldSanitizer();
 103
 104         //Get the default user currency
 105         $this->defaultUserCurrency = new Currency();
 106         $this->defaultUserCurrency->retrieve('-99');
 107
 108         //Get our import column definitions
 109         $this->importColumns = $this->getImportColumns();
 110         $this->isUpdateOnly = ( isset($_REQUEST['import_type']) && $_REQUEST['import_type'] == 'update' );
 111     }
 112
 113     public function import()
 114     {
 115         foreach($this->importSource as $row)
 116         {
 117             $this->importRow($row);
 118         }
 119
 120         // save mapping if requested
 121         if ( isset($_REQUEST['save_map_as']) && $_REQUEST['save_map_as'] != '' )
 122         {
 123             $this->saveMappingFile();
 124         }
 125
 126         $this->importSource->writeStatus();
 127
 128         //All done, remove file.
 129     }
 130
 131
 132     protected function importRow($row)
 133     {
 134         global $sugar_config, $mod_strings, $current_user;
 135
 136         $focus = clone $this->bean;
 137         $focus->unPopulateDefaultValues();
 138         $focus->save_from_post = false;
 139         $focus->team_id = null;
 140         $this->ifs->createdBeans = array();
 141         $this->importSource->resetRowErrorCounter();
 142         $do_save = true;
 143
 144         for ( $fieldNum = 0; $fieldNum < $_REQUEST['columncount']; $fieldNum++ )
 145         {
 146             // loop if this column isn't set
 147             if ( !isset($this->importColumns[$fieldNum]) )
 148                 continue;
 149
 150             // get this field's properties
 151             $field           = $this->importColumns[$fieldNum];
 152             $fieldDef        = $focus->getFieldDefinition($field);
 153             $fieldTranslated = translate((isset($fieldDef['vname'])?$fieldDef['vname']:$fieldDef['name']), $focus->module_dir)." (".$fieldDef['name'].")";
 154             $defaultRowValue = '';
 155             // Bug 37241 - Don't re-import over a field we already set during the importing of another field
 156             if ( !empty($focus->$field) )
 157                 continue;
 158
 159             // translate strings
 160             global $locale;
 161             if(empty($locale))
 162             {
 163                 $locale = new Localization();
 164             }
 165             if ( isset($row[$fieldNum]) )
 166             {
 167                 $rowValue = $locale->translateCharset(strip_tags(trim($row[$fieldNum])),$this->importSource->importlocale_charset,$sugar_config['default_charset']);
 168             }
 169             else if( isset($this->sugarToExternalSourceFieldMap[$field]) && isset($row[$this->sugarToExternalSourceFieldMap[$field]]) )
 170             {
 171                 $rowValue = $locale->translateCharset(strip_tags(trim($row[$this->sugarToExternalSourceFieldMap[$field]])),$this->importSource->importlocale_charset,$sugar_config['default_charset']);
 172             }
 173             else
 174             {
 175                 $rowValue = '';
 176             }
 177
 178             // If there is an default value then use it instead
 179             if ( !empty($_REQUEST[$field]) )
 180             {
 181                 $defaultRowValue = $this->populateDefaultMapValue($field, $_REQUEST[$field], $fieldDef);
 182
 183
 184                 if( empty($rowValue))
 185                 {
 186                     $rowValue = $defaultRowValue;
 187                     //reset the default value to empty
 188                     $defaultRowValue='';
 189                 }
 190             }
 191
 192             // Bug 22705 - Don't update the First Name or Last Name value if Full Name is set
 193             if ( in_array($field, array('first_name','last_name')) && !empty($focus->full_name) )
 194                 continue;
 195
 196             // loop if this value has not been set
 197             if ( !isset($rowValue) )
 198                 continue;
 199
 200             // If the field is required and blank then error out
 201             if ( array_key_exists($field,$focus->get_import_required_fields()) && empty($rowValue) && $rowValue!='0')
 202             {
 203                 $this->importSource->writeError( $mod_strings['LBL_REQUIRED_VALUE'],$fieldTranslated,'NULL');
 204                 $do_save = false;
 205             }
 206
 207             // Handle the special case "Sync to Outlook"
 208             if ( $focus->object_name == "Contact" && $field == 'sync_contact' )
 209             {
 210                 /**
 211                  * Bug #41194 : if true used as value of sync_contact - add curent user to list to sync
 212                  */
 213                 if ( true == $rowValue || 'true' == strtolower($rowValue)) {
 214                     $focus->sync_contact = $focus->id;
 215                 } elseif (false == $rowValue || 'false' == strtolower($rowValue)) {
 216                     $focus->sync_contact = '';
 217                 } else {
 218                     $bad_names = array();
 219                     $returnValue = $this->ifs->synctooutlook($rowValue,$fieldDef,$bad_names);
 220                     // try the default value on fail
 221                     if ( !$returnValue && !empty($defaultRowValue) )
 222                         $returnValue = $this->ifs->synctooutlook($defaultRowValue, $fieldDef, $bad_names);
 223                     if ( !$returnValue )
 224                     {
 225                         $this->importSource->writeError($mod_strings['LBL_ERROR_SYNC_USERS'], $fieldTranslated, $bad_names);
 226                         $do_save = 0;
 227                     } else {
 228                         $focus->sync_contact = $returnValue;
 229                     }
 230                 }
 231             }
 232
 233             // Handle email1 and email2 fields ( these don't have the type of email )
 234             if ( $field == 'email1' || $field == 'email2' )
 235             {
 236                 $returnValue = $this->ifs->email($rowValue, $fieldDef, $focus);
 237                 // try the default value on fail
 238                 if ( !$returnValue && !empty($defaultRowValue) )
 239                     $returnValue = $this->ifs->email( $defaultRowValue, $fieldDef);
 240                 if ( $returnValue === FALSE )
 241                 {
 242                     $do_save=0;
 243                     $this->importSource->writeError( $mod_strings['LBL_ERROR_INVALID_EMAIL'], $fieldTranslated, $rowValue);
 244                 }
 245                 else
 246                 {
 247                     $rowValue = $returnValue;
 248                     // check for current opt_out and invalid email settings for this email address
 249                     // if we find any, set them now
 250                     $emailres = $focus->db->query( "SELECT opt_out, invalid_email FROM email_addresses WHERE email_address = '".$focus->db->quote($rowValue)."'");
 251                     if ( $emailrow = $focus->db->fetchByAssoc($emailres) )
 252                     {
 253                         $focus->email_opt_out = $emailrow['opt_out'];
 254                         $focus->invalid_email = $emailrow['invalid_email'];
 255                     }
 256                 }
 257             }
 258
 259             // Handle splitting Full Name into First and Last Name parts
 260             if ( $field == 'full_name' && !empty($rowValue) )
 261             {
 262                 $this->ifs->fullname($rowValue,$fieldDef,$focus);
 263             }
 264
 265             // to maintain 451 compatiblity
 266             if(!isset($fieldDef['module']) && $fieldDef['type']=='relate')
 267                 $fieldDef['module'] = ucfirst($fieldDef['table']);
 268
 269             if(isset($fieldDef['custom_type']) && !empty($fieldDef['custom_type']))
 270                 $fieldDef['type'] = $fieldDef['custom_type'];
 271
 272             // If the field is empty then there is no need to check the data
 273             if( !empty($rowValue) )
 274             {
 275                 //Start
 276                 $rowValue = $this->sanitizeFieldValueByType($rowValue, $fieldDef, $defaultRowValue, $focus, $fieldTranslated);
 277                 if ($rowValue === FALSE) {
 278                                         /* BUG 51213 - jeff @ neposystems.com */
 279                     $do_save = false;
 280                     continue;
 281                                 }
 282             }
 283
 284             // if the parent type is in singular form, get the real module name for parent_type
 285             if (isset($fieldDef['type']) && $fieldDef['type']=='parent_type') {
 286                 $rowValue = get_module_from_singular($rowValue);
 287             }
 288
 289             $focus->$field = $rowValue;
 290             unset($defaultRowValue);
 291         }
 292
 293         // Now try to validate flex relate fields
 294         if ( isset($focus->field_defs['parent_name']) && isset($focus->parent_name) && ($focus->field_defs['parent_name']['type'] == 'parent') )
 295         {
 296             // populate values from the picker widget if the import file doesn't have them
 297             $parent_idField = $focus->field_defs['parent_name']['id_name'];
 298             if ( empty($focus->$parent_idField) && !empty($_REQUEST[$parent_idField]) )
 299                 $focus->$parent_idField = $_REQUEST[$parent_idField];
 300
 301             $parent_typeField = $focus->field_defs['parent_name']['type_name'];
 302
 303             if ( empty($focus->$parent_typeField) && !empty($_REQUEST[$parent_typeField]) )
 304                 $focus->$parent_typeField = $_REQUEST[$parent_typeField];
 305             // now validate it
 306             $returnValue = $this->ifs->parent($focus->parent_name,$focus->field_defs['parent_name'],$focus, empty($_REQUEST['parent_name']));
 307             if ( !$returnValue && !empty($_REQUEST['parent_name']) )
 308                 $returnValue = $this->ifs->parent( $_REQUEST['parent_name'],$focus->field_defs['parent_name'], $focus);
 309         }
 310
 311         // check to see that the indexes being entered are unique.
 312         if (isset($_REQUEST['enabled_dupes']) && $_REQUEST['enabled_dupes'] != "")
 313         {
 314             $toDecode = html_entity_decode  ($_REQUEST['enabled_dupes'], ENT_QUOTES);
 315             $enabled_dupes = json_decode($toDecode);
 316             $idc = new ImportDuplicateCheck($focus);
 317
 318             if ( $idc->isADuplicateRecord($enabled_dupes) )
 319             {
 320                 $this->importSource->markRowAsDuplicate($idc->_dupedFields);
 321                 $this->_undoCreatedBeans($this->ifs->createdBeans);
 322                 return;
 323             }
 324         }
 325         //Allow fields to be passed in for dup check as well (used by external adapters)
 326         else if( !empty($_REQUEST['enabled_dup_fields']) )
 327         {
 328             $toDecode = html_entity_decode  ($_REQUEST['enabled_dup_fields'], ENT_QUOTES);
 329             $enabled_dup_fields = json_decode($toDecode);
 330             $idc = new ImportDuplicateCheck($focus);
 331             if ( $idc->isADuplicateRecordByFields($enabled_dup_fields) )
 332             {
 333                 $this->importSource->markRowAsDuplicate($idc->_dupedFields);
 334                 $this->_undoCreatedBeans($this->ifs->createdBeans);
 335                 return;
 336             }
 337         }
 338
 339         // if the id was specified
 340         $newRecord = true;
 341         if ( !empty($focus->id) )
 342         {
 343             $focus->id = $this->_convertId($focus->id);
 344
 345             // check if it already exists
 346             $query = "SELECT * FROM {$focus->table_name} WHERE id='".$focus->db->quote($focus->id)."'";
 347             $result = $focus->db->query($query)
 348             or sugar_die("Error selecting sugarbean: ");
 349
 350             $dbrow = $focus->db->fetchByAssoc($result);
 351
 352             if (isset ($dbrow['id']) && $dbrow['id'] != -1)
 353             {
 354                 // if it exists but was deleted, just remove it
 355                 if (isset ($dbrow['deleted']) && $dbrow['deleted'] == 1 && $this->isUpdateOnly ==false)
 356                 {
 357                     $this->removeDeletedBean($focus);
 358                     $focus->new_with_id = true;
 359                 }
 360                 else
 361                 {
 362                     if( ! $this->isUpdateOnly )
 363                     {
 364                         $this->importSource->writeError($mod_strings['LBL_ID_EXISTS_ALREADY'],'ID',$focus->id);
 365                         $this->_undoCreatedBeans($this->ifs->createdBeans);
 366                         return;
 367                     }
 368
 369                     $clonedBean = $this->cloneExistingBean($focus);
 370                     if($clonedBean === FALSE)
 371                     {
 372                         $this->importSource->writeError($mod_strings['LBL_RECORD_CANNOT_BE_UPDATED'],'ID',$focus->id);
 373                         $this->_undoCreatedBeans($this->ifs->createdBeans);
 374                         return;
 375                     }
 376                     else
 377                     {
 378                         $focus = $clonedBean;
 379                         $newRecord = FALSE;
 380                     }
 381                 }
 382             }
 383             else
 384             {
 385                 $focus->new_with_id = true;
 386             }
 387         }
 388
 389         if ($do_save)
 390         {
 391             $this->saveImportBean($focus, $newRecord);
 392             // Update the created/updated counter
 393             $this->importSource->markRowAsImported($newRecord);
 394         }
 395         else
 396             $this->_undoCreatedBeans($this->ifs->createdBeans);
 397
 398         unset($defaultRowValue);
 399
 400     }
 401
 402
 403     protected function sanitizeFieldValueByType($rowValue, $fieldDef, $defaultRowValue, $focus, $fieldTranslated)
 404     {
 405         global $mod_strings, $app_list_strings;
 406         switch ($fieldDef['type'])
 407         {
 408             case 'enum':
 409             case 'multienum':
 410                 if ( isset($fieldDef['type']) && $fieldDef['type'] == "multienum" )
 411                     $returnValue = $this->ifs->multienum($rowValue,$fieldDef);
 412                 else
 413                     $returnValue = $this->ifs->enum($rowValue,$fieldDef);
 414                 // try the default value on fail
 415                 if ( !$returnValue && !empty($defaultRowValue) )
 416                 {
 417                     if ( isset($fieldDef['type']) && $fieldDef['type'] == "multienum" )
 418                         $returnValue = $this->ifs->multienum($defaultRowValue,$fieldDef);
 419                     else
 420                         $returnValue = $this->ifs->enum($defaultRowValue,$fieldDef);
 421                 }
 422                 if ( $returnValue === FALSE )
 423                 {
 424                     $this->importSource->writeError($mod_strings['LBL_ERROR_NOT_IN_ENUM'] . implode(",",$app_list_strings[$fieldDef['options']]), $fieldTranslated,$rowValue);
 425                     return FALSE;
 426                 }
 427                 else
 428                     return $returnValue;
 429
 430                 break;
 431             case 'relate':
 432             case 'parent':
 433                 $returnValue = $this->ifs->relate($rowValue, $fieldDef, $focus, empty($defaultRowValue));
 434                 if (!$returnValue && !empty($defaultRowValue))
 435                     $returnValue = $this->ifs->relate($defaultRowValue,$fieldDef, $focus);
 436                 // Bug 33623 - Set the id value found from the above method call as an importColumn
 437                 if ($returnValue !== false)
 438                     $this->importColumns[] = $fieldDef['id_name'];
 439                 return $rowValue;
 440                 break;
 441             case 'teamset':
 442                 $this->ifs->teamset($rowValue,$fieldDef,$focus);
 443                 $this->importColumns[] = 'team_set_id';
 444                 $this->importColumns[] = 'team_id';
 445                 return $rowValue;
 446                 break;
 447             case 'fullname':
 448                 return $rowValue;
 449                 break;
 450             default:
 451                 $fieldtype = $fieldDef['type'];
 452                 $returnValue = $this->ifs->$fieldtype($rowValue, $fieldDef, $focus);
 453                 // try the default value on fail
 454                 if ( !$returnValue && !empty($defaultRowValue) )
 455                     $returnValue = $this->ifs->$fieldtype($defaultRowValue,$fieldDef, $focus);
 456                 if ( !$returnValue )
 457                 {
 458                     $this->importSource->writeError($mod_strings['LBL_ERROR_INVALID_'.strtoupper($fieldDef['type'])],$fieldTranslated,$rowValue,$focus);
 459                     return FALSE;
 460                 }
 461                 return $returnValue;
 462         }
 463     }
 464
 465     protected function cloneExistingBean($focus)
 466     {
 467         $existing_focus = clone $this->bean;
 468         if ( !( $existing_focus->retrieve($focus->id) instanceOf SugarBean ) )
 469         {
 470             return FALSE;
 471         }
 472         else
 473         {
 474             $newData = $focus->toArray();
 475             foreach ( $newData as $focus_key => $focus_value )
 476                 if ( in_array($focus_key,$this->importColumns) )
 477                     $existing_focus->$focus_key = $focus_value;
 478
 479             return $existing_focus;
 480         }
 481     }
 482
 483     protected function removeDeletedBean($focus)
 484     {
 485         global $mod_strings;
 486
 487         $query2 = "DELETE FROM {$focus->table_name} WHERE id='".$focus->db->quote($focus->id)."'";
 488         $result2 = $focus->db->query($query2) or sugar_die($mod_strings['LBL_ERROR_DELETING_RECORD']." ".$focus->id);
 489         if ($focus->hasCustomFields())
 490         {
 491             $query3 = "DELETE FROM {$focus->table_name}_cstm WHERE id_c='".$focus->db->quote($focus->id)."'";
 492             $result2 = $focus->db->query($query3);
 493         }
 494     }
 495
 496     protected function saveImportBean($focus, $newRecord)
 497     {
 498         global $timedate, $current_user;
 499
 500         // Populate in any default values to the bean
 501         $focus->populateDefaultValues();
 502
 503         if ( !isset($focus->assigned_user_id) || $focus->assigned_user_id == '' && $newRecord )
 504         {
 505             $focus->assigned_user_id = $current_user->id;
 506         }
 507         /*
 508         * Bug 34854: Added all conditions besides the empty check on date modified.
 509         */
 510         if ( ( !empty($focus->new_with_id) && !empty($focus->date_modified) ) ||
 511              ( empty($focus->new_with_id) && $timedate->to_db($focus->date_modified) != $timedate->to_db($timedate->to_display_date_time($focus->fetched_row['date_modified'])) )
 512         )
 513             $focus->update_date_modified = false;
 514
 515         $focus->optimistic_lock = false;
 516         if ( $focus->object_name == "Contact" && isset($focus->sync_contact) )
 517         {
 518             //copy the potential sync list to another varible
 519             $list_of_users=$focus->sync_contact;
 520             //and set it to false for the save
 521             $focus->sync_contact=false;
 522         }
 523         else if($focus->object_name == "User" && !empty($current_user) && $focus->is_admin && !is_admin($current_user) && is_admin_for_module($current_user, 'Users')) {
 524             sugar_die($GLOBALS['mod_strings']['ERR_IMPORT_SYSTEM_ADMININSTRATOR']);
 525         }
 526         //bug# 46411 importing Calls will not populate Leads or Contacts Subpanel
 527         if (!empty($focus->parent_type) && !empty($focus->parent_id))
 528         {
 529             foreach ($focus->relationship_fields as $key => $val)
 530             {
 531                 if ($val == strtolower($focus->parent_type))
 532                 {
 533                     $focus->$key = $focus->parent_id;
 534                 }
 535             }
 536         }
 537         //bug# 40260 setting it true as the module in focus is involved in an import
 538         $focus->in_import=true;
 539         // call any logic needed for the module preSave
 540         $focus->beforeImportSave();
 541
 542         // if modified_user_id is set, set the flag to false so SugarBEan will not reset it
 543         if (isset($focus->modified_user_id) && $focus->modified_user_id) {
 544             $focus->update_modified_by = false;
 545         }
 546         // if created_by is set, set the flag to false so SugarBEan will not reset it
 547         if (isset($focus->created_by) && $focus->created_by) {
 548             $focus->set_created_by = false;
 549         }
 550
 551         if ( $focus->object_name == "Contact" && isset($list_of_users) )
 552             $focus->process_sync_to_outlook($list_of_users);
 553
 554         $focus->save(false);
 555
 556         //now that save is done, let's make sure that parent and related id's were saved as relationships
 557         //this takes place before the afterImportSave()
 558         $this->checkRelatedIDsAfterSave($focus);
 559
 560         // call any logic needed for the module postSave
 561         $focus->afterImportSave();
 562
 563         // Add ID to User's Last Import records
 564         if ( $newRecord )
 565             $this->importSource->writeRowToLastImport( $_REQUEST['import_module'],($focus->object_name == 'Case' ? 'aCase' : $focus->object_name),$focus->id);
 566
 567     }
 568
 569     protected function saveMappingFile()
 570     {
 571         global $current_user;
 572
 573         $firstrow    = unserialize(base64_decode($_REQUEST['firstrow']));
 574         $mappingValsArr = $this->importColumns;
 575         $mapping_file = new ImportMap();
 576         if ( isset($_REQUEST['has_header']) && $_REQUEST['has_header'] == 'on')
 577         {
 578             $header_to_field = array ();
 579             foreach ($this->importColumns as $pos => $field_name)
 580             {
 581                 if (isset($firstrow[$pos]) && isset($field_name))
 582                 {
 583                     $header_to_field[$firstrow[$pos]] = $field_name;
 584                 }
 585             }
 586
 587             $mappingValsArr = $header_to_field;
 588         }
 589         //get array of values to save for duplicate and locale settings
 590         $advMapping = $this->retrieveAdvancedMapping();
 591
 592         //merge with mappingVals array
 593         if(!empty($advMapping) && is_array($advMapping))
 594         {
 595             $mappingValsArr = array_merge($mappingValsArr,$advMapping);
 596         }
 597
 598         //set mapping
 599         $mapping_file->setMapping($mappingValsArr);
 600
 601         // save default fields
 602         $defaultValues = array();
 603         for ( $i = 0; $i < $_REQUEST['columncount']; $i++ )
 604         {
 605             if (isset($this->importColumns[$i]) && !empty($_REQUEST[$this->importColumns[$i]]))
 606             {
 607                 $field = $this->importColumns[$i];
 608                 $fieldDef = $this->bean->getFieldDefinition($field);
 609                 if(!empty($fieldDef['custom_type']) && $fieldDef['custom_type'] == 'teamset')
 610                 {
 611                     require_once('include/SugarFields/Fields/Teamset/SugarFieldTeamset.php');
 612                     $sugar_field = new SugarFieldTeamset('Teamset');
 613                     $teams = $sugar_field->getTeamsFromRequest($field);
 614                     if(isset($_REQUEST['primary_team_name_collection']))
 615                     {
 616                         $primary_index = $_REQUEST['primary_team_name_collection'];
 617                     }
 618
 619                     //If primary_index was selected, ensure that the first Array entry is the primary team
 620                     if(isset($primary_index))
 621                     {
 622                         $count = 0;
 623                         $new_teams = array();
 624                         foreach($teams as $id=>$name)
 625                         {
 626                             if($primary_index == $count++)
 627                             {
 628                                 $new_teams[$id] = $name;
 629                                 unset($teams[$id]);
 630                                 break;
 631                             }
 632                         }
 633
 634                         foreach($teams as $id=>$name)
 635                         {
 636                             $new_teams[$id] = $name;
 637                         }
 638                         $teams = $new_teams;
 639                     } //if
 640
 641                     $json = getJSONobj();
 642                     $defaultValues[$field] = $json->encode($teams);
 643                 }
 644                 else
 645                 {
 646                     $defaultValues[$field] = $_REQUEST[$this->importColumns[$i]];
 647                 }
 648             }
 649         }
 650         $mapping_file->setDefaultValues($defaultValues);
 651         $result = $mapping_file->save( $current_user->id,  $_REQUEST['save_map_as'], $_REQUEST['import_module'], $_REQUEST['source'],
 652             ( isset($_REQUEST['has_header']) && $_REQUEST['has_header'] == 'on'), $_REQUEST['custom_delimiter'], html_entity_decode($_REQUEST['custom_enclosure'],ENT_QUOTES)
 653         );
 654     }
 655
 656
 657     protected function populateDefaultMapValue($field, $fieldValue, $fieldDef)
 658     {
 659         global $timedate, $current_user;
 660
 661         if ( is_array($fieldValue) )
 662             $defaultRowValue = encodeMultienumValue($fieldValue);
 663         else
 664             $defaultRowValue = $_REQUEST[$field];
 665         // translate default values to the date/time format for the import file
 666         if( $fieldDef['type'] == 'date' && $this->ifs->dateformat != $timedate->get_date_format() )
 667             $defaultRowValue = $timedate->swap_formats($defaultRowValue, $this->ifs->dateformat, $timedate->get_date_format());
 668
 669         if( $fieldDef['type'] == 'time' && $this->ifs->timeformat != $timedate->get_time_format() )
 670             $defaultRowValue = $timedate->swap_formats($defaultRowValue, $this->ifs->timeformat, $timedate->get_time_format());
 671
 672         if( ($fieldDef['type'] == 'datetime' || $fieldDef['type'] == 'datetimecombo') && $this->ifs->dateformat.' '.$this->ifs->timeformat != $timedate->get_date_time_format() )
 673             $defaultRowValue = $timedate->swap_formats($defaultRowValue, $this->ifs->dateformat.' '.$this->ifs->timeformat,$timedate->get_date_time_format());
 674
 675         if ( in_array($fieldDef['type'],array('currency','float','int','num')) && $this->ifs->num_grp_sep != $current_user->getPreference('num_grp_sep') )
 676             $defaultRowValue = str_replace($current_user->getPreference('num_grp_sep'), $this->ifs->num_grp_sep,$defaultRowValue);
 677
 678         if ( in_array($fieldDef['type'],array('currency','float')) && $this->ifs->dec_sep != $current_user->getPreference('dec_sep') )
 679             $defaultRowValue = str_replace($current_user->getPreference('dec_sep'), $this->ifs->dec_sep,$defaultRowValue);
 680
 681         $user_currency_symbol = $this->defaultUserCurrency->symbol;
 682         if ( $fieldDef['type'] == 'currency' && $this->ifs->currency_symbol != $user_currency_symbol )
 683             $defaultRowValue = str_replace($user_currency_symbol, $this->ifs->currency_symbol,$defaultRowValue);
 684
 685         return $defaultRowValue;
 686     }
 687
 688     protected function getImportColumns()
 689     {
 690         $importable_fields = $this->bean->get_importable_fields();
 691         $importColumns = array();
 692         foreach ($_REQUEST as $name => $value)
 693         {
 694             // only look for var names that start with "fieldNum"
 695             if (strncasecmp($name, "colnum_", 7) != 0)
 696                 continue;
 697
 698             // pull out the column position for this field name
 699             $pos = substr($name, 7);
 700
 701             if ( isset($importable_fields[$value]) )
 702             {
 703                 // now mark that we've seen this field
 704                 $importColumns[$pos] = $value;
 705             }
 706         }
 707
 708         return $importColumns;
 709     }
 710
 711     protected function getFieldSanitizer()
 712     {
 713         $ifs = new ImportFieldSanitize();
 714         $copyFields = array('dateformat','timeformat','timezone','default_currency_significant_digits','num_grp_sep','dec_sep','default_locale_name_format');
 715         foreach($copyFields as $field)
 716         {
 717             $fieldKey = "importlocale_$field";
 718             $ifs->$field = $this->importSource->$fieldKey;
 719         }
 720
 721         $currency = new Currency();
 722         $currency->retrieve($this->importSource->importlocale_currency);
 723         $ifs->currency_symbol = $currency->symbol;
 724
 725         return $ifs;
 726     }
 727
 728     /**
 729      * Sets a translation map from sugar field key to external source key used while importing a row.  This allows external sources
 730      * to return a data set that is an associative array rather than numerically indexed.
 731      *
 732      * @param  $translator
 733      * @return void
 734      */
 735     public function setFieldKeyTranslator($translator)
 736     {
 737         $this->sugarToExternalSourceFieldMap = $translator;
 738     }
 739
 740     /**
 741      * If a bean save is not done for some reason, this method will undo any of the beans that were created
 742      *
 743      * @param array $ids ids of user_last_import records created
 744      */
 745     protected function _undoCreatedBeans( array $ids )
 746     {
 747         $focus = new UsersLastImport();
 748         foreach ($ids as $id)
 749             $focus->undoById($id);
 750     }
 751
 752     /**
 753      * clean id's when being imported
 754      *
 755      * @param  string $string
 756      * @return string
 757      */
 758     protected function _convertId($string)
 759     {
 760         return preg_replace_callback(
 761             '|[^A-Za-z0-9\-\_]|',
 762             create_function(
 763             // single quotes are essential here,
 764             // or alternative escape all $ as \$
 765             '$matches',
 766             'return ord($matches[0]);'
 767                  ) ,
 768             $string);
 769     }
 770
 771     public function retrieveAdvancedMapping()
 772     {
 773         $advancedMappingSettings = array();
 774
 775         //harvest the dupe index settings
 776         if( isset($_REQUEST['enabled_dupes']) )
 777         {
 778             $toDecode = html_entity_decode  ($_REQUEST['enabled_dupes'], ENT_QUOTES);
 779             $dupe_ind = json_decode($toDecode);
 780
 781             foreach($dupe_ind as $dupe)
 782             {
 783                 $advancedMappingSettings['dupe_'.$dupe] = $dupe;
 784             }
 785         }
 786
 787         foreach($_REQUEST as $rk=>$rv)
 788         {
 789             //harvest the import locale settings
 790             if(strpos($rk,'portlocale_')>0)
 791             {
 792                 $advancedMappingSettings[$rk] = $rv;
 793             }
 794
 795         }
 796         return $advancedMappingSettings;
 797     }
 798
 799     public static function getImportableModules()
 800     {
 801         global $beanList;
 802         $importableModules = array();
 803         foreach ($beanList as $moduleName => $beanName)
 804         {
 805             if( class_exists($beanName) )
 806             {
 807                 $tmp = new $beanName();
 808                 if( isset($tmp->importable) && $tmp->importable )
 809                 {
 810                     $label = isset($GLOBALS['app_list_strings']['moduleList'][$moduleName]) ? $GLOBALS['app_list_strings']['moduleList'][$moduleName] : $moduleName;
 811                     $importableModules[$moduleName] = $label;
 812                 }
 813             }
 814         }
 815
 816         asort($importableModules);
 817         return $importableModules;
 818     }
 819
 820
 821     /**
 822      * Replaces PHP error handler in Step4
 823      *
 824      * @param int    $errno
 825      * @param string $errstr
 826      * @param string $errfile
 827      * @param string $errline
 828      */
 829     public static function handleImportErrors($errno, $errstr, $errfile, $errline)
 830     {
 831         $GLOBALS['log']->fatal("Caught error: $errstr");
 832
 833         if ( !defined('E_DEPRECATED') )
 834             define('E_DEPRECATED','8192');
 835         if ( !defined('E_USER_DEPRECATED') )
 836             define('E_USER_DEPRECATED','16384');
 837
 838         $isFatal = false;
 839         switch ($errno)
 840         {
 841             case E_USER_ERROR:
 842                 $message = "ERROR: [$errno] $errstr on line $errline in file $errfile<br />\n";
 843                 $isFatal = true;
 844                 break;
 845             case E_USER_WARNING:
 846             case E_WARNING:
 847                 $message = "WARNING: [$errno] $errstr on line $errline in file $errfile<br />\n";
 848                 break;
 849             case E_USER_NOTICE:
 850             case E_NOTICE:
 851                 $message = "NOTICE: [$errno] $errstr on line $errline in file $errfile<br />\n";
 852                 break;
 853             case E_STRICT:
 854             case E_DEPRECATED:
 855             case E_USER_DEPRECATED:
 856                 // don't worry about these
 857                 // $message = "STRICT ERROR: [$errno] $errstr on line $errline in file $errfile<br />\n";
 858                 $message = "";
 859                 break;
 860             default:
 861                 $message = "Unknown error type: [$errno] $errstr on line $errline in file $errfile<br />\n";
 862                 break;
 863         }
 864
 865         // check to see if current reporting level should be included based upon error_reporting() setting, if not
 866         // then just return
 867         if (error_reporting() & $errno)
 868         {
 869             echo $message;
 870         }
 871
 872         if ($isFatal)
 873         {
 874             exit(1);
 875         }
 876     }
 877
 878
 879     /**
 880          * upon bean save, the relationships are saved by SugarBean->save_relationship_changes() method, but those values depend on
 881      * the request object and is not reliable during import.  This function makes sure any defined related or parent id's are processed
 882          * and their relationship saved.
 883          */
 884     public function checkRelatedIDsAfterSave($focus)
 885     {
 886         if(empty($focus)){
 887             return false;
 888         }
 889
 890         //check relationship fields first
 891         if(!empty($focus->parent_id) && !empty($focus->parent_type)){
 892             $relParentName = strtolower($focus->parent_type);
 893             $relParentID = strtolower($focus->parent_id);
 894         }
 895         if(!empty($focus->related_id) && !empty($focus->related_type)){
 896             $relName = strtolower($focus->related_type);
 897             $relID = strtolower($focus->related_id);
 898         }
 899
 900         //now refresh the bean and process for parent relationship
 901         $focus->retrieve($focus->id);
 902         if(!empty($relParentName) && !empty($relParentID)){
 903
 904             //grab the relationship and any available ids
 905             if(!empty($focus->$relParentName)){
 906                 $rel_ids=array();
 907                 $focus->load_relationship($relParentName);
 908                 $rel_ids = $focus->$relParentName->get();
 909
 910                 //if the current parent_id is not part of the stored rels, then add it
 911                 if(!in_array($relParentID, $rel_ids)){
 912                     $focus->$relParentName->add($relParentID);
 913                 }
 914             }
 915         }
 916
 917         //now lets process any related fields
 918         if(!empty($relName) && !empty($relID)){
 919             if(!empty($focus->$relName)){
 920                 $rel_ids=array();
 921                 $focus->load_relationship($relName);
 922                 $rel_ids = $focus->$relName->get();
 923
 924                 //if the related_id is not part of the stored rels, then add it
 925                 if(!in_array($relID, $rel_ids)){
 926                     $focus->$relName->add($relID);
 927                 }
 928             }
 929         }
 930     }
 931
 932
 933 }