@os1-platform/dispatch-mobile 2.0.8 → 2.1.0

package/src/manager/dispatch/DispatchStateContainer.tsx

@@ -0,0 +1,842 @@
+import { clearCache, createFmsFolder } from '../../utils/SyncManagerUtils';
+import {
+  DispatchExecutor as dispatchExecutor,
+  IDispatchExecutor,
+  IDispatch,
+} from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { showToast } from '../../components/widgets/Toaster';
+import {
+  CustomScreens,
+  ExecutionTaskID,
+} from '../../models/execTasks/ETConfig';
+import type {
+  ETSummary,
+  ObjectiveSummary,
+} from '../../models/execTasks/ETBaseModels';
+
+import EventsSyncManager from '../syncmanager/events/EventsSyncManager';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import DispatchSdkCache from '../sdk/DispatchSdkCache';
+import type {
+  BaseETProps,
+  endEvent,
+  JobObjectiveType,
+  stateParams,
+} from '../../models/DispatchModels';
+import { BaseError } from '../../errors/BaseError';
+import { getBaseETResponse } from '../../utils/ExecTaskUtils';
+import ReasonCodeContainer from '../dispatchCodes/ReasonCodeContainer';
+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';
+import { SCANNED_RECORD } from '../../components/executiontasks/scan/interfaces';
+import { SHARED_PREF_SCAN_OUTPUT_INTERFACE } from '../../components/executiontasks/scan/interfaces';
+import { ScannerOutput } from '../../components/executiontasks/scan/ScanSchema';
+
+export default class DispatchStateContainer {
+  cacheKeys = DispatchSdkCache.KEYS;
+  cache = DispatchSdkCache.getInstance();
+
+  get stateKeys(): string[] {
+    return this._stateKeys;
+  }
+
+  set stateKeys(value: string[]) {
+    this._stateKeys = value;
+  }
+  get mappedStates(): Map<string, IDispatch.IExecutionTaskQueryResponse> {
+    return this._mappedStates;
+  }
+
+  set mappedStates(value: Map<string, IDispatch.IExecutionTaskQueryResponse>) {
+    this._mappedStates = value;
+  }
+  private static instance: DispatchStateContainer;
+  private successRoute: string | null = null;
+  private failureRoute: string | null = null;
+
+  private _stateKeys: string[] = [];
+  public _jobObjectives: JobObjectiveType[] | null = null;
+  private _mappedStates: Map<string, IDispatch.IExecutionTaskQueryResponse> =
+    new Map<string, IDispatch.IExecutionTaskQueryResponse>();
+  private _mappedStatesData: Map<
+    string,
+    IDispatch.IExecutionTaskQueryResponse
+  > = new Map<string, IDispatch.IExecutionTaskQueryResponse>();
+
+  /**
+   * Call this function when dispatch data is fetched successfully in client app
+   * @param dispatchID
+   * @param jobs
+   * @param dispatchWorkflows
+   * @param maxTaskReattempt
+   */
+  public async initDispatchExecutor(
+    dispatchID: string,
+    jobs: IDispatchExecutor.Job[],
+    dispatchWorkflows: { [id: string]: IDispatchExecutor.Workflow },
+    maxTaskReattempt?: number
+  ) {
+    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
+      );
+    }
+    await clearCache(dispatchID);
+    await DispatchSdkCache.getInstance().setKeyInCache(
+      DispatchSdkCache.KEYS.DISPATCH_ID,
+      dispatchID
+    );
+    await createFmsFolder(dispatchID);
+
+    // 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,
+    });
+  }
+
+  // NEW CODE
+  /**
+   *
+   * @param mergedObjectiveId
+   * @returns IExecutionTaskQueryResponse {
+   *    mergedObjectiveId: string;
+   *    taskName: string;
+   *    taskId: string;
+   *    input: any;
+   * }
+   */
+
+  public async queryNextET(
+    mergedObjectiveId: Array<string>,
+    statusFilter: IDispatchExecutor.ExecutionStatus[]
+  ): Promise<IDispatch.IExecutionTaskQueryResponse[]> {
+    if (!mergedObjectiveId) {
+      Logger.getInstance().logEvent(
+        'queryNextET',
+        'CONSTRAINTS FAILED',
+        LOG_TYPE.SDK_ERROR
+      );
+      throw new BaseError(ErrorCodes.MERGING_ERROR, 'CONSTRAINTS FAILED');
+    }
+
+    return await dispatchExecutor.getNextTask(
+      mergedObjectiveId[0],
+      statusFilter
+    );
+  }
+
+  private async updateScanETOutputSharedPreference(
+    etOutput: any,
+    prefixedMergedObjectiveId: Array<string>,
+    prefixKey: string
+  ) {
+    etOutput.mergedObjectiveIds = prefixedMergedObjectiveId;
+    let storage = Storage.getInstance();
+    const output = await storage.getSharedItem(SHARED_PREFERENCE_SCAN_OUTPUT);
+
+    if (output) {
+      const scanETOutput: SHARED_PREF_SCAN_OUTPUT_INTERFACE =
+        JSON.parse(output);
+      let _scanETOutput: ScannerOutput = {};
+      if (scanETOutput[prefixKey]) {
+        _scanETOutput = scanETOutput[prefixKey];
+      }
+      prefixedMergedObjectiveId.forEach((mergedId: string) => {
+        _scanETOutput[mergedId] = etOutput;
+      });
+
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(
+        SHARED_PREFERENCE_SCAN_OUTPUT,
+        JSON.stringify({ ...scanETOutput, [prefixKey]: _scanETOutput })
+      );
+    } else {
+      const scanETOutput: SHARED_PREF_SCAN_OUTPUT_INTERFACE = {};
+      prefixedMergedObjectiveId.forEach((mergedId: string) => {
+        scanETOutput[mergedId] = etOutput;
+      });
+      // SAVE IN SHARED PREFERENCE
+      await storage.setSharedItem(
+        SHARED_PREFERENCE_SCAN_OUTPUT,
+        JSON.stringify({ [prefixKey]: scanETOutput })
+      );
+    }
+  }
+
+  private async updatePendingSharedPreference(
+    eventType: boolean,
+    prefixedMergedObjectiveId: Array<string>,
+    prefixKey: string
+  ) {
+    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 {
+          _mergedIds.failure.push(...prefixedMergedObjectiveId);
+          _mergedIds.pending = [];
+        }
+
+        await storage.setSharedItem(
+          SCAN_MERGED_OBJ_ID_OUTPUT,
+          JSON.stringify({ ...mergedIds, [prefixKey]: _mergedIds })
+        );
+      }
+    }
+  }
+
+  // NEW CODE
+  public async sendETOutput(
+    etOutput: any,
+    states: any,
+    isMergedObjectiveBasedOutput?: boolean
+  ) {
+    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: boolean = true;
+
+    if (isMergedObjectiveBasedOutput) {
+      // NEW CODE
+      const output = etOutput;
+      let promises: any = [];
+
+      const prefixKey = this.findPrefixKey(
+        mergedObjectiveIds,
+        etOutput,
+        states
+      );
+
+      let defaultConfig: { index: number; success: boolean; output: any } = {
+        index: -1,
+        success: false,
+        output: {},
+      };
+      let mergedIds: SCANNED_RECORD = {
+        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,
+              }
+            )
+          );
+        }
+      });
+
+      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
+        );
+      }
+    } else {
+      await dispatchExecutor.saveTaskOutput(
+        mergedObjectiveIds,
+        taskName,
+        taskID,
+        {
+          input,
+          output: etOutput,
+        }
+      );
+    }
+  }
+
+  private findPrefixKey(
+    mergedObjectiveIds: Array<string>,
+    scanOutput: { [mergedObjectiveId: string]: any },
+    routeParams: any
+  ) {
+    const prefixedMergedObjectiveId =
+      routeParams[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+
+    return prefixedMergedObjectiveId;
+  }
+
+  public static getInstance(): DispatchStateContainer {
+    if (!DispatchStateContainer.instance) {
+      DispatchStateContainer.instance = new DispatchStateContainer();
+    }
+    return DispatchStateContainer.instance;
+  }
+
+  public setSuccessRoute(route: string) {
+    this.successRoute = route;
+  }
+  public getSuccessRoute(): string | null {
+    return this.successRoute;
+  }
+  public setFailureRoute(route: string) {
+    this.failureRoute = route;
+  }
+  public getFailureRoute(): string | null {
+    return this.failureRoute;
+  }
+  public async getObjectiveSummary(
+    jobObjective: JobObjectiveType
+  ): Promise<ETSummary[]> {
+    try {
+      let response: ETSummary[] = [];
+      let summaryData =
+        await EventsSyncManager.getInstance().getObjectiveSummary(
+          jobObjective.jobId + jobObjective.objectiveId
+        );
+      if (summaryData) {
+        for (const k in summaryData) {
+          if (k === 'inputs') continue;
+          else {
+            const reason =
+              await ReasonCodeContainer.getInstance().getReasonByCode(
+                summaryData[k].output.reasonCode
+              );
+            response.push({
+              eventCode: summaryData[k].output.eventCode,
+              reasonCode: summaryData[k].output.reasonCode,
+              reasonCodeDesc: reason?.description,
+              name: k,
+            });
+          }
+        }
+        return response;
+      } else return response;
+    } catch (error: any) {
+      Logger.getInstance().logEvent(
+        'getObjectiveSummary',
+        error.message,
+        LOG_TYPE.SDK_ERROR
+      );
+      return [];
+    }
+  }
+  public async navigateToNextTask(
+    navigation: any,
+    route: any,
+    etOutput: any,
+    etSuccess: boolean,
+    entityCode: string,
+    eTaskID: ExecutionTaskID,
+    baseETProps: BaseETProps,
+    isLastTask?: boolean,
+    isMergeObjectiveBasedOutput?: boolean
+  ) {
+    try {
+      baseETProps.showProgress(true);
+      const mergedObjectiveIds =
+        route.params[RouteParams.NEXT_STATES].mergedObjectiveIds;
+      const reasonsContainer = ReasonCodeContainer.getInstance();
+      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: any;
+            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_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: any;
+                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 {
+          let failureCodes: any[] = [];
+          if (!_eventCode) {
+            const _failureApplicable =
+              route.params[RouteParams.NEXT_STATES].input.applicableReasons
+                .failure;
+            const failureEventCodes = await eventsContainer.getEventCodes(
+              _failureApplicable
+            );
+
+            let rParams: any;
+            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.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: any;
+                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
+              );
+            }
+          }
+        }
+      }
+    } catch (error: any) {
+      baseETProps.showProgress(false);
+      Logger.getInstance().logEvent(
+        'navigateToNextTask',
+        error.message,
+        LOG_TYPE.SDK_ERROR
+      );
+    }
+  }
+
+  async moveToNextET(
+    etOutput: any,
+    baseETProps: BaseETProps,
+    states: stateParams,
+    navigation: any,
+    isLastTask?: boolean
+  ) {
+    try {
+      let etStates = states.next_states;
+      baseETProps.showProgress(true);
+
+      if (isLastTask && etStates && Object.keys(etStates).length > 0) {
+        if (this._mappedStates.size && this._stateKeys.length) {
+          const st = this._stateKeys.pop();
+          if (st) {
+            let rParams: any = {};
+            const _stData = this._mappedStates.get(st);
+            this._mappedStates.delete(st);
+            if (_stData) {
+              rParams[RouteParams.NEXT_STATES] = _stData;
+              rParams[RouteParams.ROOT_META_DATA] = states.rootMetaData;
+              navigation.replace(_stData.taskId, rParams);
+            }
+          }
+        } else {
+          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?: ObjectiveSummary[];
+            failure?: ObjectiveSummary[];
+          } = {
+            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) {
+              const reason =
+                await ReasonCodeContainer.getInstance().getReasonByCode(
+                  _lastER.lastReasonCode
+                );
+
+              objSummary[_objKey]?.push({
+                entityCode: _lastER.lastEntityCode,
+                eventCode: _lastER.lastEventCode,
+                reasonCode: _lastER.lastReasonCode,
+                reasonCodeDesc: 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 rParams: any = {};
+
+        let nextStateDataArray: IDispatch.IExecutionTaskQueryResponse[] =
+          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 (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) {
+            const eventOutputData: endEvent = {
+              meta: etOutput?.baseResponse?.meta || 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: any) {
+      baseETProps.showProgress(false);
+      Logger.getInstance().logEvent(
+        'moveToNextET',
+        error.message,
+        LOG_TYPE.SDK_ERROR
+      );
+    }
+  }
+
+  private saveAndProceedToNextET = debounce(
+    async (
+      baseETProps: BaseETProps,
+      etOutput: any,
+      states: stateParams,
+      navigation: any,
+      isLastTask?: boolean,
+      isMergedObjectiveBasedOutput?: boolean
+    ) => {
+      try {
+        await this.sendETOutput(etOutput, states, isMergedObjectiveBasedOutput);
+        await this.moveToNextET(
+          etOutput,
+          baseETProps,
+          states,
+          navigation,
+          isLastTask
+        );
+      } catch (error: any) {
+        Logger.getInstance().logEvent(
+          'saveAndProceed',
+          error.message,
+          LOG_TYPE.SDK_ERROR
+        );
+        baseETProps.showProgress(false);
+        showToast(error.message);
+      }
+    },
+    800
+  );
+
+  public async saveAndProceed(
+    baseETProps: BaseETProps,
+    etOutput: any,
+    states: stateParams,
+    navigation: any,
+    isLastTask?: boolean,
+    isMergedObjectiveBasedOutput?: boolean
+  ) {
+    baseETProps.showProgress(true);
+    await this.saveAndProceedToNextET(
+      baseETProps,
+      etOutput,
+      states,
+      navigation,
+      isLastTask,
+      isMergedObjectiveBasedOutput
+    );
+  }
+}