@os1-platform/dispatch-mobile 1.0.8 → 2.0.0

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

@@ -1,10 +1,10 @@
-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';
-import Storage from '../../utils/storage';
-import { EmptyJobError, EngineNotReadyError, ETIdInvalidError, ExecutionEngine, JobNotFoundError, JobStatusInvalidError, ObjectiveJobAlreadyCompletedError, ObjectiveNotFoundError, ObjectiveNotReadyError, QuerySucceededObjectiveError } from 'mobile-execution-lib';
+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 } from '../../utils/SyncManagerUtils';
+import { DispatchExecutor as dispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
 import { showToast } from '../../components/widgets/Toaster';
-import { BaseEventCodes, CustomScreens, ExecutionTaskID, FinalETName } from '../../models/execTasks/ETConfig';
+import { CustomScreens, ExecutionTaskID } from '../../models/execTasks/ETConfig';
 import EventsSyncManager from '../syncmanager/events/EventsSyncManager';
 import Logger, { LOG_TYPE } from '../../utils/Logger';
 import DispatchSdkCache from '../sdk/DispatchSdkCache';
@@ -15,24 +15,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';
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+// NEW CODE
+import { BULK_DATA_LIMIT, LAST_SYNCED_EVENT_ID, SCAN_MERGED_OBJ_ID_OUTPUT, SHARED_PREFERENCE_DISPATCH_ID, SHARED_PREFERENCE_SCAN_OUTPUT } from '../syncmanager/constants';
+import Storage from '../../utils/storage';
+import { clearScanOutput, getScanMergedObjectID } from '../../components/executiontasks/scan/utils';
 export default class DispatchStateContainer {
   constructor() {
-    _defineProperty(this, "dispatchExecutor", new ExecutionEngine());
-
+    _defineProperty(this, "cacheKeys", DispatchSdkCache.KEYS);
+    _defineProperty(this, "cache", DispatchSdkCache.getInstance());
     _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, "_mappedStatesData", new Map());
+    _defineProperty(this, "saveAndProceedToNextET", debounce(async (baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput) => {
       try {
-        await this.sendETOutput(etOutput, etStates);
-        await this.moveToNextET(baseETProps, etStates, navigation, isLastTask);
+        await this.sendETOutput(etOutput, states, isMergedObjectiveBasedOutput);
+        await this.moveToNextET(etOutput, baseETProps, states, navigation, isLastTask);
       } catch (error) {
         Logger.getInstance().logEvent('saveAndProceed', error.message, LOG_TYPE.SDK_ERROR);
         baseETProps.showProgress(false);
@@ -40,194 +46,218 @@ 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
    * @param jobs
-   * @param logging
+   * @param dispatchWorkflows
    * @param maxTaskReattempt
    */
-  async initDispatchExecutor(dispatchID, jobs, logging, maxTaskReattempt) {
-    if (!dispatchID || !jobs || jobs.length < 1) {
+  async initDispatchExecutor(dispatchID, jobs, dispatchWorkflows, maxTaskReattempt) {
+    if (!dispatchID || !jobs || jobs.length < 1 || !dispatchWorkflows || Object.keys(dispatchWorkflows).length < 1) {
       Logger.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,
-      deleteDbItemsCallback: storage.deleteMultiple,
-      getDbKeysCallback: storage.getAllKeys,
-      eventSyncCallback: pushEventForSync
-    }, {
-      startTaskName: FinalETName.START_WORKFLOW,
-      successTaskName: FinalETName.COMPLETED_SUCCESS,
-      failureTaskName: FinalETName.COMPLETED_FAILURE,
-      maxTaskReattempts: maxTaskReattempt,
-      logLevel: logging ? 'debug' : 'emerg'
+
+    // NEW CODE
+    let storage = Storage.getInstance();
+    const sharedPreferenceDispatchId = await storage.getSharedItem(SHARED_PREFERENCE_DISPATCH_ID);
+    if (sharedPreferenceDispatchId) {
+      if (sharedPreferenceDispatchId !== dispatchID) {
+        await Promise.all([storage.setSharedItem(SHARED_PREFERENCE_DISPATCH_ID, dispatchID), storage.setSharedItem(LAST_SYNCED_EVENT_ID, '0')]);
+      }
+    } else {
+      await Promise.all([storage.setSharedItem(SHARED_PREFERENCE_DISPATCH_ID, dispatchID), storage.setSharedItem(LAST_SYNCED_EVENT_ID, '0')]);
+    }
+    await dispatchExecutor.start(dispatchID, jobs, dispatchWorkflows, {
+      maxTaskReattempt,
+      eventSyncBatchSize: BULK_DATA_LIMIT
     });
   }
 
-  async bulkQueryNextET(jobObjectiveList) {
-    if (!jobObjectiveList || jobObjectiveList.length === 0) {
-      Logger.getInstance().logEvent('bulkQueryNextET', 'CONSTRAINTS FAILED', LOG_TYPE.SDK_ERROR);
+  // NEW CODE
+  /**
+   *
+   * @param mergedObjectiveId
+   * @returns IExecutionTaskQueryResponse {
+   *    mergedObjectiveId: string;
+   *    taskName: string;
+   *    taskId: string;
+   *    input: any;
+   * }
+   */
+
+  async queryNextET(mergedObjectiveId, statusFilter) {
+    if (!mergedObjectiveId) {
+      Logger.getInstance().logEvent('queryNextET', '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);
+    return await dispatchExecutor.getNextTask(mergedObjectiveId[0], statusFilter);
+  }
+  async updateScanETOutputSharedPreference(etOutput, prefixedMergedObjectiveId, prefixKey) {
+    etOutput.mergedObjectiveIds = prefixedMergedObjectiveId;
+    let storage = Storage.getInstance();
+    const output = await storage.getSharedItem(SHARED_PREFERENCE_SCAN_OUTPUT);
+    if (output) {
+      const scanETOutput = JSON.parse(output);
+      let _scanETOutput = {};
+      if (scanETOutput[prefixKey]) {
+        _scanETOutput = scanETOutput[prefixKey];
       }
+      prefixedMergedObjectiveId.forEach(mergedId => {
+        _scanETOutput[mergedId] = etOutput;
+      });
 
-      if (nState) {
-        if (this._mappedStates.has(nState.taskId)) {
-          const val = this._mappedStates.get(nState.taskId);
-
-          val === null || val === void 0 ? void 0 : val.push({
-            nextState: nState,
-            objRef: o.objectiveId,
-            jobId: o.jobId
-          });
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify({
+        ...scanETOutput,
+        [prefixKey]: _scanETOutput
+      }));
+    } else {
+      const scanETOutput = {};
+      prefixedMergedObjectiveId.forEach(mergedId => {
+        scanETOutput[mergedId] = etOutput;
+      });
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify({
+        [prefixKey]: scanETOutput
+      }));
+    }
+  }
+  async updatePendingSharedPreference(eventType, prefixedMergedObjectiveId, prefixKey) {
+    let storage = Storage.getInstance();
+    const mergedIdOutput = await storage.getSharedItem(SCAN_MERGED_OBJ_ID_OUTPUT);
+    if (mergedIdOutput) {
+      const mergedIds = JSON.parse(mergedIdOutput);
+      const _mergedIds = mergedIds[prefixKey];
+      if (_mergedIds) {
+        if (eventType) {
+          _mergedIds.success.push(...prefixedMergedObjectiveId);
+          _mergedIds.pending = [];
         } else {
-          this._stateKeys.push(nState.taskId);
-
-          this._mappedStates.set(nState.taskId, [{
-            nextState: nState,
-            objRef: o.objectiveId,
-            jobId: o.jobId
-          }]);
+          _mergedIds.failure.push(...prefixedMergedObjectiveId);
+          _mergedIds.pending = [];
         }
+        await storage.setSharedItem(SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify({
+          ...mergedIds,
+          [prefixKey]: _mergedIds
+        }));
       }
     }
-
-    const taskID = this._stateKeys.pop();
-
-    if (taskID) {
-      const nextStates = this._mappedStates.get(taskID);
-
-      this._mappedStates.delete(taskID);
-
-      return nextStates ?? [];
-    } else return null;
   }
 
-  async queryNextTask(jobObjectiveList) {
-    try {
-      const promises = [];
-      jobObjectiveList.forEach(jobObjective => {
-        promises.push(this.queryObjective(jobObjective.objectiveId, jobObjective.jobId));
+  // NEW CODE
+  async sendETOutput(etOutput, states, isMergedObjectiveBasedOutput) {
+    const mergedObjectiveIds = states[RouteParams.NEXT_STATES].mergedObjectiveIds;
+    const taskName = states[RouteParams.NEXT_STATES].taskName;
+    const taskID = states[RouteParams.NEXT_STATES].taskId;
+    const input = states[RouteParams.NEXT_STATES].input;
+    let lockTaskResponse = true;
+    if (isMergedObjectiveBasedOutput) {
+      // NEW CODE
+      const output = etOutput;
+      let promises = [];
+      const prefixKey = this.findPrefixKey(mergedObjectiveIds, etOutput, states);
+      let defaultConfig = {
+        index: -1,
+        success: false,
+        output: {}
+      };
+      let mergedIds = {
+        success: [],
+        failure: [],
+        pending: [prefixKey]
+      };
+      const filterIds = await getScanMergedObjectID();
+      if (filterIds) {
+        mergedIds = filterIds[prefixKey];
+      }
+      Object.keys(etOutput).forEach(mergedObjectiveId => {
+        const _output = output[mergedObjectiveId].output;
+        // PREFIX_KEY
+        if (mergedObjectiveId === 'default') {
+          const defaultOutput = output['default'].output;
+          // DELIVER AT DIFF LOCATION
+          if (defaultOutput.eventCode === REASON_NOT_USED) {
+            // DO NOT SEND OUTPUT WHEN DELIVER AT DIFF LOCATION
+            defaultOutput.eventCode = '';
+            defaultOutput.reasonCode = '';
+            lockTaskResponse = false;
+          } else {
+            defaultConfig = {
+              index: promises.length,
+              success: defaultOutput.success,
+              output: output['default']
+            };
+            promises.push(dispatchExecutor.saveTaskOutput(mergedIds.pending, taskName, taskID, {
+              input,
+              output: defaultOutput
+            }, {
+              ec: defaultOutput.eventCode,
+              rc: defaultOutput.reasonCode || ''
+            }));
+          }
+        } else {
+          promises.push(dispatchExecutor.saveTaskOutput([mergedObjectiveId], taskName, taskID, {
+            input,
+            output: _output
+          }));
+        }
       });
-      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');
+      const response = await Promise.all(promises);
+      if (defaultConfig.index !== -1) {
+        // UPDATE PENDING IN SHARED PREFERENCE MERGED_SCAN_OUTPUT
+        this.updatePendingSharedPreference(defaultConfig.success, response[defaultConfig.index], prefixKey);
+        this.updateScanETOutputSharedPreference(defaultConfig.output, response[defaultConfig.index], prefixKey);
       }
-
-      return null;
+    } else {
+      await dispatchExecutor.saveTaskOutput(mergedObjectiveIds, taskName, taskID, {
+        input,
+        output: etOutput
+      });
     }
   }
-
-  async queryObjective(objRef, jobID) {
-    return await this.dispatchExecutor.queryObjectiveState(objRef, jobID);
-  }
-
-  async sendETOutput(etOutput, etState) {
-    if (!etState || etState.length === 0) {
-      Logger.getInstance().logEvent('sendETOutput', 'CONSTRAINTS FAILED', LOG_TYPE.SDK_ERROR);
-      return;
-    }
-
-    const promises = [];
-    etState.forEach(objItem => {
-      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;
-      }
-
-      objItem.nextState.data.output = { ...etOutput
-      };
-      promises.push(this.dispatchExecutor.lockObjectiveState(objItem.objRef, objItem.jobId, objItem.nextState));
-    });
-    await Promise.all(promises);
+  findPrefixKey(mergedObjectiveIds, scanOutput, routeParams) {
+    const prefixedMergedObjectiveId = routeParams[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+    return prefixedMergedObjectiveId;
   }
-
-  async saveETOutput(jobId, objRef, 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 +270,6 @@ export default class DispatchStateContainer {
             });
           }
         }
-
         return response;
       } else return response;
     } catch (error) {
@@ -248,51 +277,99 @@ 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, isMergeObjectiveBasedOutput) {
     try {
       baseETProps.showProgress(true);
+      const mergedObjectiveIds = route.params[RouteParams.NEXT_STATES].mergedObjectiveIds;
       const reasonsContainer = ReasonCodeContainer.getInstance();
-
-      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);
-          } else {
+      const eventsContainer = EventCodeContainer.getInstance();
+      if (isMergeObjectiveBasedOutput) {
+        await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+      } else {
+        const _eventCode = etOutput.eventCode;
+        if (etSuccess) {
+          if (!_eventCode) {
+            const _successApplicable = route.params[RouteParams.NEXT_STATES].input.applicableReasons.success;
+            const successEventCodes = await eventsContainer.getEventCodes(_successApplicable);
             let rParams;
-            rParams = { ...route.params
+            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.EVENT_CODES] = successEventCodes;
+            rParams[RouteParams.APPLICABLE_CODES] = _successApplicable;
+            rParams[RouteParams.IS_MERGED_OBJ_BASED_OUTPUT] = isMergeObjectiveBasedOutput;
+            rParams[RouteParams.ROOT_META_DATA] = route.params[RouteParams.ROOT_META_DATA];
+            rParams[RouteParams.CANCEL_EVENT] = '';
             navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+          } else {
+            const successCodes = await reasonsContainer.getReasonCodes(route.params[RouteParams.NEXT_STATES].input.applicableReasons.success ? route.params[RouteParams.NEXT_STATES].input.applicableReasons.success : route.params[RouteParams.NEXT_STATES].input.applicableReasons, _eventCode);
+            if (successCodes && successCodes.length > 0) {
+              if (successCodes.length === 1) {
+                if (isMergeObjectiveBasedOutput) etOutput.baseResponse.reasonCode = successCodes[0].reasonCode;else etOutput.reasonCode = successCodes[0].reasonCode;
+                await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+              } else {
+                let rParams;
+                rParams = {
+                  ...route.params
+                };
+                rParams[RouteParams.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.CANCEL_EVENT] = _eventCode;
+                navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+              }
+            } else {
+              await this.saveAndProceed(baseETProps, etOutput, route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+            }
           }
         } 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);
-          } else {
+          let failureCodes = [];
+          if (!_eventCode) {
+            const _failureApplicable = route.params[RouteParams.NEXT_STATES].input.applicableReasons.failure;
+            const failureEventCodes = await eventsContainer.getEventCodes(_failureApplicable);
             let rParams;
-            rParams = { ...route.params
+            rParams = {
+              ...route.params
             };
             rParams[RouteParams.ET_SUCCESS] = false;
+            // rParams[RouteParams.ET_SUCCESS_RESPONSE] = etOutput;
             rParams[RouteParams.CURRENT_ET_NAME] = eTaskID;
-            rParams[RouteParams.REASONS] = failureCodes;
             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.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].input.applicableReasons.failure ? route.params[RouteParams.NEXT_STATES].input.applicableReasons.failure : route.params[RouteParams.NEXT_STATES].input.applicableReasons, _eventCode);
+            if (failureCodes && failureCodes.length > 0) {
+              if (isMergeObjectiveBasedOutput) etOutput.baseResponse.reasonCode = failureCodes[0].reasonCode;
+              if (failureCodes.length === 1) {
+                await this.saveAndProceed(baseETProps, isMergeObjectiveBasedOutput ? etOutput : await getBaseETResponse(entityCode, false, _eventCode, failureCodes[0].reasonCode, mergedObjectiveIds, eTaskID), route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+              } 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.CANCEL_EVENT] = _eventCode;
+                navigation.replace(CustomScreens.REMARK_SCREEN, rParams);
+              }
+            } else {
+              await this.saveAndProceed(baseETProps, isMergeObjectiveBasedOutput ? etOutput : await getBaseETResponse(entityCode, false, _eventCode, '', mergedObjectiveIds, eTaskID), route.params, navigation, isLastTask, isMergeObjectiveBasedOutput);
+            }
           }
-        } else {
-          await this.saveAndProceed(baseETProps, await getBaseETResponse(entityCode, false, BaseEventCodes.ENTITY_FAILURE, ''), route.params[RouteParams.NEXT_STATES], navigation, isLastTask);
         }
       }
     } catch (error) {
@@ -300,106 +377,116 @@ 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
-      });
-    });
-    return result;
-  }
-
-  async moveToNextET(baseETProps, etStates, navigation, isLastTask) {
+  async moveToNextET(etOutput, baseETProps, states, navigation, isLastTask) {
     try {
+      let etStates = states.next_states;
       baseETProps.showProgress(true);
-
-      if (isLastTask && etStates && etStates.length > 0) {
-        if (this._stateKeys.length !== 0) {
+      if (isLastTask && etStates && Object.keys(etStates).length > 0) {
+        if (this._mappedStates.size && this._stateKeys.length) {
           const st = this._stateKeys.pop();
-
           if (st) {
-            baseETProps.showProgress(false);
-
-            let nextStateList = this._mappedStates.get(st);
-
+            let rParams = {};
+            const _stData = this._mappedStates.get(st);
             this._mappedStates.delete(st);
-
-            if (nextStateList != null && nextStateList.length > 0) {
-              let rParams = {};
-              rParams[RouteParams.NEXT_STATES] = nextStateList;
-              navigation.replace(nextStateList[0].nextState.taskId, rParams);
+            if (_stData) {
+              rParams[RouteParams.NEXT_STATES] = _stData;
+              rParams[RouteParams.ROOT_META_DATA] = states.rootMetaData;
+              navigation.replace(_stData.taskId, rParams);
             }
-
-            return;
           }
-        }
-
-        let nextState = etStates[0];
-        let completeJobsSummary = [];
-        let objSummary = await this.getObjectiveSummary({
-          jobId: etStates[0].jobId,
-          objectiveId: etStates[0].objRef
-        });
-        completeJobsSummary.push({
-          jobId: etStates[0].jobId,
-          objectiveRef: etStates[0].objRef,
-          jobObjectiveSummary: objSummary
-        });
-
-        for (let i = 1; i < etStates.length; i++) {
-          let obs = await this.getObjectiveSummary({
-            jobId: etStates[i].jobId,
-            objectiveId: etStates[i].objRef
-          });
-          completeJobsSummary.push({
-            jobId: etStates[i].jobId,
-            objectiveRef: etStates[i].objRef,
-            jobObjectiveSummary: obs
-          });
-        }
-
-        baseETProps.showProgress(false);
-
-        if (nextState.nextState.taskId === ExecutionTaskID.COMPLETED_SUCCESS) {
-          navigation.replace(this.getSuccessRoute(), {
-            summary: objSummary,
-            completeSummary: completeJobsSummary,
-            objList: this.getJobObjectiveList(etStates),
-            objSuccess: true
-          });
         } else {
-          navigation.replace(this.getFailureRoute(), {
-            summary: objSummary,
-            completeSummary: completeJobsSummary,
-            objList: this.getJobObjectiveList(etStates),
-            objSuccess: false
-          });
+          baseETProps.showProgress(false);
+          // TODO: Remove this later
+          this.cache.clearKeys([this.cacheKeys.CURRENT_WORKING_TASK_ID]);
+          AppSyncManager.getInstance().isForceStartEnabled = true;
+          AppSyncManager.getInstance().isSyncActive = false;
+          AppSyncManager.getInstance().startSDKSyncManager();
+          let objSummary = {
+            success: [],
+            failure: []
+          };
+          for (let [_key, _value] of this._mappedStatesData) {
+            const _objKey = _key === ExecutionTaskID.COMPLETED_SUCCESS ? 'success' : 'failure';
+            const lastERCData = await DispatchExecutor.getlastERC(_value.mergedObjectiveIds);
+            for (const _lastER of lastERCData) {
+              var _objSummary$_objKey;
+              const reason = await ReasonCodeContainer.getInstance().getReasonByCode(_lastER.lastReasonCode);
+              (_objSummary$_objKey = objSummary[_objKey]) === null || _objSummary$_objKey === void 0 ? void 0 : _objSummary$_objKey.push({
+                entityCode: _lastER.lastEntityCode,
+                eventCode: _lastER.lastEventCode,
+                reasonCode: _lastER.lastReasonCode,
+                reasonCodeDesc: reason === null || reason === void 0 ? void 0 : reason.description
+              });
+            }
+          }
+          if (this._mappedStatesData.get(ExecutionTaskID.COMPLETED_SUCCESS)) {
+            this._mappedStatesData.clear();
+            this._mappedStates.clear();
+            this._stateKeys = [];
+            clearScanOutput(states.rootMetaData.prefixedMergedObjectiveId);
+            navigation.replace(this.getSuccessRoute(), {
+              summary: objSummary,
+              objSuccess: true
+            });
+          } else {
+            this._mappedStatesData.clear();
+            this._mappedStates.clear();
+            this._stateKeys = [];
+            clearScanOutput(states.rootMetaData.prefixedMergedObjectiveId);
+            navigation.replace(this.getFailureRoute(), {
+              summary: objSummary,
+              objSuccess: false
+            });
+          }
         }
       } else {
-        let nextStateList = await this.bulkQueryNextET(this.getJobObjectiveList(etStates));
+        let rParams = {};
+        let nextStateDataArray = await this.queryNextET(states.next_states.mergedObjectiveIds, states.rootMetaData.statusFilter);
+        const storeTerminalData = nextStateDataArray.every(_state => _state.taskId === ExecutionTaskID.COMPLETED_SUCCESS || _state.taskId === ExecutionTaskID.COMPLETED_FAILURE);
+        if (storeTerminalData) {
+          if (nextStateDataArray.length === 2) {
+            // Array in case of last states containing c-s and c-f
+            this._mappedStates.set(nextStateDataArray[1].taskId, nextStateDataArray[1]);
+            this._stateKeys.push(nextStateDataArray[1].taskId);
+          }
+          nextStateDataArray.forEach(data => {
+            if (data.taskId === ExecutionTaskID.COMPLETED_SUCCESS || data.taskId === ExecutionTaskID.COMPLETED_FAILURE) this._mappedStatesData.set(data.taskId, data);
+          });
+        }
+        const nextStateData = nextStateDataArray[0];
         baseETProps.showProgress(false);
-
-        if (nextStateList != null && nextStateList.length > 0) {
-          let rParams = {};
-          rParams[RouteParams.NEXT_STATES] = nextStateList;
-          navigation.replace(nextStateList[0].nextState.taskId, rParams);
+        if (nextStateData != null && Object.keys(nextStateData).length > 0) {
+          rParams[RouteParams.NEXT_STATES] = nextStateData;
+          rParams[RouteParams.ROOT_META_DATA] = states.rootMetaData;
+
+          /**
+           * Send END/BACK custom event
+           */
+          if (!isLastTask) {
+            var _etOutput$baseRespons;
+            const eventOutputData = {
+              meta: (etOutput === null || etOutput === void 0 || (_etOutput$baseRespons = etOutput.baseResponse) === null || _etOutput$baseRespons === void 0 ? void 0 : _etOutput$baseRespons.meta) || (etOutput === null || etOutput === void 0 ? void 0 : etOutput.meta) || {},
+              etData: etOutput,
+              taskId: etStates.taskId,
+              nextTaskId: '',
+              timestamp: Date.now(),
+              customData: rParams[RouteParams.ROOT_META_DATA].customEventsData
+            };
+            eventOutputData.nextTaskId = nextStateData.taskId;
+            eventOutputData.etData.eventCode !== GO_BACK_EVENT_CODE ? dispatchEvent('END', etStates.taskName, eventOutputData) : dispatchEvent('BACK', etStates.taskName, eventOutputData);
+          }
         }
+        navigation.replace(nextStateData.taskId, rParams);
       }
     } catch (error) {
       baseETProps.showProgress(false);
       Logger.getInstance().logEvent('moveToNextET', error.message, LOG_TYPE.SDK_ERROR);
     }
   }
-
-  async saveAndProceed(baseETProps, etOutput, etStates, navigation, isLastTask) {
+  async saveAndProceed(baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput) {
     baseETProps.showProgress(true);
-    await this.saveAndProceedToNextET(baseETProps, etOutput, etStates, navigation, isLastTask);
+    await this.saveAndProceedToNextET(baseETProps, etOutput, states, navigation, isLastTask, isMergedObjectiveBasedOutput);
   }
-
 }
-
 _defineProperty(DispatchStateContainer, "instance", void 0);
 //# sourceMappingURL=DispatchStateContainer.js.map