[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /* +***********************************************************************************
   4   * The contents of this file are subject to the vtiger CRM Public License Version 1.0
   5   * ("License"); You may not use this file except in compliance with the License
   6   * The Original Code is:  vtiger CRM Open Source
   7   * The Initial Developer of the Original Code is vtiger.
   8   * Portions created by vtiger are Copyright (C) vtiger.
   9   * All Rights Reserved.
  10   * *********************************************************************************** */
  11  
  12  class Vtiger_Import_View extends Vtiger_Index_View {
  13  
  14  	function __construct() {
  15          parent::__construct();
  16          $this->exposeMethod('continueImport');
  17          $this->exposeMethod('uploadAndParse');
  18          $this->exposeMethod('importBasicStep');
  19          $this->exposeMethod('import');
  20          $this->exposeMethod('undoImport');
  21          $this->exposeMethod('lastImportedRecords');
  22          $this->exposeMethod('deleteMap');
  23          $this->exposeMethod('clearCorruptedData');
  24          $this->exposeMethod('cancelImport');
  25          $this->exposeMethod('checkImportStatus');
  26      }
  27  
  28  	function checkPermission(Vtiger_Request $request) {
  29          $moduleName = $request->getModule();
  30          $moduleModel = Vtiger_Module_Model::getInstance($moduleName);
  31  
  32          $currentUserPriviligesModel = Users_Privileges_Model::getCurrentUserPrivilegesModel();
  33          if(!$currentUserPriviligesModel->hasModuleActionPermission($moduleModel->getId(), 'Import')) {
  34              throw new AppException('LBL_PERMISSION_DENIED');
  35          }
  36      }
  37  
  38  	function process(Vtiger_Request $request) {
  39          global $VTIGER_BULK_SAVE_MODE;
  40          $previousBulkSaveMode = $VTIGER_BULK_SAVE_MODE;
  41          $VTIGER_BULK_SAVE_MODE = true;
  42  
  43          $mode = $request->getMode();
  44          if(!empty($mode)) {
  45              // Added to check the status of import
  46              if($mode == 'continueImport' || $mode == 'uploadAndParse' || $mode == 'importBasicStep') {
  47                  $this->checkImportStatus($request);
  48              }
  49              $this->invokeExposedMethod($mode, $request);
  50          } else {
  51              $this->checkImportStatus($request);
  52              $this->importBasicStep($request);
  53          }
  54          
  55          $VTIGER_BULK_SAVE_MODE = $previousBulkSaveMode;
  56      }
  57  
  58      /**
  59       * Function to get the list of Script models to be included
  60       * @param Vtiger_Request $request
  61       * @return <Array> - List of Vtiger_JsScript_Model instances
  62       */
  63  	function getHeaderScripts(Vtiger_Request $request) {
  64          $headerScriptInstances = parent::getHeaderScripts($request);
  65  
  66          $jsFileNames = array(
  67              'modules.Import.resources.Import'
  68          );
  69  
  70          $jsScriptInstances = $this->checkAndConvertJsScripts($jsFileNames);
  71          $headerScriptInstances = array_merge($headerScriptInstances, $jsScriptInstances);
  72          return $headerScriptInstances;
  73      }
  74  
  75  	function importBasicStep(Vtiger_Request $request) {
  76          $viewer = $this->getViewer($request);
  77          $moduleName = $request->getModule();
  78  
  79          $moduleModel = Vtiger_Module_Model::getInstance($moduleName);
  80          $moduleMeta = $moduleModel->getModuleMeta();
  81  
  82          $viewer->assign('FOR_MODULE', $moduleName);
  83          $viewer->assign('MODULE', 'Import');
  84          $viewer->assign('SUPPORTED_FILE_TYPES', Import_Utils_Helper::getSupportedFileExtensions());
  85          $viewer->assign('SUPPORTED_FILE_ENCODING', Import_Utils_Helper::getSupportedFileEncoding());
  86          $viewer->assign('SUPPORTED_DELIMITERS', Import_Utils_Helper::getSupportedDelimiters());
  87          $viewer->assign('AUTO_MERGE_TYPES', Import_Utils_Helper::getAutoMergeTypes());
  88          
  89          //Duplicate records handling not supported for inventory moduels
  90          $duplicateHandlingNotSupportedModules = getInventoryModules();
  91          if(in_array($moduleName, $duplicateHandlingNotSupportedModules)){
  92              $viewer->assign('DUPLICATE_HANDLING_NOT_SUPPORTED', true);
  93          }
  94          //End
  95          
  96          $viewer->assign('AVAILABLE_FIELDS', $moduleMeta->getMergableFields());
  97          $viewer->assign('ENTITY_FIELDS', $moduleMeta->getEntityFields());
  98          $viewer->assign('ERROR_MESSAGE', $request->get('error_message'));
  99          $viewer->assign('IMPORT_UPLOAD_SIZE', '3145728');
 100  
 101          return $viewer->view('ImportBasicStep.tpl', 'Import');
 102      }
 103  
 104  	function uploadAndParse(Vtiger_Request $request) {
 105  
 106          if(Import_Utils_Helper::validateFileUpload($request)) {
 107              $moduleName = $request->getModule();
 108              $user = Users_Record_Model::getCurrentUserModel();
 109  
 110              $fileReader = Import_Utils_Helper::getFileReader($request, $user);
 111              if($fileReader == null) {
 112                  $request->set('error_message', vtranslate('LBL_INVALID_FILE', 'Import'));
 113                  $this->importBasicStep($request);
 114                  exit;
 115              }
 116  
 117              $hasHeader = $fileReader->hasHeader();
 118              $rowData = $fileReader->getFirstRowData($hasHeader);
 119  
 120              $viewer = $this->getViewer($request);
 121              $autoMerge = $request->get('auto_merge');
 122              if(!$autoMerge) {
 123                  $request->set('merge_type', 0);
 124                  $request->set('merge_fields', '');
 125              } else {
 126                  $viewer->assign('MERGE_FIELDS', Zend_Json::encode($request->get('merge_fields')));
 127              }
 128  
 129              $moduleName = $request->getModule();
 130              $moduleModel = Vtiger_Module_Model::getInstance($moduleName);
 131              $moduleMeta = $moduleModel->getModuleMeta();
 132  
 133  
 134              $viewer->assign('DATE_FORMAT', $user->date_format);
 135              $viewer->assign('FOR_MODULE', $moduleName);
 136              $viewer->assign('MODULE', 'Import');
 137  
 138              $viewer->assign('HAS_HEADER', $hasHeader);
 139              $viewer->assign('ROW_1_DATA', $rowData);
 140              $viewer->assign('USER_INPUT', $request);
 141  
 142              $viewer->assign('AVAILABLE_FIELDS', $moduleMeta->getImportableFields($moduleName));
 143              $viewer->assign('ENCODED_MANDATORY_FIELDS', Zend_Json::encode($moduleMeta->getMandatoryFields($moduleName)));
 144              $viewer->assign('SAVED_MAPS', Import_Map_Model::getAllByModule($moduleName));
 145              $viewer->assign('USERS_LIST', Import_Utils_Helper::getAssignedToUserList($moduleName));
 146              $viewer->assign('GROUPS_LIST', Import_Utils_Helper::getAssignedToGroupList($moduleName));
 147  
 148              return $viewer->view('ImportAdvanced.tpl', 'Import');
 149          } else {
 150              $this->importBasicStep($request);
 151          }
 152      }
 153  
 154  	function import(Vtiger_Request $request) {
 155          $user = Users_Record_Model::getCurrentUserModel();
 156          Import_Main_View::import($request, $user);
 157      }
 158  
 159  	function undoImport(Vtiger_Request $request) {
 160          $viewer = new Vtiger_Viewer();
 161          $db = PearDatabase::getInstance();
 162  
 163          $moduleName = $request->getModule();
 164          $ownerId = $request->get('foruser');
 165  
 166          $user = Users_Record_Model::getCurrentUserModel();
 167          $dbTableName = Import_Utils_Helper::getDbTableName($user);
 168  
 169          if(!$user->isAdminUser() && $user->id != $ownerId) {
 170              $viewer->assign('MESSAGE', 'LBL_PERMISSION_DENIED');
 171              $viewer->view('OperationNotPermitted.tpl', 'Vtiger');
 172              exit;
 173          }
 174          $previousBulkSaveMode = $VTIGER_BULK_SAVE_MODE;
 175          $VTIGER_BULK_SAVE_MODE = true;
 176          $query = "SELECT recordid FROM $dbTableName WHERE status = ? AND recordid IS NOT NULL";
 177          //For inventory modules
 178          $inventoryModules = getInventoryModules();
 179          if(in_array($moduleName, $inventoryModules)){
 180              $query .=' GROUP BY subject';
 181          }
 182          //End
 183          $result = $db->pquery($query, array(Import_Data_Action::$IMPORT_RECORD_CREATED));
 184          $noOfRecords = $db->num_rows($result);
 185          $noOfRecordsDeleted = 0;
 186          $entityData = array();
 187          for($i=0; $i<$noOfRecords; $i++) {
 188              $recordId = $db->query_result($result, $i, 'recordid');
 189              if(isRecordExists($recordId) && isPermitted($moduleName, 'Delete', $recordId) == 'yes') {
 190                  $recordModel = Vtiger_Record_Model::getCleanInstance($moduleName);
 191                  $recordModel->setId($recordId);
 192                  $recordModel->delete();
 193                  $focus = $recordModel->getEntity();
 194                  $focus->id = $recordId;
 195                  $entityData[] = VTEntityData::fromCRMEntity($focus);
 196                  $noOfRecordsDeleted++;
 197              }
 198          }
 199          $entity = new VTEventsManager($db);        
 200          $entity->triggerEvent('vtiger.batchevent.delete',$entityData);
 201          $VTIGER_BULK_SAVE_MODE = $previousBulkSaveMode;
 202          $viewer->assign('FOR_MODULE', $moduleName);
 203          $viewer->assign('MODULE', 'Import');
 204          $viewer->assign('TOTAL_RECORDS', $noOfRecords);
 205          $viewer->assign('DELETED_RECORDS_COUNT', $noOfRecordsDeleted);
 206          $viewer->view('ImportUndoResult.tpl', 'Import');
 207      }
 208  
 209  	function lastImportedRecords(Vtiger_Request $request) {
 210          $importList = new Import_List_View();
 211          $importList->process($request);
 212      }
 213  
 214  	function deleteMap(Vtiger_Request $request) {
 215          Import_Main_View::deleteMap($request);
 216      }
 217  
 218      //TODO need to move it to an action
 219  	function clearCorruptedData(Vtiger_Request $request) {
 220          $user = Users_Record_Model::getCurrentUserModel();
 221          Import_Utils_Helper::clearUserImportInfo($user);
 222          $this->importBasicStep($request);
 223      }
 224  
 225  	function cancelImport(Vtiger_Request $request) {
 226          $importId = $request->get('import_id');
 227          $user = Users_Record_Model::getCurrentUserModel();
 228  
 229          $importInfo = Import_Queue_Action::getImportInfoById($importId);
 230          if($importInfo != null) {
 231              if($importInfo['user_id'] == $user->id || $user->isAdminUser()) {
 232                  $importUser = Users_Record_Model::getInstanceById($importInfo['user_id'], 'Users');
 233                  $importDataController = new Import_Data_Action($importInfo, $importUser);
 234                  $importStatusCount = $importDataController->getImportStatusCount();
 235                  $importDataController->finishImport();
 236                  Import_Main_View::showResult($importInfo, $importStatusCount);
 237              }
 238          }
 239      }
 240  
 241  	function checkImportStatus(Vtiger_Request $request) {
 242          $moduleName = $request->getModule();
 243          $user = Users_Record_Model::getCurrentUserModel();
 244          $mode = $request->getMode();
 245  
 246          // Check if import on the module is locked
 247          $lockInfo = Import_Lock_Action::isLockedForModule($moduleName);
 248          if($lockInfo != null) {
 249              $lockedBy = $lockInfo['userid'];
 250              if($user->id != $lockedBy && !$user->isAdminUser()) {
 251                  Import_Utils_Helper::showImportLockedError($lockInfo);
 252                  exit;
 253              } else {
 254                  if($mode == 'continueImport' && $user->id == $lockedBy) {
 255                      $importController = new Import_Main_View($request, $user);
 256                      $importController->triggerImport(true);
 257                  } else {
 258                      $importInfo = Import_Queue_Action::getImportInfoById($lockInfo['importid']);
 259                      $lockOwner = $user;
 260                      if($user->id != $lockedBy) {
 261                          $lockOwner = Users_Record_Model::getInstanceById($lockInfo['userid'], 'Users');
 262                      }
 263                      Import_Main_View::showImportStatus($importInfo, $lockOwner);
 264                  }
 265                  exit;
 266              }
 267          }
 268  
 269          if(Import_Utils_Helper::isUserImportBlocked($user)) {
 270              $importInfo = Import_Queue_Action::getUserCurrentImportInfo($user);
 271              if($importInfo != null) {
 272                  Import_Main_View::showImportStatus($importInfo, $user);
 273                  exit;
 274              } else {
 275                  Import_Utils_Helper::showImportTableBlockedError($moduleName, $user);
 276                  exit;
 277              }
 278          }
 279          Import_Utils_Helper::clearUserImportInfo($user);
 280      }
 281  }