@os1-platform/dispatch-mobile 1.0.7 → 1.3.11

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

@@ -1,10 +1,11 @@
-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; }
-
-import { clearCache, createFmsFolder, pushEventForSync } from '../../utils/SyncManagerUtils';
+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); }
+import { clearCache, createFmsFolder, pushBulkEventForSync } from '../../utils/SyncManagerUtils';
 import Storage from '../../utils/storage';
-import { EmptyJobError, EngineNotReadyError, ETIdInvalidError, ExecutionEngine, JobNotFoundError, JobStatusInvalidError, ObjectiveJobAlreadyCompletedError, ObjectiveNotFoundError, ObjectiveNotReadyError, QuerySucceededObjectiveError } from 'mobile-execution-lib';
+import { ExecutionEngine } from '@os1-platform/mobile-execution-lib';
 import { showToast } from '../../components/widgets/Toaster';
-import { BaseEventCodes, CustomScreens, ExecutionTaskID, FinalETName } from '../../models/execTasks/ETConfig';
+import { BaseEventCodes, CustomScreens, EntityCode, ExecutionTaskID, FinalETName } from '../../models/execTasks/ETConfig';
 import EventsSyncManager from '../syncmanager/events/EventsSyncManager';
 import Logger, { LOG_TYPE } from '../../utils/Logger';
 import DispatchSdkCache from '../sdk/DispatchSdkCache';
@@ -15,24 +16,30 @@ import BaseErrorCodes from '../../errors/ErrorCodes';
 import ErrorCodes, { InvalidArgumentsError } from '../../errors/ErrorCodes';
 import { RouteParams } from '../../ui/uiConfig/RouteParams';
 import { debounce } from 'lodash';
+import dispatchEvent from '../../events/EventDispatcher';
+import EventCodeContainer from '../dispatchCodes/EventCodeContainer';
+import { GO_BACK_EVENT_CODE, REASON_NOT_USED } from '../../constants/constants';
+import AppSyncManager from '../syncmanager/AppSyncManager';
 export default class DispatchStateContainer {
   constructor() {
+    _defineProperty(this, "cacheKeys", DispatchSdkCache.KEYS);
+    _defineProperty(this, "cache", DispatchSdkCache.getInstance());
     _defineProperty(this, "dispatchExecutor", new ExecutionEngine());
-
     _defineProperty(this, "successRoute", null);
-
     _defineProperty(this, "failureRoute", null);
-
     _defineProperty(this, "_stateKeys", []);
-
     _defineProperty(this, "_jobObjectives", null);
-
     _defineProperty(this, "_mappedStates", new Map());
-
-    _defineProperty(this, "saveAndProceedToNextET", debounce(async (baseETProps, etOutput, etStates, navigation, isLastTask) => {
+    _defineProperty(this, "saveAndProceedToNextET", 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.getInstance().logEvent('saveAndProceed', error.message, LOG_TYPE.SDK_ERROR);
         baseETProps.showProgress(false);
@@ -40,23 +47,18 @@ export default class DispatchStateContainer {
       }
     }, 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
@@ -69,17 +71,21 @@ export default class DispatchStateContainer {
       Logger.getInstance().logEvent('initDispatchExecutor', InvalidArgumentsError, LOG_TYPE.SDK_WARNING);
       throw new BaseError(BaseErrorCodes.InvalidArgumentError, InvalidArgumentsError);
     }
-
     let storage = Storage.getInstance();
     await clearCache(dispatchID);
     await DispatchSdkCache.getInstance().setKeyInCache(DispatchSdkCache.KEYS.DISPATCH_ID, dispatchID);
     await 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: pushEventForSync
+      // eventSyncCallback: pushEventForSync,
+      eventBulkSyncCallback: pushBulkEventForSync
     }, {
       startTaskName: FinalETName.START_WORKFLOW,
       successTaskName: FinalETName.COMPLETED_SUCCESS,
@@ -89,145 +95,319 @@ export default 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.getInstance().logEvent('bulkQueryNextET', 'CONSTRAINTS FAILED', LOG_TYPE.SDK_ERROR);
       throw new BaseError(ErrorCodes.MERGING_ERROR, 'CONSTRAINTS FAILED');
     }
-
-    for (const o of jobObjectiveList) {
-      let nState = null;
-
-      try {
-        nState = await this.queryObjective(o.objectiveId, o.jobId);
-      } catch (error) {
-        Logger.getInstance().logEvent('bulkQueryNextET', JSON.stringify({
-          error: error.message,
-          jobId: o.jobId,
-          objRef: o.objectiveId
-        }), 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.getInstance().logEvent('bulkQueryNextET', JSON.stringify({
+        error: error.message,
+        data: jobObjectiveList.map(_job => _job.jobId)
+      }), 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 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;
-    }
+  // 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.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', LOG_TYPE.SDK_ERROR);
       return;
     }
-
-    const promises = [];
-    etState.forEach(objItem => {
+    // const promises: any[] = [];
+    const _objectiveState = [];
+    etState.forEach((objItem, index) => {
       if (objItem.nextState.taskId === 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.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', LOG_TYPE.SDK_ERROR);
+      return;
+    }
+    // const promises: any[] = [];
+    const _objectiveState = [];
+    const _etDataVar = isPendingState ? 'pendingEtData' : 'etData';
+    etState.forEach((objItem, index) => {
+      if (objItem.nextState.taskId === 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.getInstance().getObjectiveSummary(jobObjective.jobId + jobObjective.objectiveId);
-
       if (summaryData) {
         for (const k in summaryData) {
           if (k === 'inputs') continue;else {
@@ -240,7 +420,6 @@ export default class DispatchStateContainer {
             });
           }
         }
-
         return response;
       } else return response;
     } catch (error) {
@@ -248,51 +427,132 @@ export default class DispatchStateContainer {
       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.getInstance();
-
+      const eventsContainer = EventCodeContainer.getInstance();
+      const _eventCode = isJobBasedOutput ? etOutput.baseResponse.eventCode : etOutput.eventCode;
+      const _isReasonNotToBeUsed = isJobBasedOutput ? etOutput.baseResponse.reasonCode === REASON_NOT_USED : etOutput.reasonCode === REASON_NOT_USED;
+      if (_isReasonNotToBeUsed) {
+        isJobBasedOutput ? etOutput.baseResponse.reasonCode = '' : etOutput.reasonCode = '';
+      }
+      if (isLastTask) {
+        if (route.params[RouteParams.PENDING_STATES] && route.params[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.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.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, BaseEventCodes.ENTITY_SUCCESS);
+          let _etOutput = JSON.parse(JSON.stringify(etOutput));
+          _etOutput.entityCode = EntityCode.COMPLETED_FAILURE;
+          _etOutput.success = true;
+          _etOutput.eventCode = 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.PENDING_STATES] = _states;
+        }
+      }
       if (etSuccess) {
-        const successCodes = await reasonsContainer.getReasonCodes(route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, 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.NEXT_STATES], navigation, isLastTask);
+        if (!_eventCode) {
+          const _successApplicable = route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success;
+          const successEventCodes = await eventsContainer.getEventCodes(_successApplicable);
+          let rParams;
+          rParams = {
+            ...route.params
+          };
+          rParams[RouteParams.ET_SUCCESS] = true;
+          rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
+          rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
+          rParams[RouteParams.IS_LAST_ET] = isLastTask;
+          rParams[RouteParams.EVENT_CODES] = successEventCodes;
+          rParams[RouteParams.APPLICABLE_CODES] = _successApplicable;
+          rParams[RouteParams.IS_JOB_BASED_OUTPUT] = isJobBasedOutput;
+          rParams[RouteParams.ROOT_META_DATA] = route.params[RouteParams.ROOT_META_DATA];
+          rParams[RouteParams.COMPLETED_STATES] = route.params[RouteParams.COMPLETED_STATES];
+          rParams[RouteParams.PENDING_STATES_OUTPUT] = route.params[RouteParams.PENDING_STATES_OUTPUT];
+          rParams[RouteParams.CANCEL_EVENT] = '';
+          navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+        } else {
+          const successCodes = await reasonsContainer.getReasonCodes(route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success ? route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.success : route.params[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.ET_SUCCESS] = true;
+              rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
+              rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
+              rParams[RouteParams.REASONS] = successCodes;
+              rParams[RouteParams.IS_LAST_ET] = isLastTask;
+              rParams[RouteParams.ROOT_META_DATA] = route.params[RouteParams.ROOT_META_DATA];
+              rParams[RouteParams.COMPLETED_STATES] = route.params[RouteParams.COMPLETED_STATES];
+              rParams[RouteParams.PENDING_STATES_OUTPUT] = route.params[RouteParams.PENDING_STATES_OUTPUT];
+              rParams[RouteParams.CANCEL_EVENT] = _eventCode;
+              navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+            }
           } else {
-            let rParams;
-            rParams = { ...route.params
-            };
-            rParams[RouteParams.ET_SUCCESS] = true;
-            rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
-            rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
-            rParams[RouteParams.REASONS] = successCodes;
-            rParams[RouteParams.IS_LAST_ET] = isLastTask;
-            navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+            await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isJobBasedOutput);
           }
-        } else {
-          await this.saveAndProceed(baseETProps, etOutput, route.params[RouteParams.NEXT_STATES], navigation, isLastTask);
         }
       } else {
-        const failureCodes = await reasonsContainer.getReasonCodes(route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons, BaseEventCodes.ENTITY_FAILURE);
-
-        if (failureCodes && failureCodes.length > 0) {
-          if (failureCodes.length === 1) {
-            await this.saveAndProceed(baseETProps, await getBaseETResponse(entityCode, false, BaseEventCodes.ENTITY_FAILURE, failureCodes[0].reasonCode), route.params[RouteParams.NEXT_STATES], navigation, isLastTask);
+        let failureCodes = [];
+        if (!_eventCode) {
+          const _failureApplicable = route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.failure;
+          const failureEventCodes = await eventsContainer.getEventCodes(_failureApplicable);
+          let rParams;
+          rParams = {
+            ...route.params
+          };
+          rParams[RouteParams.ET_SUCCESS] = false;
+          // rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
+          rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
+          rParams[RouteParams.IS_LAST_ET] = isLastTask;
+          rParams[RouteParams.EVENT_CODES] = failureEventCodes;
+          rParams[RouteParams.APPLICABLE_CODES] = _failureApplicable;
+          rParams[RouteParams.ROOT_META_DATA] = route.params[RouteParams.ROOT_META_DATA];
+          rParams[RouteParams.COMPLETED_STATES] = route.params[RouteParams.COMPLETED_STATES];
+          rParams[RouteParams.PENDING_STATES_OUTPUT] = route.params[RouteParams.PENDING_STATES_OUTPUT];
+          rParams[RouteParams.CANCEL_EVENT] = '';
+          navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+        } else {
+          if (_eventCode === GO_BACK_EVENT_CODE) failureCodes = [];else failureCodes = await reasonsContainer.getReasonCodes(route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.failure ? route.params[RouteParams.NEXT_STATES][0].nextState.data.input.applicableReasons.failure : route.params[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 getBaseETResponse(entityCode, false, _eventCode, failureCodes[0].reasonCode), route.params, navigation, isLastTask, isJobBasedOutput);
+            } else {
+              let rParams;
+              rParams = {
+                ...route.params
+              };
+              rParams[RouteParams.ET_SUCCESS] = false;
+              rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
+              rParams[RouteParams.REASONS] = failureCodes;
+              rParams[RouteParams.IS_LAST_ET] = isLastTask;
+              rParams[RouteParams.ROOT_META_DATA] = route.params[RouteParams.ROOT_META_DATA];
+              rParams[RouteParams.COMPLETED_STATES] = route.params[RouteParams.COMPLETED_STATES];
+              rParams[RouteParams.PENDING_STATES_OUTPUT] = route.params[RouteParams.PENDING_STATES_OUTPUT];
+              rParams[RouteParams.CANCEL_EVENT] = _eventCode;
+              navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+            }
           } else {
-            let rParams;
-            rParams = { ...route.params
-            };
-            rParams[RouteParams.ET_SUCCESS] = false;
-            rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
-            rParams[RouteParams.REASONS] = failureCodes;
-            rParams[RouteParams.IS_LAST_ET] = isLastTask;
-            navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+            await this.saveAndProceed(baseETProps, isJobBasedOutput ? etOutput : await getBaseETResponse(entityCode, false, _eventCode, ''), route.params, navigation, isLastTask, isJobBasedOutput);
           }
-        } else {
-          await this.saveAndProceed(baseETProps, await getBaseETResponse(entityCode, false, BaseEventCodes.ENTITY_FAILURE, ''), route.params[RouteParams.NEXT_STATES], navigation, isLastTask);
         }
       }
     } catch (error) {
@@ -300,43 +560,132 @@ export default class DispatchStateContainer {
       Logger.getInstance().logEvent('navigateToNextTask', error.message, 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.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 === ExecutionTaskID.COMPLETED_FAILURE) {
+                  var _states$0$nextState$d3, _states$0$nextState$d4, _failureCodes$2;
+                  const failureCodes = await ReasonCodeContainer.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, BaseEventCodes.ENTITY_SUCCESS);
+                  let _etOutput = JSON.parse(JSON.stringify(etOutput));
+                  _etOutput.entityCode = EntityCode.COMPLETED_FAILURE;
+                  _etOutput.success = true;
+                  _etOutput.eventCode = 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.NEXT_STATES] = _states;
+                  rParams[RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+                  rParams[RouteParams.COMPLETED_STATES] = [...(states.completed_states || []), ...etStates];
+                  rParams[RouteParams.PENDING_STATES_OUTPUT] = states.pending_states_output;
+                  rParams[RouteParams.ROOT_META_DATA] = states.rootMetaData;
+                  navigation.replace(_states[0].nextState.taskId, rParams);
+                }
+              } else {
+                let rParams = {};
+                rParams[RouteParams.NEXT_STATES] = nextStateList;
+                rParams[RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+                rParams[RouteParams.COMPLETED_STATES] = [...(states.completed_states || []), ...etStates];
+                rParams[RouteParams.PENDING_STATES_OUTPUT] = states.pending_states_output;
+                rParams[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({
@@ -348,7 +697,6 @@ export default 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,
@@ -360,9 +708,11 @@ export default class DispatchStateContainer {
             jobObjectiveSummary: obs
           });
         }
-
         baseETProps.showProgress(false);
-
+        this.cache.clearKeys([this.cacheKeys.CURRENT_WORKING_TASK_ID]);
+        AppSyncManager.getInstance().isForceStartEnabled = true;
+        AppSyncManager.getInstance().isSyncActive = false;
+        AppSyncManager.getInstance().startSDKSyncManager();
         if (nextState.nextState.taskId === ExecutionTaskID.COMPLETED_SUCCESS) {
           navigation.replace(this.getSuccessRoute(), {
             summary: objSummary,
@@ -381,10 +731,41 @@ export default class DispatchStateContainer {
       } else {
         let nextStateList = await this.bulkQueryNextET(this.getJobObjectiveList(etStates));
         baseETProps.showProgress(false);
-
         if (nextStateList != null && nextStateList.length > 0) {
           let rParams = {};
           rParams[RouteParams.NEXT_STATES] = nextStateList;
+          rParams[RouteParams.PENDING_STATES] = [...(states.pending_states || [])];
+          rParams[RouteParams.COMPLETED_STATES] = states.completed_states;
+          rParams[RouteParams.ROOT_META_DATA] = states.rootMetaData;
+          rParams[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 === 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 !== GO_BACK_EVENT_CODE ? dispatchEvent('END', etStates[0].nextState.name, eventOutputData) : dispatchEvent('BACK', etStates[0].nextState.name, eventOutputData);
+          }
           navigation.replace(nextStateList[0].nextState.taskId, rParams);
         }
       }
@@ -393,13 +774,10 @@ export default class DispatchStateContainer {
       Logger.getInstance().logEvent('moveToNextET', error.message, 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);
   }
-
 }
-
 _defineProperty(DispatchStateContainer, "instance", void 0);
 //# sourceMappingURL=DispatchStateContainer.js.map