@os1-platform/dispatch-mobile 1.0.8 → 2.0.0

package/lib/commonjs/manager/dispatch/DispatchStateContainer.js

@@ -4,261 +4,265 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _SyncManagerUtils = require("../../utils/SyncManagerUtils");
-
-var _storage = _interopRequireDefault(require("../../utils/storage"));
-
-var _mobileExecutionLib = require("mobile-execution-lib");
-
+var _platformCoreosExecutionEngineSdk = require("@os1-platform/platform-coreos-execution-engine-sdk");
 var _Toaster = require("../../components/widgets/Toaster");
-
 var _ETConfig = require("../../models/execTasks/ETConfig");
-
 var _EventsSyncManager = _interopRequireDefault(require("../syncmanager/events/EventsSyncManager"));
-
 var _Logger = _interopRequireWildcard(require("../../utils/Logger"));
-
 var _DispatchSdkCache = _interopRequireDefault(require("../sdk/DispatchSdkCache"));
-
 var _BaseError = require("../../errors/BaseError");
-
 var _ExecTaskUtils = require("../../utils/ExecTaskUtils");
-
 var _ReasonCodeContainer = _interopRequireDefault(require("../dispatchCodes/ReasonCodeContainer"));
-
 var _ErrorCodes = _interopRequireWildcard(require("../../errors/ErrorCodes"));
-
 var _RouteParams = require("../../ui/uiConfig/RouteParams");
-
 var _lodash = require("lodash");
-
+var _EventDispatcher = _interopRequireDefault(require("../../events/EventDispatcher"));
+var _EventCodeContainer = _interopRequireDefault(require("../dispatchCodes/EventCodeContainer"));
+var _constants = require("../../constants/constants");
+var _AppSyncManager = _interopRequireDefault(require("../syncmanager/AppSyncManager"));
+var _constants2 = require("../syncmanager/constants");
+var _storage = _interopRequireDefault(require("../../utils/storage"));
+var _utils = require("../../components/executiontasks/scan/utils");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } // NEW CODE
 class DispatchStateContainer {
   constructor() {
-    _defineProperty(this, "dispatchExecutor", new _mobileExecutionLib.ExecutionEngine());
-
+    _defineProperty(this, "cacheKeys", _DispatchSdkCache.default.KEYS);
+    _defineProperty(this, "cache", _DispatchSdkCache.default.getInstance());
     _defineProperty(this, "successRoute", null);
-
     _defineProperty(this, "failureRoute", null);
-
     _defineProperty(this, "_stateKeys", []);
-
     _defineProperty(this, "_jobObjectives", null);
-
     _defineProperty(this, "_mappedStates", new Map());
-
-    _defineProperty(this, "saveAndProceedToNextET", (0, _lodash.debounce)(async (baseETProps, etOutput, etStates, navigation, isLastTask) => {
+    _defineProperty(this, "_mappedStatesData", new Map());
+    _defineProperty(this, "saveAndProceedToNextET", (0, _lodash.debounce)(async (baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput) => {
       try {
-        await this.sendETOutput(etOutput, etStates);
-        await this.moveToNextET(baseETProps, etStates, navigation, isLastTask);
+        await this.sendETOutput(etOutput, states, isMergedObjectiveBasedOutput);
+        await this.moveToNextET(etOutput, baseETProps, states, navigation, isLastTask);
       } catch (error) {
         _Logger.default.getInstance().logEvent('saveAndProceed', error.message, _Logger.LOG_TYPE.SDK_ERROR);
-
         baseETProps.showProgress(false);
         (0, _Toaster.showToast)(error.message);
       }
     }, 800));
   }
-
   get stateKeys() {
     return this._stateKeys;
   }
-
   set stateKeys(value) {
     this._stateKeys = value;
   }
-
   get mappedStates() {
     return this._mappedStates;
   }
-
   set mappedStates(value) {
     this._mappedStates = value;
   }
-
   /**
    * Call this function when dispatch data is fetched successfully in client app
    * @param dispatchID
    * @param jobs
-   * @param logging
+   * @param dispatchWorkflows
    * @param maxTaskReattempt
    */
-  async initDispatchExecutor(dispatchID, jobs, logging, maxTaskReattempt) {
-    if (!dispatchID || !jobs || jobs.length < 1) {
+  async initDispatchExecutor(dispatchID, jobs, dispatchWorkflows, maxTaskReattempt) {
+    if (!dispatchID || !jobs || jobs.length < 1 || !dispatchWorkflows || Object.keys(dispatchWorkflows).length < 1) {
       _Logger.default.getInstance().logEvent('initDispatchExecutor', _ErrorCodes.InvalidArgumentsError, _Logger.LOG_TYPE.SDK_WARNING);
-
       throw new _BaseError.BaseError(_ErrorCodes.default.InvalidArgumentError, _ErrorCodes.InvalidArgumentsError);
     }
-
-    let storage = _storage.default.getInstance();
-
     await (0, _SyncManagerUtils.clearCache)(dispatchID);
     await _DispatchSdkCache.default.getInstance().setKeyInCache(_DispatchSdkCache.default.KEYS.DISPATCH_ID, dispatchID);
     await (0, _SyncManagerUtils.createFmsFolder)(dispatchID);
-    await this.dispatchExecutor.init(dispatchID, jobs, {
-      storeDbItemCallback: storage.setObject,
-      readDbItemCallback: storage.getObject,
-      deleteDbItemsCallback: storage.deleteMultiple,
-      getDbKeysCallback: storage.getAllKeys,
-      eventSyncCallback: _SyncManagerUtils.pushEventForSync
-    }, {
-      startTaskName: _ETConfig.FinalETName.START_WORKFLOW,
-      successTaskName: _ETConfig.FinalETName.COMPLETED_SUCCESS,
-      failureTaskName: _ETConfig.FinalETName.COMPLETED_FAILURE,
-      maxTaskReattempts: maxTaskReattempt,
-      logLevel: logging ? 'debug' : 'emerg'
+
+    // NEW CODE
+    let storage = _storage.default.getInstance();
+    const sharedPreferenceDispatchId = await storage.getSharedItem(_constants2.SHARED_PREFERENCE_DISPATCH_ID);
+    if (sharedPreferenceDispatchId) {
+      if (sharedPreferenceDispatchId !== dispatchID) {
+        await Promise.all([storage.setSharedItem(_constants2.SHARED_PREFERENCE_DISPATCH_ID, dispatchID), storage.setSharedItem(_constants2.LAST_SYNCED_EVENT_ID, '0')]);
+      }
+    } else {
+      await Promise.all([storage.setSharedItem(_constants2.SHARED_PREFERENCE_DISPATCH_ID, dispatchID), storage.setSharedItem(_constants2.LAST_SYNCED_EVENT_ID, '0')]);
+    }
+    await _platformCoreosExecutionEngineSdk.DispatchExecutor.start(dispatchID, jobs, dispatchWorkflows, {
+      maxTaskReattempt,
+      eventSyncBatchSize: _constants2.BULK_DATA_LIMIT
     });
   }
 
-  async bulkQueryNextET(jobObjectiveList) {
-    if (!jobObjectiveList || jobObjectiveList.length === 0) {
-      _Logger.default.getInstance().logEvent('bulkQueryNextET', 'CONSTRAINTS FAILED', _Logger.LOG_TYPE.SDK_ERROR);
+  // NEW CODE
+  /**
+   *
+   * @param mergedObjectiveId
+   * @returns IExecutionTaskQueryResponse {
+   *    mergedObjectiveId: string;
+   *    taskName: string;
+   *    taskId: string;
+   *    input: any;
+   * }
+   */
 
+  async queryNextET(mergedObjectiveId, statusFilter) {
+    if (!mergedObjectiveId) {
+      _Logger.default.getInstance().logEvent('queryNextET', 'CONSTRAINTS FAILED', _Logger.LOG_TYPE.SDK_ERROR);
       throw new _BaseError.BaseError(_ErrorCodes.default.MERGING_ERROR, 'CONSTRAINTS FAILED');
     }
-
-    for (const o of jobObjectiveList) {
-      let nState = null;
-
-      try {
-        nState = await this.queryObjective(o.objectiveId, o.jobId);
-      } catch (error) {
-        _Logger.default.getInstance().logEvent('bulkQueryNextET', JSON.stringify({
-          error: error.message,
-          jobId: o.jobId,
-          objRef: o.objectiveId
-        }), _Logger.LOG_TYPE.SDK_ERROR);
+    return await _platformCoreosExecutionEngineSdk.DispatchExecutor.getNextTask(mergedObjectiveId[0], statusFilter);
+  }
+  async updateScanETOutputSharedPreference(etOutput, prefixedMergedObjectiveId, prefixKey) {
+    etOutput.mergedObjectiveIds = prefixedMergedObjectiveId;
+    let storage = _storage.default.getInstance();
+    const output = await storage.getSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT);
+    if (output) {
+      const scanETOutput = JSON.parse(output);
+      let _scanETOutput = {};
+      if (scanETOutput[prefixKey]) {
+        _scanETOutput = scanETOutput[prefixKey];
       }
+      prefixedMergedObjectiveId.forEach(mergedId => {
+        _scanETOutput[mergedId] = etOutput;
+      });
 
-      if (nState) {
-        if (this._mappedStates.has(nState.taskId)) {
-          const val = this._mappedStates.get(nState.taskId);
-
-          val === null || val === void 0 ? void 0 : val.push({
-            nextState: nState,
-            objRef: o.objectiveId,
-            jobId: o.jobId
-          });
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify({
+        ...scanETOutput,
+        [prefixKey]: _scanETOutput
+      }));
+    } else {
+      const scanETOutput = {};
+      prefixedMergedObjectiveId.forEach(mergedId => {
+        scanETOutput[mergedId] = etOutput;
+      });
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify({
+        [prefixKey]: scanETOutput
+      }));
+    }
+  }
+  async updatePendingSharedPreference(eventType, prefixedMergedObjectiveId, prefixKey) {
+    let storage = _storage.default.getInstance();
+    const mergedIdOutput = await storage.getSharedItem(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT);
+    if (mergedIdOutput) {
+      const mergedIds = JSON.parse(mergedIdOutput);
+      const _mergedIds = mergedIds[prefixKey];
+      if (_mergedIds) {
+        if (eventType) {
+          _mergedIds.success.push(...prefixedMergedObjectiveId);
+          _mergedIds.pending = [];
         } else {
-          this._stateKeys.push(nState.taskId);
-
-          this._mappedStates.set(nState.taskId, [{
-            nextState: nState,
-            objRef: o.objectiveId,
-            jobId: o.jobId
-          }]);
+          _mergedIds.failure.push(...prefixedMergedObjectiveId);
+          _mergedIds.pending = [];
         }
+        await storage.setSharedItem(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify({
+          ...mergedIds,
+          [prefixKey]: _mergedIds
+        }));
       }
     }
-
-    const taskID = this._stateKeys.pop();
-
-    if (taskID) {
-      const nextStates = this._mappedStates.get(taskID);
-
-      this._mappedStates.delete(taskID);
-
-      return nextStates ?? [];
-    } else return null;
   }
 
-  async queryNextTask(jobObjectiveList) {
-    try {
-      const promises = [];
-      jobObjectiveList.forEach(jobObjective => {
-        promises.push(this.queryObjective(jobObjective.objectiveId, jobObjective.jobId));
+  // NEW CODE
+  async sendETOutput(etOutput, states, isMergedObjectiveBasedOutput) {
+    const mergedObjectiveIds = states[_RouteParams.RouteParams.NEXT_STATES].mergedObjectiveIds;
+    const taskName = states[_RouteParams.RouteParams.NEXT_STATES].taskName;
+    const taskID = states[_RouteParams.RouteParams.NEXT_STATES].taskId;
+    const input = states[_RouteParams.RouteParams.NEXT_STATES].input;
+    let lockTaskResponse = true;
+    if (isMergedObjectiveBasedOutput) {
+      // NEW CODE
+      const output = etOutput;
+      let promises = [];
+      const prefixKey = this.findPrefixKey(mergedObjectiveIds, etOutput, states);
+      let defaultConfig = {
+        index: -1,
+        success: false,
+        output: {}
+      };
+      let mergedIds = {
+        success: [],
+        failure: [],
+        pending: [prefixKey]
+      };
+      const filterIds = await (0, _utils.getScanMergedObjectID)();
+      if (filterIds) {
+        mergedIds = filterIds[prefixKey];
+      }
+      Object.keys(etOutput).forEach(mergedObjectiveId => {
+        const _output = output[mergedObjectiveId].output;
+        // PREFIX_KEY
+        if (mergedObjectiveId === 'default') {
+          const defaultOutput = output['default'].output;
+          // DELIVER AT DIFF LOCATION
+          if (defaultOutput.eventCode === _constants.REASON_NOT_USED) {
+            // DO NOT SEND OUTPUT WHEN DELIVER AT DIFF LOCATION
+            defaultOutput.eventCode = '';
+            defaultOutput.reasonCode = '';
+            lockTaskResponse = false;
+          } else {
+            defaultConfig = {
+              index: promises.length,
+              success: defaultOutput.success,
+              output: output['default']
+            };
+            promises.push(_platformCoreosExecutionEngineSdk.DispatchExecutor.saveTaskOutput(mergedIds.pending, taskName, taskID, {
+              input,
+              output: defaultOutput
+            }, {
+              ec: defaultOutput.eventCode,
+              rc: defaultOutput.reasonCode || ''
+            }));
+          }
+        } else {
+          promises.push(_platformCoreosExecutionEngineSdk.DispatchExecutor.saveTaskOutput([mergedObjectiveId], taskName, taskID, {
+            input,
+            output: _output
+          }));
+        }
       });
-      return await Promise.all(promises);
-    } catch (error) {
-      if (error instanceof _mobileExecutionLib.QuerySucceededObjectiveError) {
-        (0, _Toaster.showToast)('OBJECTIVE IS ALREADY COMPLETED');
-      } else if (error instanceof _mobileExecutionLib.EngineNotReadyError) {
-        (0, _Toaster.showToast)('ENGINE NOT READY! Please Try again after some time');
-      } else if (error instanceof _mobileExecutionLib.ObjectiveNotFoundError) {
-        (0, _Toaster.showToast)('NO SUCH OBJECTIVE FOUND');
-      } else if (error instanceof _mobileExecutionLib.ObjectiveNotReadyError) {
-        (0, _Toaster.showToast)('OBJECTIVE NOT READY');
-      } else if (error instanceof _mobileExecutionLib.ObjectiveJobAlreadyCompletedError) {
-        (0, _Toaster.showToast)('OBJECTIVE CANNOT BE ATTEMPTED');
-      } else if (error instanceof _mobileExecutionLib.JobStatusInvalidError || error instanceof _mobileExecutionLib.JobNotFoundError || error instanceof _mobileExecutionLib.EmptyJobError || error instanceof _mobileExecutionLib.ETIdInvalidError) {
-        (0, _Toaster.showToast)('INVALID JOB');
+      const response = await Promise.all(promises);
+      if (defaultConfig.index !== -1) {
+        // UPDATE PENDING IN SHARED PREFERENCE MERGED_SCAN_OUTPUT
+        this.updatePendingSharedPreference(defaultConfig.success, response[defaultConfig.index], prefixKey);
+        this.updateScanETOutputSharedPreference(defaultConfig.output, response[defaultConfig.index], prefixKey);
       }
-
-      return null;
-    }
-  }
-
-  async queryObjective(objRef, jobID) {
-    return await this.dispatchExecutor.queryObjectiveState(objRef, jobID);
-  }
-
-  async sendETOutput(etOutput, etState) {
-    if (!etState || etState.length === 0) {
-      _Logger.default.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', _Logger.LOG_TYPE.SDK_ERROR);
-
-      return;
+    } else {
+      await _platformCoreosExecutionEngineSdk.DispatchExecutor.saveTaskOutput(mergedObjectiveIds, taskName, taskID, {
+        input,
+        output: etOutput
+      });
     }
-
-    const promises = [];
-    etState.forEach(objItem => {
-      if (objItem.nextState.taskId === _ETConfig.ExecutionTaskID.DELIVER_CASH) {
-        var _objItem$nextState$da, _objItem$nextState$da2;
-
-        etOutput.amount = (_objItem$nextState$da = objItem.nextState.data) === null || _objItem$nextState$da === void 0 ? void 0 : (_objItem$nextState$da2 = _objItem$nextState$da.input) === null || _objItem$nextState$da2 === void 0 ? void 0 : _objItem$nextState$da2.expectedAmount;
-      }
-
-      objItem.nextState.data.output = { ...etOutput
-      };
-      promises.push(this.dispatchExecutor.lockObjectiveState(objItem.objRef, objItem.jobId, objItem.nextState));
-    });
-    await Promise.all(promises);
   }
-
-  async saveETOutput(jobId, objRef, etState) {
-    await this.dispatchExecutor.lockObjectiveState(objRef, jobId, etState);
+  findPrefixKey(mergedObjectiveIds, scanOutput, routeParams) {
+    const prefixedMergedObjectiveId = routeParams[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+    return prefixedMergedObjectiveId;
   }
-
   static getInstance() {
     if (!DispatchStateContainer.instance) {
       DispatchStateContainer.instance = new DispatchStateContainer();
     }
-
     return DispatchStateContainer.instance;
   }
-
-  fetchObjectiveState(objRef, jobID) {
-    return this.dispatchExecutor.queryObjectiveStatus(objRef, jobID);
-  }
-
   setSuccessRoute(route) {
     this.successRoute = route;
   }
-
   getSuccessRoute() {
     return this.successRoute;
   }
-
   setFailureRoute(route) {
     this.failureRoute = route;
   }
-
   getFailureRoute() {
     return this.failureRoute;
   }
-
   async getObjectiveSummary(jobObjective) {
     try {
       let response = [];
       let summaryData = await _EventsSyncManager.default.getInstance().getObjectiveSummary(jobObjective.jobId + jobObjective.objectiveId);
-
       if (summaryData) {
         for (const k in summaryData) {
           if (k === 'inputs') continue;else {
@@ -271,172 +275,224 @@ class DispatchStateContainer {
             });
           }
         }
-
         return response;
       } else return response;
     } catch (error) {
       _Logger.default.getInstance().logEvent('getObjectiveSummary', error.message, _Logger.LOG_TYPE.SDK_ERROR);
-
       return [];
     }
   }
-
-  async navigateToNextTask(navigation, route, etOutput, etSuccess, entityCode, eTaskID, baseETProps, isLastTask) {
+  async navigateToNextTask(navigation, route, etOutput, etSuccess, entityCode, eTaskID, baseETProps, isLastTask, isMergeObjectiveBasedOutput) {
     try {
       baseETProps.showProgress(true);
-
+      const mergedObjectiveIds = route.params[_RouteParams.RouteParams.NEXT_STATES].mergedObjectiveIds;
       const reasonsContainer = _ReasonCodeContainer.default.getInstance();
-
-      if (etSuccess) {
-        const successCodes = await reasonsContainer.getReasonCodes(route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, _ETConfig.BaseEventCodes.ENTITY_SUCCESS);
-
-        if (successCodes && successCodes.length > 0) {
-          if (successCodes.length === 1) {
-            etOutput.reasonCode = successCodes[0].reasonCode;
-            await this.saveAndProceed(baseETProps, etOutput, route.params[_RouteParams.RouteParams.NEXT_STATES], navigation, isLastTask);
-          } else {
+      const eventsContainer = _EventCodeContainer.default.getInstance();
+      if (isMergeObjectiveBasedOutput) {
+        await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+      } else {
+        const _eventCode = etOutput.eventCode;
+        if (etSuccess) {
+          if (!_eventCode) {
+            const _successApplicable = route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.success;
+            const successEventCodes = await eventsContainer.getEventCodes(_successApplicable);
             let rParams;
-            rParams = { ...route.params
+            rParams = {
+              ...route.params
             };
             rParams[_RouteParams.RouteParams.ET_SUCCESS] = true;
             rParams[_RouteParams.RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
             rParams[_RouteParams.RouteParams.CURRENT_ET_NAME] = eTaskID;
-            rParams[_RouteParams.RouteParams.REASONS] = successCodes;
             rParams[_RouteParams.RouteParams.IS_LAST_ET] = isLastTask;
+            rParams[_RouteParams.RouteParams.EVENT_CODES] = successEventCodes;
+            rParams[_RouteParams.RouteParams.APPLICABLE_CODES] = _successApplicable;
+            rParams[_RouteParams.RouteParams.IS_MERGED_OBJ_BASED_OUTPUT] = isMergeObjectiveBasedOutput;
+            rParams[_RouteParams.RouteParams.ROOT_META_DATA] = route.params[_RouteParams.RouteParams.ROOT_META_DATA];
+            rParams[_RouteParams.RouteParams.CANCEL_EVENT] = '';
             navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+          } else {
+            const successCodes = await reasonsContainer.getReasonCodes(route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.success ? route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.success : route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons, _eventCode);
+            if (successCodes && successCodes.length > 0) {
+              if (successCodes.length === 1) {
+                if (isMergeObjectiveBasedOutput) etOutput.baseResponse.reasonCode = successCodes[0].reasonCode;else etOutput.reasonCode = successCodes[0].reasonCode;
+                await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+              } else {
+                let rParams;
+                rParams = {
+                  ...route.params
+                };
+                rParams[_RouteParams.RouteParams.ET_SUCCESS] = true;
+                rParams[_RouteParams.RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
+                rParams[_RouteParams.RouteParams.CURRENT_ET_NAME] = eTaskID;
+                rParams[_RouteParams.RouteParams.REASONS] = successCodes;
+                rParams[_RouteParams.RouteParams.IS_LAST_ET] = isLastTask;
+                rParams[_RouteParams.RouteParams.ROOT_META_DATA] = route.params[_RouteParams.RouteParams.ROOT_META_DATA];
+                rParams[_RouteParams.RouteParams.CANCEL_EVENT] = _eventCode;
+                navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+              }
+            } else {
+              await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+            }
           }
         } else {
-          await this.saveAndProceed(baseETProps, etOutput, route.params[_RouteParams.RouteParams.NEXT_STATES], navigation, isLastTask);
-        }
-      } else {
-        const failureCodes = await reasonsContainer.getReasonCodes(route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, _ETConfig.BaseEventCodes.ENTITY_FAILURE);
-
-        if (failureCodes && failureCodes.length > 0) {
-          if (failureCodes.length === 1) {
-            await this.saveAndProceed(baseETProps, await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _ETConfig.BaseEventCodes.ENTITY_FAILURE, failureCodes[0].reasonCode), route.params[_RouteParams.RouteParams.NEXT_STATES], navigation, isLastTask);
-          } else {
+          let failureCodes = [];
+          if (!_eventCode) {
+            const _failureApplicable = route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.failure;
+            const failureEventCodes = await eventsContainer.getEventCodes(_failureApplicable);
             let rParams;
-            rParams = { ...route.params
+            rParams = {
+              ...route.params
             };
             rParams[_RouteParams.RouteParams.ET_SUCCESS] = false;
+            // rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
             rParams[_RouteParams.RouteParams.CURRENT_ET_NAME] = eTaskID;
-            rParams[_RouteParams.RouteParams.REASONS] = failureCodes;
             rParams[_RouteParams.RouteParams.IS_LAST_ET] = isLastTask;
+            rParams[_RouteParams.RouteParams.EVENT_CODES] = failureEventCodes;
+            rParams[_RouteParams.RouteParams.APPLICABLE_CODES] = _failureApplicable;
+            rParams[_RouteParams.RouteParams.ROOT_META_DATA] = route.params[_RouteParams.RouteParams.ROOT_META_DATA];
+            rParams[_RouteParams.RouteParams.CANCEL_EVENT] = '';
             navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+          } else {
+            if (_eventCode === _constants.GO_BACK_EVENT_CODE) failureCodes = [];else failureCodes = await reasonsContainer.getReasonCodes(route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.failure ? route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons.failure : route.params[_RouteParams.RouteParams.NEXT_STATES].input.applicableReasons, _eventCode);
+            if (failureCodes && failureCodes.length > 0) {
+              if (isMergeObjectiveBasedOutput) etOutput.baseResponse.reasonCode = failureCodes[0].reasonCode;
+              if (failureCodes.length === 1) {
+                await this.saveAndProceed(baseETProps, isMergeObjectiveBasedOutput ? etOutput : await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _eventCode, failureCodes[0].reasonCode, mergedObjectiveIds, eTaskID), route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+              } else {
+                let rParams;
+                rParams = {
+                  ...route.params
+                };
+                rParams[_RouteParams.RouteParams.ET_SUCCESS] = false;
+                rParams[_RouteParams.RouteParams.CURRENT_ET_NAME] = eTaskID;
+                rParams[_RouteParams.RouteParams.REASONS] = failureCodes;
+                rParams[_RouteParams.RouteParams.IS_LAST_ET] = isLastTask;
+                rParams[_RouteParams.RouteParams.ROOT_META_DATA] = route.params[_RouteParams.RouteParams.ROOT_META_DATA];
+                rParams[_RouteParams.RouteParams.CANCEL_EVENT] = _eventCode;
+                navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+              }
+            } else {
+              await this.saveAndProceed(baseETProps, isMergeObjectiveBasedOutput ? etOutput : await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _eventCode, '', mergedObjectiveIds, eTaskID), route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+            }
           }
-        } else {
-          await this.saveAndProceed(baseETProps, await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _ETConfig.BaseEventCodes.ENTITY_FAILURE, ''), route.params[_RouteParams.RouteParams.NEXT_STATES], navigation, isLastTask);
         }
       }
     } catch (error) {
       baseETProps.showProgress(false);
-
       _Logger.default.getInstance().logEvent('navigateToNextTask', error.message, _Logger.LOG_TYPE.SDK_ERROR);
     }
   }
-
-  getJobObjectiveList(nextStates) {
-    const result = [];
-    nextStates.forEach(s => {
-      result.push({
-        jobId: s.jobId,
-        objectiveId: s.objRef
-      });
-    });
-    return result;
-  }
-
-  async moveToNextET(baseETProps, etStates, navigation, isLastTask) {
+  async moveToNextET(etOutput, baseETProps, states, navigation, isLastTask) {
     try {
+      let etStates = states.next_states;
       baseETProps.showProgress(true);
-
-      if (isLastTask && etStates && etStates.length > 0) {
-        if (this._stateKeys.length !== 0) {
+      if (isLastTask && etStates && Object.keys(etStates).length > 0) {
+        if (this._mappedStates.size && this._stateKeys.length) {
           const st = this._stateKeys.pop();
-
           if (st) {
-            baseETProps.showProgress(false);
-
-            let nextStateList = this._mappedStates.get(st);
-
+            let rParams = {};
+            const _stData = this._mappedStates.get(st);
             this._mappedStates.delete(st);
-
-            if (nextStateList != null && nextStateList.length > 0) {
-              let rParams = {};
-              rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateList;
-              navigation.replace(nextStateList[0].nextState.taskId, rParams);
+            if (_stData) {
+              rParams[_RouteParams.RouteParams.NEXT_STATES] = _stData;
+              rParams[_RouteParams.RouteParams.ROOT_META_DATA] = states.rootMetaData;
+              navigation.replace(_stData.taskId, rParams);
             }
-
-            return;
           }
-        }
-
-        let nextState = etStates[0];
-        let completeJobsSummary = [];
-        let objSummary = await this.getObjectiveSummary({
-          jobId: etStates[0].jobId,
-          objectiveId: etStates[0].objRef
-        });
-        completeJobsSummary.push({
-          jobId: etStates[0].jobId,
-          objectiveRef: etStates[0].objRef,
-          jobObjectiveSummary: objSummary
-        });
-
-        for (let i = 1; i < etStates.length; i++) {
-          let obs = await this.getObjectiveSummary({
-            jobId: etStates[i].jobId,
-            objectiveId: etStates[i].objRef
-          });
-          completeJobsSummary.push({
-            jobId: etStates[i].jobId,
-            objectiveRef: etStates[i].objRef,
-            jobObjectiveSummary: obs
-          });
-        }
-
-        baseETProps.showProgress(false);
-
-        if (nextState.nextState.taskId === _ETConfig.ExecutionTaskID.COMPLETED_SUCCESS) {
-          navigation.replace(this.getSuccessRoute(), {
-            summary: objSummary,
-            completeSummary: completeJobsSummary,
-            objList: this.getJobObjectiveList(etStates),
-            objSuccess: true
-          });
         } else {
-          navigation.replace(this.getFailureRoute(), {
-            summary: objSummary,
-            completeSummary: completeJobsSummary,
-            objList: this.getJobObjectiveList(etStates),
-            objSuccess: false
-          });
+          baseETProps.showProgress(false);
+          // TODO: Remove this later
+          this.cache.clearKeys([this.cacheKeys.CURRENT_WORKING_TASK_ID]);
+          _AppSyncManager.default.getInstance().isForceStartEnabled = true;
+          _AppSyncManager.default.getInstance().isSyncActive = false;
+          _AppSyncManager.default.getInstance().startSDKSyncManager();
+          let objSummary = {
+            success: [],
+            failure: []
+          };
+          for (let [_key, _value] of this._mappedStatesData) {
+            const _objKey = _key === _ETConfig.ExecutionTaskID.COMPLETED_SUCCESS ? 'success' : 'failure';
+            const lastERCData = await _platformCoreosExecutionEngineSdk.DispatchExecutor.getlastERC(_value.mergedObjectiveIds);
+            for (const _lastER of lastERCData) {
+              var _objSummary$_objKey;
+              const reason = await _ReasonCodeContainer.default.getInstance().getReasonByCode(_lastER.lastReasonCode);
+              (_objSummary$_objKey = objSummary[_objKey]) === null || _objSummary$_objKey === void 0 ? void 0 : _objSummary$_objKey.push({
+                entityCode: _lastER.lastEntityCode,
+                eventCode: _lastER.lastEventCode,
+                reasonCode: _lastER.lastReasonCode,
+                reasonCodeDesc: reason === null || reason === void 0 ? void 0 : reason.description
+              });
+            }
+          }
+          if (this._mappedStatesData.get(_ETConfig.ExecutionTaskID.COMPLETED_SUCCESS)) {
+            this._mappedStatesData.clear();
+            this._mappedStates.clear();
+            this._stateKeys = [];
+            (0, _utils.clearScanOutput)(states.rootMetaData.prefixedMergedObjectiveId);
+            navigation.replace(this.getSuccessRoute(), {
+              summary: objSummary,
+              objSuccess: true
+            });
+          } else {
+            this._mappedStatesData.clear();
+            this._mappedStates.clear();
+            this._stateKeys = [];
+            (0, _utils.clearScanOutput)(states.rootMetaData.prefixedMergedObjectiveId);
+            navigation.replace(this.getFailureRoute(), {
+              summary: objSummary,
+              objSuccess: false
+            });
+          }
         }
       } else {
-        let nextStateList = await this.bulkQueryNextET(this.getJobObjectiveList(etStates));
+        let rParams = {};
+        let nextStateDataArray = await this.queryNextET(states.next_states.mergedObjectiveIds, states.rootMetaData.statusFilter);
+        const storeTerminalData = nextStateDataArray.every(_state => _state.taskId === _ETConfig.ExecutionTaskID.COMPLETED_SUCCESS || _state.taskId === _ETConfig.ExecutionTaskID.COMPLETED_FAILURE);
+        if (storeTerminalData) {
+          if (nextStateDataArray.length === 2) {
+            // Array in case of last states containing c-s and c-f
+            this._mappedStates.set(nextStateDataArray[1].taskId, nextStateDataArray[1]);
+            this._stateKeys.push(nextStateDataArray[1].taskId);
+          }
+          nextStateDataArray.forEach(data => {
+            if (data.taskId === _ETConfig.ExecutionTaskID.COMPLETED_SUCCESS || data.taskId === _ETConfig.ExecutionTaskID.COMPLETED_FAILURE) this._mappedStatesData.set(data.taskId, data);
+          });
+        }
+        const nextStateData = nextStateDataArray[0];
         baseETProps.showProgress(false);
-
-        if (nextStateList != null && nextStateList.length > 0) {
-          let rParams = {};
-          rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateList;
-          navigation.replace(nextStateList[0].nextState.taskId, rParams);
+        if (nextStateData != null && Object.keys(nextStateData).length > 0) {
+          rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateData;
+          rParams[_RouteParams.RouteParams.ROOT_META_DATA] = states.rootMetaData;
+
+          /**
+           * Send END/BACK custom event
+           */
+          if (!isLastTask) {
+            var _etOutput$baseRespons;
+            const eventOutputData = {
+              meta: (etOutput === null || etOutput === void 0 || (_etOutput$baseRespons = etOutput.baseResponse) === null || _etOutput$baseRespons === void 0 ? void 0 : _etOutput$baseRespons.meta) || (etOutput === null || etOutput === void 0 ? void 0 : etOutput.meta) || {},
+              etData: etOutput,
+              taskId: etStates.taskId,
+              nextTaskId: '',
+              timestamp: Date.now(),
+              customData: rParams[_RouteParams.RouteParams.ROOT_META_DATA].customEventsData
+            };
+            eventOutputData.nextTaskId = nextStateData.taskId;
+            eventOutputData.etData.eventCode !== _constants.GO_BACK_EVENT_CODE ? (0, _EventDispatcher.default)('END', etStates.taskName, eventOutputData) : (0, _EventDispatcher.default)('BACK', etStates.taskName, eventOutputData);
+          }
         }
+        navigation.replace(nextStateData.taskId, rParams);
       }
     } catch (error) {
       baseETProps.showProgress(false);
-
       _Logger.default.getInstance().logEvent('moveToNextET', error.message, _Logger.LOG_TYPE.SDK_ERROR);
     }
   }
-
-  async saveAndProceed(baseETProps, etOutput, etStates, navigation, isLastTask) {
+  async saveAndProceed(baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput) {
     baseETProps.showProgress(true);
-    await this.saveAndProceedToNextET(baseETProps, etOutput, etStates, navigation, isLastTask);
+    await this.saveAndProceedToNextET(baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput);
   }
-
 }
-
 exports.default = DispatchStateContainer;
-
 _defineProperty(DispatchStateContainer, "instance", void 0);
 //# sourceMappingURL=DispatchStateContainer.js.map