@os1-platform/dispatch-mobile 2.1.1 → 2.1.2

package/src/manager/dispatch/DispatchStateContainer.tsx

@@ -1,842 +0,0 @@
-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
-    );
-  }
-}