@os1-platform/dispatch-mobile 1.0.7 → 1.3.11

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

@@ -4,86 +4,69 @@ 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 _mobileExecutionLib = require("@os1-platform/mobile-execution-lib");
 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"));
 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); }
 class DispatchStateContainer {
   constructor() {
+    _defineProperty(this, "cacheKeys", _DispatchSdkCache.default.KEYS);
+    _defineProperty(this, "cache", _DispatchSdkCache.default.getInstance());
     _defineProperty(this, "dispatchExecutor", new _mobileExecutionLib.ExecutionEngine());
-
     _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, "saveAndProceedToNextET", (0, _lodash.debounce)(async (baseETProps, etOutput, states, navigation, isLastTask, isJobBasedOutput) => {
       try {
-        await this.sendETOutput(etOutput, etStates);
-        await this.moveToNextET(baseETProps, etStates, navigation, isLastTask);
+        // console.log('saveAndProceedToNextET start: ', new Date().getTime());
+        // console.log('sendETOutput start: ', new Date().getTime());
+        await this.sendETOutput(etOutput, states, isJobBasedOutput);
+        // console.log('sendETOutput end: ', new Date().getTime());
+        // console.log('moveToNextET start: ', new Date().getTime());
+        await this.moveToNextET(etOutput, baseETProps, states, navigation, isLastTask);
+        // console.log('moveToNextET end: ', new Date().getTime());
+        // console.log('saveAndProceedToNextET end: ', new Date().getTime());
       } 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
@@ -94,21 +77,23 @@ class DispatchStateContainer {
   async initDispatchExecutor(dispatchID, jobs, logging, maxTaskReattempt) {
     if (!dispatchID || !jobs || jobs.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,
+      // storeDbItemCallback: storage.setObject,
+      // readDbItemCallback: storage.getObject,
+      storeMultipleDbItemCallback: storage.setMultiObject,
+      readMultipleDbItemCallback: storage.getMultiObject,
+      // storeDbItemCallback: storage.setMultiObject, // NEW CODE
+      // readDbItemCallback: storage.getMultiObject, // NEW CODE
       deleteDbItemsCallback: storage.deleteMultiple,
       getDbKeysCallback: storage.getAllKeys,
-      eventSyncCallback: _SyncManagerUtils.pushEventForSync
+      // eventSyncCallback: pushEventForSync,
+      eventBulkSyncCallback: _SyncManagerUtils.pushBulkEventForSync
     }, {
       startTaskName: _ETConfig.FinalETName.START_WORKFLOW,
       successTaskName: _ETConfig.FinalETName.COMPLETED_SUCCESS,
@@ -118,147 +103,319 @@ class DispatchStateContainer {
     });
   }
 
+  // async getStates(o: any) {
+  //   let nState: state | null = null;
+  //   try {
+  //     // console.log('queryObjective: start ', new Date().getTime());
+  //     // promises.push(this.queryObjective(o.objectiveId, o.jobId));
+  //     // nState = await this.queryObjective(o.objectiveId, o.jobId);
+  //     // console.log('queryObjective: end ', new Date().getTime());
+  //   } catch (error: any) {
+  //     Logger.getInstance().logEvent(
+  //       'bulkQueryNextET',
+  //       JSON.stringify({
+  //         error: error.message,
+  //         jobId: o.jobId,
+  //         objRef: o.objectiveId,
+  //         groupId: o.groupId,
+  //         additionalData: o.additionalData,
+  //       }),
+  //       LOG_TYPE.SDK_ERROR
+  //     );
+  //   }
+  //   if (nState) {
+  //     if (this._mappedStates.has(nState.taskId)) {
+  //       let val = this._mappedStates.get(nState.taskId);
+  //       val?.push({
+  //         nextState: nState,
+  //         objRef: o.objectiveId,
+  //         jobId: o.jobId,
+  //         groupId: o.groupId,
+  //         additionalData: o.additionalData,
+  //       });
+  //     } else {
+  //       this._stateKeys.push(nState.taskId);
+  //       this._mappedStates.set(nState.taskId, [
+  //         {
+  //           nextState: nState,
+  //           objRef: o.objectiveId,
+  //           jobId: o.jobId,
+  //           groupId: o.groupId,
+  //           additionalData: o.additionalData,
+  //         },
+  //       ]);
+  //     }
+  //   }
+  // }
+
   async bulkQueryNextET(jobObjectiveList) {
     if (!jobObjectiveList || jobObjectiveList.length === 0) {
       _Logger.default.getInstance().logEvent('bulkQueryNextET', '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);
-      }
-
-      if (nState) {
+    const _jobObjectiveList = jobObjectiveList.map(o => ({
+      objectiveRef: o.objectiveId,
+      jobId: o.jobId
+    }));
+    let nStateArray = [];
+    try {
+      // @ts-ignore
+      nStateArray = await this.bulkQueryObjectives(_jobObjectiveList);
+    } catch (error) {
+      _Logger.default.getInstance().logEvent('bulkQueryNextET', JSON.stringify({
+        error: error.message,
+        data: jobObjectiveList.map(_job => _job.jobId)
+      }), _Logger.LOG_TYPE.SDK_ERROR);
+    }
+    if (nStateArray && nStateArray.length) {
+      nStateArray.forEach((nState, i) => {
+        const o = jobObjectiveList[i];
         if (this._mappedStates.has(nState.taskId)) {
-          const val = this._mappedStates.get(nState.taskId);
-
+          let val = this._mappedStates.get(nState.taskId);
           val === null || val === void 0 ? void 0 : val.push({
             nextState: nState,
             objRef: o.objectiveId,
-            jobId: o.jobId
+            jobId: o.jobId,
+            groupId: o.groupId,
+            additionalData: o.additionalData
           });
         } else {
           this._stateKeys.push(nState.taskId);
-
           this._mappedStates.set(nState.taskId, [{
             nextState: nState,
             objRef: o.objectiveId,
-            jobId: o.jobId
+            jobId: o.jobId,
+            groupId: o.groupId,
+            additionalData: o.additionalData
           }]);
         }
-      }
+      });
     }
 
-    const taskID = this._stateKeys.pop();
-
+    // OLD CODE
+    // console.log('bulkQueryNextET: start ', new Date().getTime());
+    // const promises: any[] = [];
+    // for (const o of jobObjectiveList) {
+    //   promises.push(this.getStates(o));
+    // }
+    // OLD CODE END
+    // await Promise.all(promises);
+
+    // console.log('bulkQueryNextET: end ', new Date().getTime());
+    let taskID;
+    const currentWorkingTaskId = await this.cache.getKeyFromCache(this.cacheKeys.CURRENT_WORKING_TASK_ID);
+    if (currentWorkingTaskId) {
+      taskID = currentWorkingTaskId;
+      const taskIndx = this._stateKeys.indexOf(taskID);
+      if (taskIndx >= 0) {
+        this._stateKeys.splice(taskIndx, 1);
+      } else taskID = this._stateKeys.pop();
+    } else taskID = this._stateKeys.pop();
     if (taskID) {
       const nextStates = this._mappedStates.get(taskID);
-
       this._mappedStates.delete(taskID);
 
+      /* console.log(
+        '🚀 ~ file: DispatchStateContainer.tsx:250 ~ DispatchStateContainer ~ nextStates:',
+        JSON.stringify(nextStates),
+        this._mappedStates
+      ); */
       return nextStates ?? [];
     } else return null;
   }
 
-  async queryNextTask(jobObjectiveList) {
-    try {
-      const promises = [];
-      jobObjectiveList.forEach(jobObjective => {
-        promises.push(this.queryObjective(jobObjective.objectiveId, jobObjective.jobId));
-      });
-      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');
-      }
-
-      return null;
-    }
+  // public async queryNextTask(
+  //   jobObjectiveList: JobObjectiveType[]
+  // ): Promise<PromiseSettledResult<state>[]> {
+  //   try {
+  //     const promises: any[] = [];
+  //     const _jobObjectiveList = jobObjectiveList.map((jobObjective)=>({objectiveRef:jobObjective.objectiveId,jobId:jobObjective.jobId}))
+
+  //     return await this.queryObjectives(_jobObjectiveList)
+  //     // jobObjectiveList.forEach((jobObjective) => {
+  //     //   promises.push(
+  //     //     this.queryObjective(jobObjective.objectiveId, jobObjective.jobId)
+  //     //   );
+  //     // });
+  //     // return await Promise.all(promises);
+  //   } catch (error: any) {
+  //     if (error instanceof QuerySucceededObjectiveError) {
+  //       showToast('OBJECTIVE IS ALREADY COMPLETED');
+  //     } else if (error instanceof EngineNotReadyError) {
+  //       showToast('ENGINE NOT READY! Please Try again after some time');
+  //     } else if (error instanceof ObjectiveNotFoundError) {
+  //       showToast('NO SUCH OBJECTIVE FOUND');
+  //     } else if (error instanceof ObjectiveNotReadyError) {
+  //       showToast('OBJECTIVE NOT READY');
+  //     } else if (error instanceof ObjectiveJobAlreadyCompletedError) {
+  //       showToast('OBJECTIVE CANNOT BE ATTEMPTED');
+  //     } else if (
+  //       error instanceof JobStatusInvalidError ||
+  //       error instanceof JobNotFoundError ||
+  //       error instanceof EmptyJobError ||
+  //       error instanceof ETIdInvalidError
+  //     ) {
+  //       showToast('INVALID JOB');
+  //     }
+  //     return null;
+  //   }
+  // }
+
+  // NEW CODE
+  async bulkLockObjectiveStates(lockInput) {
+    return await this.dispatchExecutor.lockBulkObjectiveState(lockInput);
   }
 
-  async queryObjective(objRef, jobID) {
-    return await this.dispatchExecutor.queryObjectiveState(objRef, jobID);
+  // NEW CODE
+  async bulkQueryObjectives(queryInput) {
+    return await this.dispatchExecutor.queryBulkObjectiveState(queryInput);
   }
 
-  async sendETOutput(etOutput, etState) {
+  // public async queryObjective(objRef: string, jobID: string) {
+  //   return await this.dispatchExecutor.queryObjectiveState(objRef, jobID);
+  // }
+
+  async sendPendingETOutput(etOutputData, states, isJobBasedOutput) {
+    const etOutput = JSON.parse(JSON.stringify(etOutputData));
+    const etState = states.pending_states;
     if (!etState || etState.length === 0) {
       _Logger.default.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', _Logger.LOG_TYPE.SDK_ERROR);
-
       return;
     }
-
-    const promises = [];
-    etState.forEach(objItem => {
+    // const promises: any[] = [];
+    const _objectiveState = [];
+    etState.forEach((objItem, index) => {
       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;
       }
+      if (isJobBasedOutput) {
+        var _etOutput$pendingEtDa;
+        let baseResponse = etOutput === null || etOutput === void 0 ? void 0 : etOutput.baseResponse;
+        if ((_etOutput$pendingEtDa = etOutput.pendingEtData[objItem.jobId]) !== null && _etOutput$pendingEtDa !== void 0 && _etOutput$pendingEtDa.baseResponse) {
+          var _etOutput$pendingEtDa2, _etOutput$pendingEtDa3;
+          baseResponse = etOutput.pendingEtData[objItem.jobId].baseResponse;
+          ((_etOutput$pendingEtDa2 = etOutput.pendingEtData[objItem.jobId]) === null || _etOutput$pendingEtDa2 === void 0 ? void 0 : _etOutput$pendingEtDa2.baseResponse) && ((_etOutput$pendingEtDa3 = etOutput.pendingEtData[objItem.jobId]) === null || _etOutput$pendingEtDa3 === void 0 ? true : delete _etOutput$pendingEtDa3.baseResponse);
+        }
+        const computedOutput = {
+          ...baseResponse,
+          ...(Object.keys(etOutput === null || etOutput === void 0 ? void 0 : etOutput['pendingEtData']).length ? etOutput.pendingEtData[objItem.jobId] || {} : {})
+        };
+        objItem.nextState.data.output = {
+          ...computedOutput
+        };
+        etState[index].nextState.data.output = {
+          ...computedOutput
+        };
+      } else objItem.nextState.data.output = {
+        ...etOutput
+      };
 
-      objItem.nextState.data.output = { ...etOutput
+      /* promises.push(
+        this.dispatchExecutor.storePendingState(
+          objItem.objRef,
+          objItem.jobId,
+          objItem.nextState
+        )
+      ); */
+      _objectiveState.push({
+        // objectiveRef: objItem.objRef,
+        jobId: objItem.jobId,
+        _state: objItem.nextState
+      });
+    });
+    // await Promise.all(promises);
+    await this.dispatchExecutor.storeBulkPendingState(_objectiveState);
+  }
+  async sendETOutput(etOutput, states, isJobBasedOutput) {
+    let isPendingState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    const etState = !isPendingState ? states.next_states : states.pending_states;
+    if (!etState || etState.length === 0) {
+      _Logger.default.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', _Logger.LOG_TYPE.SDK_ERROR);
+      return;
+    }
+    // const promises: any[] = [];
+    const _objectiveState = [];
+    const _etDataVar = isPendingState ? 'pendingEtData' : 'etData';
+    etState.forEach((objItem, index) => {
+      if (objItem.nextState.taskId === _ETConfig.ExecutionTaskID.DELIVER_CASH) {
+        var _objItem$nextState$da3, _objItem$nextState$da4;
+        etOutput.amount = (_objItem$nextState$da3 = objItem.nextState.data) === null || _objItem$nextState$da3 === void 0 ? void 0 : (_objItem$nextState$da4 = _objItem$nextState$da3.input) === null || _objItem$nextState$da4 === void 0 ? void 0 : _objItem$nextState$da4.expectedAmount;
+      }
+      if (isJobBasedOutput) {
+        var _etOutput$_etDataVar$;
+        let baseResponse = etOutput === null || etOutput === void 0 ? void 0 : etOutput.baseResponse;
+        if ((_etOutput$_etDataVar$ = etOutput[_etDataVar][objItem.jobId]) !== null && _etOutput$_etDataVar$ !== void 0 && _etOutput$_etDataVar$.baseResponse) {
+          var _etOutput$_etDataVar$2, _etOutput$_etDataVar$3;
+          baseResponse = etOutput[_etDataVar][objItem.jobId].baseResponse;
+          ((_etOutput$_etDataVar$2 = etOutput[_etDataVar][objItem.jobId]) === null || _etOutput$_etDataVar$2 === void 0 ? void 0 : _etOutput$_etDataVar$2.baseResponse) && ((_etOutput$_etDataVar$3 = etOutput[_etDataVar][objItem.jobId]) === null || _etOutput$_etDataVar$3 === void 0 ? true : delete _etOutput$_etDataVar$3.baseResponse);
+        }
+        const computedOutput = {
+          ...baseResponse,
+          ...(Object.keys(etOutput === null || etOutput === void 0 ? void 0 : etOutput[_etDataVar]).length ? etOutput[_etDataVar][objItem.jobId] || {} : {})
+        };
+        objItem.nextState.data.output = {
+          ...computedOutput
+        };
+        etState[index].nextState.data.output = {
+          ...computedOutput
+        };
+      } else objItem.nextState.data.output = {
+        ...etOutput
       };
-      promises.push(this.dispatchExecutor.lockObjectiveState(objItem.objRef, objItem.jobId, objItem.nextState));
+
+      // NEW CODE
+      _objectiveState.push({
+        objectiveRef: objItem.objRef,
+        jobId: objItem.jobId,
+        state: objItem.nextState
+      });
+
+      // OLD CODE
+      // promises.push(
+      //   this.dispatchExecutor.lockObjectiveState(
+      //     objItem.objRef,
+      //     objItem.jobId,
+      //     objItem.nextState
+      //   )
+      // );
     });
-    await Promise.all(promises);
+    // OLD CODE
+    // await Promise.all(promises);
+    // console.log('_objectiveState: ', JSON.stringify(_objectiveState));
+
+    await this.bulkLockObjectiveStates(_objectiveState);
   }
 
+  // ONLY USED IN RTScanScreen which is not used, needs cleanup
   async saveETOutput(jobId, objRef, etState) {
-    await this.dispatchExecutor.lockObjectiveState(objRef, jobId, etState);
+    // await this.dispatchExecutor.lockObjectiveState(objRef, jobId, etState);
   }
-
   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,106 +428,272 @@ 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, isJobBasedOutput) {
     try {
       baseETProps.showProgress(true);
-
       const reasonsContainer = _ReasonCodeContainer.default.getInstance();
-
+      const eventsContainer = _EventCodeContainer.default.getInstance();
+      const _eventCode = isJobBasedOutput ? etOutput.baseResponse.eventCode : etOutput.eventCode;
+      const _isReasonNotToBeUsed = isJobBasedOutput ? etOutput.baseResponse.reasonCode === _constants.REASON_NOT_USED : etOutput.reasonCode === _constants.REASON_NOT_USED;
+      if (_isReasonNotToBeUsed) {
+        isJobBasedOutput ? etOutput.baseResponse.reasonCode = '' : etOutput.reasonCode = '';
+      }
+      if (isLastTask) {
+        if (route.params[_RouteParams.RouteParams.PENDING_STATES] && route.params[_RouteParams.RouteParams.PENDING_STATES].length) {
+          var _states$0$nextState$d, _states$0$nextState$d2, _failureCodes$;
+          //Updated the states of pending states to completed end-state ET
+          await this.sendETOutput(route.params[_RouteParams.RouteParams.PENDING_STATES_OUTPUT], route.params, true, true);
+
+          /**
+           * Here we'll get the states data for end et
+           */
+          const _states = await this.bulkQueryNextET(this.getJobObjectiveList(route.params[_RouteParams.RouteParams.PENDING_STATES]));
+          const failureCodes = await reasonsContainer.getReasonCodes((_states$0$nextState$d = _states[0].nextState.data.input) !== null && _states$0$nextState$d !== void 0 && _states$0$nextState$d.applicableReasons.success ? _states[0].nextState.data.input.applicableReasons.success : (_states$0$nextState$d2 = _states[0].nextState.data.input) === null || _states$0$nextState$d2 === void 0 ? void 0 : _states$0$nextState$d2.applicableReasons, _ETConfig.BaseEventCodes.ENTITY_SUCCESS);
+          let _etOutput = JSON.parse(JSON.stringify(etOutput));
+          _etOutput.entityCode = _ETConfig.EntityCode.COMPLETED_FAILURE;
+          _etOutput.success = true;
+          _etOutput.eventCode = _ETConfig.BaseEventCodes.ENTITY_SUCCESS;
+          _etOutput.reasonCode = ((_failureCodes$ = failureCodes[0]) === null || _failureCodes$ === void 0 ? void 0 : _failureCodes$.reasonCode) || '';
+
+          /**
+           * Update end et state
+           */
+          await this.sendETOutput(_etOutput, {
+            next_states: _states
+          });
+          route.params[_RouteParams.RouteParams.PENDING_STATES] = _states;
+        }
+      }
       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);
+        if (!_eventCode) {
+          const _successApplicable = route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success;
+          const successEventCodes = await eventsContainer.getEventCodes(_successApplicable);
+          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.IS_LAST_ET] = isLastTask;
+          rParams[_RouteParams.RouteParams.EVENT_CODES] = successEventCodes;
+          rParams[_RouteParams.RouteParams.APPLICABLE_CODES] = _successApplicable;
+          rParams[_RouteParams.RouteParams.IS_JOB_BASED_OUTPUT] = isJobBasedOutput;
+          rParams[_RouteParams.RouteParams.ROOT_META_DATA] = route.params[_RouteParams.RouteParams.ROOT_META_DATA];
+          rParams[_RouteParams.RouteParams.COMPLETED_STATES] = route.params[_RouteParams.RouteParams.COMPLETED_STATES];
+          rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = route.params[_RouteParams.RouteParams.PENDING_STATES_OUTPUT];
+          rParams[_RouteParams.RouteParams.CANCEL_EVENT] = '';
+          navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+        } else {
+          const successCodes = await reasonsContainer.getReasonCodes(route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success ? route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success : route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, _eventCode);
+          if (successCodes && successCodes.length > 0) {
+            if (successCodes.length === 1 || _isReasonNotToBeUsed) {
+              if (isJobBasedOutput) etOutput.baseResponse.reasonCode = successCodes[0].reasonCode;else etOutput.reasonCode = successCodes[0].reasonCode;
+              await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isJobBasedOutput);
+            } 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.COMPLETED_STATES] = route.params[_RouteParams.RouteParams.COMPLETED_STATES];
+              rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = route.params[_RouteParams.RouteParams.PENDING_STATES_OUTPUT];
+              rParams[_RouteParams.RouteParams.CANCEL_EVENT] = _eventCode;
+              navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+            }
           } 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;
-            navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+            await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isJobBasedOutput);
           }
-        } 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);
+        let failureCodes = [];
+        if (!_eventCode) {
+          const _failureApplicable = route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.failure;
+          const failureEventCodes = await eventsContainer.getEventCodes(_failureApplicable);
+          let rParams;
+          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.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.COMPLETED_STATES] = route.params[_RouteParams.RouteParams.COMPLETED_STATES];
+          rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = route.params[_RouteParams.RouteParams.PENDING_STATES_OUTPUT];
+          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][0].nextState.data.input.applicableReasons.failure ? route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.failure : route.params[_RouteParams.RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, _eventCode);
+          if (failureCodes && failureCodes.length > 0) {
+            if (isJobBasedOutput) etOutput.baseResponse.reasonCode = failureCodes[0].reasonCode;
+            if (failureCodes.length === 1 || _isReasonNotToBeUsed) {
+              await this.saveAndProceed(baseETProps, isJobBasedOutput ? etOutput : await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _eventCode, failureCodes[0].reasonCode), route.params, navigation, isLastTask, isJobBasedOutput);
+            } 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.COMPLETED_STATES] = route.params[_RouteParams.RouteParams.COMPLETED_STATES];
+              rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = route.params[_RouteParams.RouteParams.PENDING_STATES_OUTPUT];
+              rParams[_RouteParams.RouteParams.CANCEL_EVENT] = _eventCode;
+              navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+            }
           } 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;
-            navigation.replace(_ETConfig.CustomScreens.REMARK_SCREEN, rParams);
+            await this.saveAndProceed(baseETProps, isJobBasedOutput ? etOutput : await (0, _ExecTaskUtils.getBaseETResponse)(entityCode, false, _eventCode, ''), route.params, navigation, isLastTask, isJobBasedOutput);
           }
-        } 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
+        objectiveId: s.objRef,
+        groupId: s.groupId,
+        additionalData: s.additionalData
       });
     });
     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) {
           const st = this._stateKeys.pop();
-
           if (st) {
             baseETProps.showProgress(false);
-
             let nextStateList = this._mappedStates.get(st);
-
             this._mappedStates.delete(st);
-
+            const taskMeta = JSON.parse(nextStateList && nextStateList[0].nextState.data.taskMeta || '{}');
+            let isFailureFlow = Object.keys(taskMeta).length ? taskMeta.allowFailureFlow !== undefined ? taskMeta.allowFailureFlow : true : true;
             if (nextStateList != null && nextStateList.length > 0) {
-              let rParams = {};
-              rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateList;
-              navigation.replace(nextStateList[0].nextState.taskId, rParams);
+              if (!isFailureFlow) {
+                const promises = [];
+                const _objectiveState = [];
+                const _taskOutput = [];
+                /*for (let index = 0; index < nextStateList.length; index++) {
+                  const objItem = nextStateList[index];
+                  
+                   //OLD CODE
+                  const prevOutput =
+                    await this.dispatchExecutor.getTaskOutputByInstanceId(
+                      objItem.nextState.name,
+                      objItem.nextState.workflowInstanceId
+                    );
+                  objItem.nextState.data.output = { ...prevOutput }; */
+                //Updated the states of pending states to completed end-state ET
+
+                // NEW CODE
+                /* _objectiveState.push({
+                    objectiveRef: objItem.objRef,
+                    jobId: objItem.jobId,
+                    state: objItem.nextState,
+                  }); */
+
+                // OLD CODE
+                // promises.push(
+                //   this.dispatchExecutor.lockObjectiveState(
+                //     objItem.objRef,
+                //     objItem.jobId,
+                //     objItem.nextState
+                //   )
+                // );
+                // }
+                // OLD CODE
+                // await Promise.all(promises);
+
+                // NEW CODE
+                nextStateList.forEach(objItem => {
+                  // const objItem = nextStateList[index];
+                  _taskOutput.push({
+                    taskName: objItem.nextState.name,
+                    jobId: objItem.jobId,
+                    objectiveRef: objItem.objRef
+                  });
+                });
+                const prevOutput = await this.dispatchExecutor.getBulkTaskOutput(_taskOutput);
+                nextStateList.forEach((objItem, index) => {
+                  objItem.nextState.data.output = {
+                    ...prevOutput[index]
+                  };
+                  _objectiveState.push({
+                    objectiveRef: objItem.objRef,
+                    jobId: objItem.jobId,
+                    state: objItem.nextState
+                  });
+                });
+                await this.bulkLockObjectiveStates(_objectiveState);
+
+                /**
+                 * Here we'll get the states data for end et
+                 */
+                const _states = await this.bulkQueryNextET(this.getJobObjectiveList(nextStateList));
+                if (_states[0].nextState.taskId === _ETConfig.ExecutionTaskID.COMPLETED_FAILURE) {
+                  var _states$0$nextState$d3, _states$0$nextState$d4, _failureCodes$2;
+                  const failureCodes = await _ReasonCodeContainer.default.getInstance().getReasonCodes((_states$0$nextState$d3 = _states[0].nextState.data.input) !== null && _states$0$nextState$d3 !== void 0 && _states$0$nextState$d3.applicableReasons.success ? _states[0].nextState.data.input.applicableReasons.success : (_states$0$nextState$d4 = _states[0].nextState.data.input) === null || _states$0$nextState$d4 === void 0 ? void 0 : _states$0$nextState$d4.applicableReasons, _ETConfig.BaseEventCodes.ENTITY_SUCCESS);
+                  let _etOutput = JSON.parse(JSON.stringify(etOutput));
+                  _etOutput.entityCode = _ETConfig.EntityCode.COMPLETED_FAILURE;
+                  _etOutput.success = true;
+                  _etOutput.eventCode = _ETConfig.BaseEventCodes.ENTITY_SUCCESS;
+                  _etOutput.reasonCode = ((_failureCodes$2 = failureCodes[0]) === null || _failureCodes$2 === void 0 ? void 0 : _failureCodes$2.reasonCode) || '';
+
+                  /**
+                   * Update end et state
+                   */
+                  await this.sendETOutput(_etOutput, {
+                    next_states: _states
+                  });
+                  states.pending_states = [...(states.pending_states || []), ..._states];
+                } else {
+                  let rParams = {};
+                  rParams[_RouteParams.RouteParams.NEXT_STATES] = _states;
+                  rParams[_RouteParams.RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+                  rParams[_RouteParams.RouteParams.COMPLETED_STATES] = [...(states.completed_states || []), ...etStates];
+                  rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = states.pending_states_output;
+                  rParams[_RouteParams.RouteParams.ROOT_META_DATA] = states.rootMetaData;
+                  navigation.replace(_states[0].nextState.taskId, rParams);
+                }
+              } else {
+                let rParams = {};
+                rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateList;
+                rParams[_RouteParams.RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+                rParams[_RouteParams.RouteParams.COMPLETED_STATES] = [...(states.completed_states || []), ...etStates];
+                rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = states.pending_states_output;
+                rParams[_RouteParams.RouteParams.ROOT_META_DATA] = states.rootMetaData;
+                navigation.replace(nextStateList[0].nextState.taskId, rParams);
+              }
             }
-
-            return;
+            if (isFailureFlow) return;
           }
         }
-
+        etStates = [...etStates, ...(states.pending_states || []), ...(states.completed_states || [])];
         let nextState = etStates[0];
         let completeJobsSummary = [];
         let objSummary = await this.getObjectiveSummary({
@@ -382,7 +705,6 @@ class DispatchStateContainer {
           objectiveRef: etStates[0].objRef,
           jobObjectiveSummary: objSummary
         });
-
         for (let i = 1; i < etStates.length; i++) {
           let obs = await this.getObjectiveSummary({
             jobId: etStates[i].jobId,
@@ -394,9 +716,11 @@ class DispatchStateContainer {
             jobObjectiveSummary: obs
           });
         }
-
         baseETProps.showProgress(false);
-
+        this.cache.clearKeys([this.cacheKeys.CURRENT_WORKING_TASK_ID]);
+        _AppSyncManager.default.getInstance().isForceStartEnabled = true;
+        _AppSyncManager.default.getInstance().isSyncActive = false;
+        _AppSyncManager.default.getInstance().startSDKSyncManager();
         if (nextState.nextState.taskId === _ETConfig.ExecutionTaskID.COMPLETED_SUCCESS) {
           navigation.replace(this.getSuccessRoute(), {
             summary: objSummary,
@@ -415,28 +739,54 @@ class DispatchStateContainer {
       } else {
         let nextStateList = await this.bulkQueryNextET(this.getJobObjectiveList(etStates));
         baseETProps.showProgress(false);
-
         if (nextStateList != null && nextStateList.length > 0) {
           let rParams = {};
           rParams[_RouteParams.RouteParams.NEXT_STATES] = nextStateList;
+          rParams[_RouteParams.RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+          rParams[_RouteParams.RouteParams.COMPLETED_STATES] = states.completed_states;
+          rParams[_RouteParams.RouteParams.ROOT_META_DATA] = states.rootMetaData;
+          rParams[_RouteParams.RouteParams.PENDING_STATES_OUTPUT] = states.pending_states_output;
+
+          /**
+           * For custom end event
+           * Add pending state(failed and unscanned) objectives only for scan et
+           */
+          const _nextStates = etStates[0].nextState.taskId === _ETConfig.ExecutionTaskID.SCAN ? [...etStates, ...(states.pending_states || [])] : etStates;
+          if (!isLastTask) {
+            var _etStates$0$nextState, _etOutput$baseRespons;
+            const eventOutputData = {
+              meta: ((_etStates$0$nextState = etStates[0].nextState.data.output) === null || _etStates$0$nextState === void 0 ? void 0 : _etStates$0$nextState.meta) || (etOutput === null || etOutput === void 0 ? 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: {},
+              taskId: etStates[0].nextState.taskId,
+              nextTaskId: '',
+              timestamp: Date.now()
+            };
+            etStates[0].groupId ? eventOutputData['groupId'] = etStates[0].groupId : null;
+            _nextStates.forEach(objItem => {
+              var _objItem$nextState$da5, _eventOutputData$etDa, _eventOutputData$etDa2, _eventOutputData$etDa3;
+              eventOutputData.etData[objItem.jobId] = {
+                ...(((_objItem$nextState$da5 = objItem.nextState.data) === null || _objItem$nextState$da5 === void 0 ? void 0 : _objItem$nextState$da5.output) || {}),
+                workflowInstanceId: objItem.nextState.workflowInstanceId,
+                additionalData: (objItem === null || objItem === void 0 ? void 0 : objItem.additionalData) || {}
+              };
+              (((_eventOutputData$etDa = eventOutputData.etData[objItem.jobId]) === null || _eventOutputData$etDa === void 0 ? void 0 : _eventOutputData$etDa.meta) || ((_eventOutputData$etDa2 = eventOutputData.etData[objItem.jobId]) === null || _eventOutputData$etDa2 === void 0 ? void 0 : _eventOutputData$etDa2.meta) === null) && ((_eventOutputData$etDa3 = eventOutputData.etData[objItem.jobId]) === null || _eventOutputData$etDa3 === void 0 ? true : delete _eventOutputData$etDa3.meta);
+            });
+            eventOutputData.nextTaskId = nextStateList[0].nextState.taskId;
+            eventOutputData.etData[Object.keys(eventOutputData.etData)[0]].eventCode !== _constants.GO_BACK_EVENT_CODE ? (0, _EventDispatcher.default)('END', etStates[0].nextState.name, eventOutputData) : (0, _EventDispatcher.default)('BACK', etStates[0].nextState.name, eventOutputData);
+          }
           navigation.replace(nextStateList[0].nextState.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, isJobBasedOutput) {
     baseETProps.showProgress(true);
-    await this.saveAndProceedToNextET(baseETProps, etOutput, etStates, navigation, isLastTask);
+    await this.saveAndProceedToNextET(baseETProps, etOutput, states, navigation, isLastTask, isJobBasedOutput);
   }
-
 }
-
 exports.default = DispatchStateContainer;
-
 _defineProperty(DispatchStateContainer, "instance", void 0);
 //# sourceMappingURL=DispatchStateContainer.js.map