@os1-platform/dispatch-mobile 2.1.1 → 2.1.2

package/src/components/executiontasks/scan/utils.ts

@@ -1,1108 +0,0 @@
-import { BarCodeScanner } from 'expo-barcode-scanner';
-import {
-  ADD_SCAN,
-  ExpoBarcodeTypes,
-  MergedScan,
-  SCANNED_RECORD,
-  SCAN_MERGED_OBJ_ID_INTEFACE,
-  SCAN_STATUS,
-  SHARED_PREF_SCAN_OUTPUT_INTERFACE,
-  SummaryDisplayData,
-  SummaryPageTabs,
-  TabRecord,
-} from './interfaces';
-import {
-  API,
-  DefaultERC,
-  DeliverState,
-  IWIMappingUpdate,
-  ScanData,
-  ScanMode,
-  ScannerInput,
-  ScannerOutput,
-  ScannerType,
-  Validation,
-} from './ScanSchema';
-import * as jsonLogic from 'json-logic-js';
-import type { ercItem } from './sub_components/ERDropDown';
-import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
-import {
-  EntityCode,
-  ExecutionTaskID,
-} from '../../../models/execTasks/ETConfig';
-import {
-  APIData,
-  getApiResponse,
-  parseBody,
-  parseKeyValue,
-} from '../../../utils/ApiUtils';
-import Logger, { LOG_TYPE } from '../../../utils/Logger';
-import { REASON_NOT_USED } from '../../../constants/constants';
-import Storage from '../../../utils/storage';
-import {
-  BULK_DATA_LIMIT,
-  SCAN_MERGED_OBJ_ID_OUTPUT,
-  SHARED_PREFERENCE_SCAN_OUTPUT,
-} from '../../../manager/syncmanager/constants';
-import { RouteParams } from '../../../ui/uiConfig/RouteParams';
-import dispatchEvent from '../../../events/EventDispatcher';
-import {
-  DispatchExecutor,
-  IDispatch,
-  WIErrorCodes,
-  ErrorCodeMessages,
-} from '@os1-platform/platform-coreos-execution-engine-sdk';
-import { isEmptyOrBlank } from '../../../utils/utils';
-import { EMPTY_AWB, ER_MISSING, INVALID_SHIPMENT } from './constants';
-import { onScanEvent, onScanRemoveEvent } from '../../../models/DispatchModels';
-import { BaseETResponse } from '../ExecutionTasksIndex';
-import { eventType } from '../../../events/interface';
-import { getDefaultERCLabel } from './sub_components/DropDownUtils';
-import { SnackBarType } from '../../../components/widgets/SnackBarCustom';
-
-export function getBarCodeTypes(input: ScannerInput): any[] {
-  const barCodeType: any[] = [];
-  const {
-    scannedInput: { scanType },
-  } = input;
-  scanType.forEach((type: ScannerType) => {
-    switch (type) {
-      case ExpoBarcodeTypes.QRCODE:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.qr);
-        break;
-      case ExpoBarcodeTypes.aztec:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.aztec);
-        break;
-      case ExpoBarcodeTypes.codabar:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.codabar);
-        break;
-      case ExpoBarcodeTypes.code128:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.code128);
-        break;
-      case ExpoBarcodeTypes.code39:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.code39);
-        break;
-      case ExpoBarcodeTypes.code93:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.code93);
-        break;
-      case ExpoBarcodeTypes.datamatrix:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.datamatrix);
-        break;
-      case ExpoBarcodeTypes.ean13:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.ean13);
-        break;
-      case ExpoBarcodeTypes.ean8:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.ean8);
-        break;
-      case ExpoBarcodeTypes.itf14:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.itf14);
-        break;
-      case ExpoBarcodeTypes.pdf417:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.pdf417);
-        break;
-      case ExpoBarcodeTypes.upc_e:
-        barCodeType.push(BarCodeScanner.Constants.BarCodeType.upc_e);
-        break;
-
-      default:
-        break;
-    }
-  });
-  return barCodeType;
-}
-
-export async function checkForValidation(
-  scannedInput: string,
-  validation: Validation
-): Promise<boolean> {
-  // Scans Array
-  if (validation.selectedIndex === 0) {
-    return true;
-  }
-  // Validation Regex
-  else if (
-    validation.selectedIndex === 1 &&
-    typeof validation.logic === 'string'
-  ) {
-    const regex = new RegExp(validation.logic);
-    return regex.test(scannedInput);
-  }
-  // API
-  else if (
-    validation.selectedIndex === 2 &&
-    typeof validation.logic === 'object'
-  ) {
-    try {
-      //@ts-ignore
-      const api: API = validation.logic;
-      const apiData: APIData = {
-        errorJsonPath: '',
-        responseJsonPath: '',
-        uri: api.uri,
-        httpMethod: api.httpMethod,
-        timeout: api.timeout,
-        headers: api.headers,
-      };
-      if (api.requestBody) {
-        const parsedRequestBody = parseBody(api.requestBody, scannedInput);
-        apiData.requestBody = parsedRequestBody;
-      }
-      if (api.pathParams) {
-        parseKeyValue(api.pathParams, scannedInput);
-        apiData.pathParams = api.pathParams;
-      }
-      if (api.queryParams) {
-        parseKeyValue(api.queryParams, scannedInput);
-        apiData.queryParams = api.queryParams;
-      }
-      const apiResponse = await getApiResponse(apiData);
-
-      return jsonLogic.apply(
-        <jsonLogic.RulesLogic>api.responseJsonLogic,
-        apiResponse.data
-      );
-    } catch (error: any) {
-      Logger.getInstance().logEvent(
-        '~ checkForValidation',
-        error.message,
-        LOG_TYPE.SDK_ERROR
-      );
-      return false;
-    }
-  } else {
-    return false;
-  }
-}
-
-export function getShipmentData(
-  selectedIndex: number,
-  scansMap: Map<string, MergedScan>
-): [string[], string[]] {
-  const pendingShipments: string[] = [];
-  const scannedShipments: string[] = [];
-  //@ts-ignore
-  for (let [key, value] of scansMap.entries()) {
-    /**
-     * If scanStatus is undefined then push the shipment to pending.
-     * If scanStatus is not undefined:
-     *    Then if successfully scanned, move to scannedShipments array.
-     *    Else do nothing.
-     */
-    if (value?.scanStatus != undefined) {
-      if (value?.scanStatus === SCAN_STATUS.SCANNED) {
-        scannedShipments.push(key);
-      } else if (value?.scanStatus === SCAN_STATUS.FAILED) {
-        pendingShipments.push(key);
-      }
-    } else if (selectedIndex === 0) {
-      pendingShipments.push(key);
-    }
-  }
-  return [pendingShipments, scannedShipments];
-}
-
-export function getScannedItemCount(scansMap: Map<string, MergedScan>): number {
-  let scannedShipments = 0;
-  if (scansMap) {
-    for (let [, value] of scansMap.entries()) {
-      if (value.scanStatus === SCAN_STATUS.SCANNED) {
-        scannedShipments++;
-      }
-    }
-    return scannedShipments;
-  }
-  return scannedShipments;
-}
-
-export function getMappingCount(
-  scanOutput: ScannerOutput,
-  wiMappingUpdate: IWIMappingUpdate
-) {
-  const { mwId: mergedObjectiveId } = wiMappingUpdate.data;
-
-  if (scanOutput[mergedObjectiveId]) {
-    return scanOutput[mergedObjectiveId].count + 1;
-  } else {
-    return 1;
-  }
-}
-
-export async function getUpdatedScanETOutput(
-  scanOutput: ScannerOutput,
-  wiMappingUpdate: IWIMappingUpdate,
-  success: boolean,
-  eventCode: string,
-  reasonCode: string,
-  route: any,
-  scannedData: any
-) {
-  const prefixedMergedObjectiveId =
-    route.params[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
-  const { mwId: mergedObjectiveId, previousMWID: previousMergedObjectiveId } =
-    wiMappingUpdate.data;
-  const output = await getBaseETResponse(
-    EntityCode.SCAN,
-    success,
-    eventCode,
-    reasonCode,
-    [mergedObjectiveId],
-    ExecutionTaskID.SCAN
-  );
-  const _scannedData: any = [
-    {
-      groupId: scannedData.displayInfo.groupId,
-      jobId: scannedData.jobId,
-      shipmentFlow: scannedData.displayInfo.shipmentFlow,
-      scanValue: scannedData.scanId,
-    },
-  ];
-
-  scannedData?.isScan
-    ? triggerScanEvent('ON_SCAN', route, _scannedData, output)
-    : null;
-
-  if (scanOutput[previousMergedObjectiveId]) {
-    scanOutput[previousMergedObjectiveId].count -= 1;
-
-    if (scanOutput[previousMergedObjectiveId].count === 0) {
-      delete scanOutput[previousMergedObjectiveId];
-    }
-  }
-  const count = getMappingCount(scanOutput, wiMappingUpdate);
-
-  if (!scanOutput[mergedObjectiveId]) {
-    scanOutput[mergedObjectiveId] = { output, count };
-  } else {
-    scanOutput[mergedObjectiveId].count = count;
-  }
-
-  // SAVE IN SHARED PREFERENCE
-  let allScansOutput = (await getScanMappedOutput()) || {};
-  let storage = Storage.getInstance();
-  await storage.setSharedItem(
-    SHARED_PREFERENCE_SCAN_OUTPUT,
-    JSON.stringify({
-      ...allScansOutput,
-      [prefixedMergedObjectiveId]: scanOutput,
-    })
-  );
-  return scanOutput;
-}
-
-export async function getScanETOutput(
-  mergeScannedOutput: ScannerOutput,
-  mergedObjectiveId: Array<string>,
-  ercItems: ercItem[],
-  defaultERC: DefaultERC,
-  deliverState: DeliverState,
-  isPartial: boolean,
-  count: number
-): Promise<ScannerOutput> {
-  switch (deliverState) {
-    case DeliverState.CANCELLED: {
-      const output = await getBaseETResponse(
-        EntityCode.SCAN,
-        false,
-        defaultERC.eventCode,
-        defaultERC.reasonCode || '',
-        mergedObjectiveId,
-        ExecutionTaskID.SCAN
-      );
-      return {
-        [mergedObjectiveId[0]]: {
-          output,
-          count,
-        },
-      };
-    }
-    case DeliverState.DELIVERE_LATER: {
-      const output = await getBaseETResponse(
-        EntityCode.SCAN,
-        false,
-        REASON_NOT_USED,
-        '',
-        mergedObjectiveId,
-        ExecutionTaskID.SCAN
-      );
-      mergeScannedOutput['default'] = {
-        output,
-        count,
-      };
-      return mergeScannedOutput;
-    }
-    case DeliverState.DELIVER_NOW: {
-      if (isPartial) {
-        const output = await getBaseETResponse(
-          EntityCode.SCAN,
-          getEventType(ercItems, defaultERC.eventCode),
-          defaultERC.eventCode,
-          defaultERC.reasonCode || '',
-          mergedObjectiveId,
-          ExecutionTaskID.SCAN
-        );
-
-        mergeScannedOutput['default'] = { output, count };
-        return mergeScannedOutput;
-      } else {
-        return mergeScannedOutput;
-      }
-    }
-    default: {
-      return mergeScannedOutput;
-    }
-  }
-}
-
-export function getScannedItems(scanValue: MergedScan): ScanData[] {
-  const items: ScanData[] = [];
-  if (scanValue.scanStatus === SCAN_STATUS.SCANNED)
-    items.push({
-      value: scanValue.value,
-      validated: scanValue.validated || false,
-      timestamp: scanValue.timestamp || Date.now(),
-    });
-
-  return items;
-}
-
-export function isETCompleted(
-  validation: Validation,
-  scansMap: Map<string, MergedScan>,
-  scanMode: ScanMode,
-  isMultiObjectiveEnable: boolean,
-  scannedShipmentCount?: number,
-  singleModeCount?: number,
-  allowMultiObjectivePartial?: boolean
-): boolean {
-  if (scanMode === 'SINGLE' || isMultiObjectiveEnable) {
-    let _scannedShipmentCount = scannedShipmentCount || 0;
-
-    if (!scannedShipmentCount) {
-      const [, scannedShipments] = getShipmentData(
-        validation.selectedIndex,
-        scansMap
-      );
-      _scannedShipmentCount = scannedShipments.length;
-    }
-
-    if (allowMultiObjectivePartial) {
-      return _scannedShipmentCount >= 1;
-    }
-
-    return singleModeCount === _scannedShipmentCount;
-  } else {
-    // Scans Array
-    if (validation.selectedIndex === 0) {
-      //@ts-ignore
-      const scans: string[] = validation.logic;
-      if (!scannedShipmentCount) {
-        const [, scannedShipments] = getShipmentData(
-          validation.selectedIndex,
-          scansMap
-        );
-        return scans.length === scannedShipments.length;
-      }
-
-      return scans.length === scannedShipmentCount;
-    }
-    // Validation Regex
-    else if (
-      (validation.selectedIndex === 1 &&
-        typeof validation.logic === 'string') ||
-      (validation.selectedIndex === 2 && typeof validation.logic === 'object')
-    ) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-}
-
-export function isReplacement(
-  scan: string,
-  scansMap: Map<string, MergedScan>,
-  selectedEventCode: ercItem | undefined,
-  selectedReason: ercItem | undefined
-) {
-  if (
-    //(selectedEventCode || selectedReason) &&
-    //scansMap.get(scan)?.eventCode &&
-    scansMap.get(scan)?.eventCode !== selectedEventCode?.code || //scansMap.get(scan)?.reasonCode !== undefined &&
-    scansMap.get(scan)?.reasonCode !== selectedReason?.code
-  ) {
-    return true;
-  }
-  return false;
-}
-
-export function getEventType(
-  eventList: Array<ercItem>,
-  eventCode: string
-): boolean {
-  const result = eventList.find((code) => code.code === eventCode);
-  if (result) {
-    return Boolean(result.success);
-  } else {
-    return false;
-  }
-}
-
-export async function getScanMappedOutput(): Promise<SHARED_PREF_SCAN_OUTPUT_INTERFACE> {
-  let storage = Storage.getInstance();
-  const mergedScanOutput = await storage.getSharedItem(
-    SHARED_PREFERENCE_SCAN_OUTPUT
-  );
-  if (mergedScanOutput) {
-    return JSON.parse(mergedScanOutput);
-  } else {
-    return {};
-  }
-}
-
-export function triggerScanEvent(
-  type: eventType,
-  route: any,
-  scannedData: any,
-  etOutput?: BaseETResponse
-) {
-  switch (type) {
-    case 'ON_SCAN': {
-      const nextStates = route.params[RouteParams.NEXT_STATES];
-      const eventOutputData: onScanEvent = {
-        meta: etOutput?.meta || {},
-        etData: {
-          eventCode: etOutput?.eventCode || '',
-          reasonCode: etOutput?.reasonCode || '',
-          success: etOutput?.success || false,
-          endTime: Date.now(),
-          scannedData,
-        },
-        taskId: nextStates.taskId,
-        timestamp: Date.now(),
-        customData: route.params[RouteParams.ROOT_META_DATA].customEventsData,
-      };
-      dispatchEvent('ON_SCAN', nextStates.taskName, eventOutputData);
-      break;
-    }
-    case 'ON_SCAN_REMOVE': {
-      const nextStates = route.params[RouteParams.NEXT_STATES];
-      const eventOutputData: onScanRemoveEvent = {
-        etData: {
-          scannedData,
-        },
-        taskId: nextStates.taskId,
-        timestamp: Date.now(),
-        customData: route.params[RouteParams.ROOT_META_DATA].customEventsData,
-      };
-      dispatchEvent('ON_SCAN_REMOVE', nextStates.taskName, eventOutputData);
-      break;
-    }
-    default:
-      break;
-  }
-}
-
-const fetchMergedObjectiveIdBasedOnStatus = async (
-  activeTab: SummaryPageTabs,
-  scanProps: ScannerInput
-) => {
-  let prefixedMergedObjectiveId =
-    scanProps.route.params[RouteParams.ROOT_META_DATA]
-      .prefixedMergedObjectiveId;
-
-  let mergedObjectiveIds: SCANNED_RECORD;
-  let filterIds = await getScanMergedObjectID();
-  if (filterIds) {
-    mergedObjectiveIds = filterIds[prefixedMergedObjectiveId] || [];
-  } else {
-    return [];
-  }
-
-  switch (activeTab) {
-    case SummaryPageTabs.ALL:
-      return [
-        ...mergedObjectiveIds['pending'],
-        ...mergedObjectiveIds['success'],
-        ...mergedObjectiveIds['failure'],
-      ];
-    case SummaryPageTabs.PENDING:
-      return mergedObjectiveIds['pending'];
-    case SummaryPageTabs.DELIVERED:
-      return mergedObjectiveIds['success'];
-    case SummaryPageTabs.UNDELIVERED:
-      return mergedObjectiveIds['failure'];
-    default:
-      return [];
-  }
-};
-
-const fetchLabel = async (eventCode: string, reasonCode?: string) => {
-  return await getDefaultERCLabel({
-    eventCode,
-    reasonCode,
-  });
-};
-
-const modifyDisplayScanData = async (
-  response: IDispatch.IQueryWFIResponse
-): Promise<SummaryDisplayData> => {
-  const { data: scans } = response;
-  const updatedScanData = await Promise.all(
-    scans.map(async (scan) => {
-      const { eventCode, reasonCode } = await fetchLabel(
-        scan.eventCode,
-        scan.reasonCode
-      );
-
-      return {
-        scanId: scan.scannableId,
-        clientName: scan.displayInfo?.clientName || '--',
-        orderId: scan.displayInfo?.orderId || '--',
-        eventCode: eventCode || '--',
-        reasonCode: reasonCode || '--',
-        prefixedMergedObjectiveId: scan.originalMergedObjId,
-        lastStatus: scan.lastStatus,
-      };
-    })
-  );
-
-  return { data: updatedScanData, totalCount: response.totalCount };
-};
-
-export async function getScanData(
-  activeTab: SummaryPageTabs,
-  scanProps: ScannerInput,
-  limit: number,
-  offset: number,
-  scan?: string
-): Promise<SummaryDisplayData> {
-  const taskName = scanProps.taskName || '';
-  const mergedObjectiveId: Array<string> = scanProps.mergedObjectiveId;
-
-  const mergedObjectiveIds = await fetchMergedObjectiveIdBasedOnStatus(
-    activeTab,
-    scanProps
-  );
-
-  if (!mergedObjectiveIds || mergedObjectiveIds.length === 0) {
-    return {
-      data: [],
-      totalCount: 0,
-    };
-  }
-  if (scan) {
-    const scans: IDispatch.IQueryWFIResponse =
-      await DispatchExecutor.filterWFIData(
-        taskName,
-        mergedObjectiveIds,
-        limit,
-        offset,
-        scan
-      );
-
-    return await modifyDisplayScanData(scans);
-  } else {
-    const scans: IDispatch.IQueryWFIResponse =
-      await DispatchExecutor.filterWFIData(
-        taskName,
-        mergedObjectiveIds,
-        limit,
-        offset
-      );
-
-    return await modifyDisplayScanData(scans);
-  }
-}
-
-export async function addScans(
-  scan: string,
-  scanProps: ScannerInput,
-  scanOutput: ScannerOutput,
-  ercItems: ercItem[],
-  eventCode: ercItem,
-  reasonCode?: ercItem
-): Promise<ADD_SCAN> {
-  const prefixedMergedObjectiveId =
-    scanProps.route.params[RouteParams.ROOT_META_DATA]
-      .prefixedMergedObjectiveId;
-
-  const isErcSelector = scanProps.ercSelector ? true : false;
-  if (isEmptyOrBlank(scan)) {
-    return { status: false, message: EMPTY_AWB, type: SnackBarType.FAILURE };
-  }
-
-  if (isErcSelector && (!eventCode || !eventCode.code)) {
-    return {
-      status: false,
-      type: SnackBarType.FAILURE,
-      message: ER_MISSING.replace('<shipment_id>', scan),
-    };
-  }
-
-  let isValidated = await checkForValidation(scan, scanProps.validation);
-
-  if (isValidated) {
-    // NEW CODE
-    try {
-      const eventType = getEventType(ercItems || [], eventCode?.code || '');
-
-      const result = await DispatchExecutor.updateWIMapping(
-        prefixedMergedObjectiveId,
-        scan,
-        {
-          ec: eventCode?.code || '',
-          rc: reasonCode?.code || '',
-        },
-        scanProps.scanToMerge || false
-      );
-      if ('data' in result) {
-        const data: IDispatch.MappingUpdateResponse = result.data;
-        const {
-          message: { title, subTitle },
-        } = data;
-
-        // UPDATE SHARED PREFERENCE
-        updateSharedPreference(eventType, data.mwId, prefixedMergedObjectiveId);
-
-        const _scanOutput = await getUpdatedScanETOutput(
-          scanOutput,
-          result,
-          eventType,
-          eventCode?.code || '',
-          reasonCode?.code || '',
-          scanProps.route,
-          {
-            jobId: data.jobId,
-            displayInfo: data.displayInfo,
-            isScan: true,
-            scanId: scan,
-          }
-        );
-
-        return {
-          status: true,
-          type: subTitle ? SnackBarType.WARNING : SnackBarType.SUCCESS,
-          message: subTitle
-            ? `#${scan}\n${title}\n${subTitle}`
-            : `#${scan}\nShipment updated successfully!`,
-          data: {
-            output: _scanOutput,
-            shipmentCount: {
-              scannedCount: data.scanned,
-              totalCount: data.total,
-            },
-          },
-        };
-      } else {
-        return {
-          status: false,
-          type: SnackBarType.FAILURE,
-          message: 'Error occurred while scanning',
-        };
-      }
-    } catch (error: any) {
-      if (scanProps.exitOnError) {
-        return {
-          status: false,
-          type: SnackBarType.FAILURE,
-          exit: true,
-          message: 'Error occurred while scanning',
-        };
-
-        // props.onSubmitET({
-        //   ...(await getScanETOutput(
-        //     mergedScanETOutput,
-        //     props.mergedObjectiveId,
-        //     eventCodeItems || [],
-        //     props.defaultERC,
-        //     false,
-        //     true
-        //   )),
-        // });
-      } else {
-        return {
-          status: false,
-          ...getErrorMessage(scan, error),
-        };
-      }
-    }
-  } else {
-    if (scanProps.exitOnError) {
-      return {
-        status: false,
-        type: SnackBarType.FAILURE,
-        exit: true,
-        message: 'Error occurred while scanning',
-      };
-    } else {
-      return {
-        status: false,
-        message: INVALID_SHIPMENT,
-        type: SnackBarType.FAILURE,
-      };
-    }
-  }
-}
-
-export async function removeScan(
-  taskName: string,
-  scans: Array<string>,
-  route: any,
-  scanOutput: ScannerOutput
-) {
-  const prefixedMergedObjectiveId =
-    route.params[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
-
-  const result = await DispatchExecutor.removeShipment(
-    prefixedMergedObjectiveId,
-    scans
-  );
-
-  // Decrease count on remove
-  Object.keys(result).forEach((mergedObjectiveId) => {
-    scanOutput[mergedObjectiveId].count -= result[mergedObjectiveId];
-
-    if (scanOutput[mergedObjectiveId].count === 0) {
-      delete scanOutput[mergedObjectiveId];
-    }
-  });
-
-  const allScansOutput = (await getScanMergedOutput()) || {};
-
-  // SAVE IN SHARED PREFERENCE
-  let storage = Storage.getInstance();
-
-  const mergedIdOutput = await getScanMergedObjectID();
-  if (mergedIdOutput) {
-    const _mergedIds: SCANNED_RECORD =
-      mergedIdOutput[prefixedMergedObjectiveId];
-    _mergedIds.pending.push(prefixedMergedObjectiveId);
-
-    await storage.setSharedItem(
-      SCAN_MERGED_OBJ_ID_OUTPUT,
-      JSON.stringify({
-        ...mergedIdOutput,
-        [prefixedMergedObjectiveId]: _mergedIds,
-      })
-    );
-  }
-
-  let outputAtPrefixedId = allScansOutput[prefixedMergedObjectiveId] || {};
-
-  await storage.setSharedItem(
-    SHARED_PREFERENCE_SCAN_OUTPUT,
-    JSON.stringify({
-      ...allScansOutput,
-      [prefixedMergedObjectiveId]: { ...outputAtPrefixedId, scanOutput },
-    })
-  );
-
-  // TRIGGER REMOVE SCAN EVENT
-  const scannedData = scans.map((scan) => ({ scanValue: scan }));
-  triggerScanEvent('ON_SCAN_REMOVE', route, scannedData);
-}
-
-export async function updateSharedPreference(
-  eventType: boolean,
-  mergedObjectiveId: string,
-  prefixedMergedObjectiveId: string
-) {
-  let storage = Storage.getInstance();
-  const mergedIdOutput = await getScanMergedObjectID();
-
-  if (mergedIdOutput) {
-    const _mergedIds: SCANNED_RECORD =
-      mergedIdOutput[prefixedMergedObjectiveId];
-    if (eventType) {
-      _mergedIds.success.push(mergedObjectiveId);
-    } else {
-      _mergedIds.failure.push(mergedObjectiveId);
-    }
-
-    await storage.setSharedItem(
-      SCAN_MERGED_OBJ_ID_OUTPUT,
-      JSON.stringify({
-        ...mergedIdOutput,
-        [prefixedMergedObjectiveId]: _mergedIds,
-      })
-    );
-  }
-}
-
-export async function updatePendingSharedPreference(
-  eventType: boolean,
-  prefixedMergedObjectiveId: string
-) {
-  let storage = Storage.getInstance();
-  const mergedIdOutput = await getScanMergedObjectID();
-
-  if (mergedIdOutput) {
-    const _mergedIds = mergedIdOutput[prefixedMergedObjectiveId];
-    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({
-          ...mergedIdOutput,
-          [prefixedMergedObjectiveId]: _mergedIds,
-        })
-      );
-    }
-  }
-}
-
-export const getTabCount = async (
-  scanProps: ScannerInput
-): Promise<TabRecord> => {
-  let prefixedMergedObjectiveId =
-    scanProps.route.params[RouteParams.ROOT_META_DATA]
-      .prefixedMergedObjectiveId;
-  const mergedIdOutput = await getScanMergedObjectID();
-  const defaultResult = {
-    [SummaryPageTabs.ALL]: 0,
-    [SummaryPageTabs.PENDING]: 0,
-    [SummaryPageTabs.DELIVERED]: 0,
-    [SummaryPageTabs.UNDELIVERED]: 0,
-  };
-  const input: any = {};
-  if (mergedIdOutput) {
-    const _mergedIds = mergedIdOutput[prefixedMergedObjectiveId];
-    if (_mergedIds) {
-      const success = _mergedIds.success;
-      const failure = _mergedIds.failure;
-      const pending = _mergedIds.pending;
-      input[SummaryPageTabs.ALL] = [...success, ...failure, ...pending];
-      if (pending.length > 0) input[SummaryPageTabs.PENDING] = pending;
-      if (success.length > 0) input[SummaryPageTabs.DELIVERED] = success;
-      if (failure.length > 0) input[SummaryPageTabs.UNDELIVERED] = failure;
-
-      const result = await DispatchExecutor.getWFICountByMWIIds(input);
-
-      return { ...defaultResult, ...result };
-    } else {
-      return defaultResult;
-    }
-  } else {
-    return defaultResult;
-  }
-};
-
-export const clearScanOutput = async (prefixedMergedObjectiveId: string) => {
-  let storage = Storage.getInstance();
-
-  const promises: any = [];
-
-  // Clear Scan Record
-  const scanRecord = (await getScanMergedObjectID()) || {};
-  if (scanRecord) {
-    delete scanRecord[prefixedMergedObjectiveId];
-
-    promises.push(
-      storage.setSharedItem(
-        SCAN_MERGED_OBJ_ID_OUTPUT,
-        JSON.stringify(scanRecord)
-      )
-    );
-  }
-
-  // Clear Scan Output
-  const scanOutputs = (await getScanMappedOutput()) || {};
-  if (scanOutputs) {
-    delete scanOutputs[prefixedMergedObjectiveId];
-
-    promises.push(
-      storage.setSharedItem(
-        SHARED_PREFERENCE_SCAN_OUTPUT,
-        JSON.stringify(scanOutputs)
-      )
-    );
-  }
-  return Promise.all(promises);
-};
-
-export async function getScanMergedObjectID(): Promise<SCAN_MERGED_OBJ_ID_INTEFACE | null> {
-  let storage = Storage.getInstance();
-  const mergedIdOutput = await storage.getSharedItem(SCAN_MERGED_OBJ_ID_OUTPUT);
-  if (mergedIdOutput) {
-    return JSON.parse(mergedIdOutput);
-  } else {
-    return null;
-  }
-}
-
-export async function getScanMergedOutput(): Promise<ScannerOutput | null> {
-  let storage = Storage.getInstance();
-  const mergedIdOutput = await storage.getSharedItem(
-    SHARED_PREFERENCE_SCAN_OUTPUT
-  );
-  if (mergedIdOutput) {
-    return JSON.parse(mergedIdOutput);
-  } else {
-    return null;
-  }
-}
-
-export const getErrorMessage = (
-  scan: string,
-  error: {
-    errorCode: number;
-    message: string;
-  }
-): { type: SnackBarType; message: string } => {
-  switch (error.errorCode) {
-    case WIErrorCodes.ScannableIdAlreadyCompleted:
-      return {
-        type: SnackBarType.FAILURE,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ScannableIdAlreadyCompleted]
-          }`,
-      };
-    case WIErrorCodes.ScannableIdNotInDispatch:
-      return {
-        type: SnackBarType.FAILURE,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ScannableIdNotInDispatch]
-          }`,
-      };
-    case WIErrorCodes.ScannableIdNotReady:
-      return {
-        type: SnackBarType.FAILURE,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ScannableIdNotReady]
-          }`,
-      };
-    case WIErrorCodes.DifferentGroupUpdateNotAllowed:
-      return {
-        type: SnackBarType.FAILURE,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.DifferentGroupUpdateNotAllowed]
-          }`,
-      };
-    case WIErrorCodes.ObjectiveAndJobWFMismatch:
-      return {
-        type: SnackBarType.FAILURE,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ObjectiveAndJobWFMismatch]
-          }`,
-      };
-    case WIErrorCodes.ScannableIdAlreadyUpdated:
-      return {
-        type: SnackBarType.WARNING,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ScannableIdAlreadyUpdated]
-          }`,
-      };
-    case WIErrorCodes.JobAlreadyCompleted:
-      return {
-        type: SnackBarType.WARNING,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.JobAlreadyCompleted]
-          }`,
-      };
-    case WIErrorCodes.ScannableIdPartOfAnotherMO:
-      return {
-        type: SnackBarType.WARNING,
-        message: `#${scan}\n${ErrorCodeMessages[WIErrorCodes.ScannableIdPartOfAnotherMO]
-          }`,
-      };
-    default:
-      return {
-        type: SnackBarType.FAILURE,
-        message: 'Error occurred while scanning',
-      };
-  }
-};
-
-export const getSplitIds = (scanOutput: ScannerOutput): string[] => {
-  const splitMergedObjectiveIds = Object.keys(scanOutput)
-    .filter((mergedObjectiveID: string) => {
-      const scan = scanOutput[mergedObjectiveID];
-      if (scan.count > 0) return true;
-      return false;
-    })
-    .map((mergedObjectiveIds) => mergedObjectiveIds);
-
-  return splitMergedObjectiveIds;
-};
-
-export function filterERCItems(
-  eventCodeItems: ercItem[],
-  type: 'SUCCESS' | 'FAILURE'
-): ercItem[] {
-  return eventCodeItems.filter(
-    (erc) => Boolean(erc.success) === (type === 'SUCCESS' ? true : false)
-  );
-}
-
-export async function resetObjective(scanProps: ScannerInput) {
-  const taskName = scanProps.taskName || '';
-  const deliveredMergedObjectiveIds = await fetchMergedObjectiveIdBasedOnStatus(
-    SummaryPageTabs.DELIVERED,
-    scanProps
-  );
-  const undeliveredMergedObjectiveIds =
-    await fetchMergedObjectiveIdBasedOnStatus(
-      SummaryPageTabs.UNDELIVERED,
-      scanProps
-    );
-
-  if (
-    (!deliveredMergedObjectiveIds ||
-      deliveredMergedObjectiveIds.length === 0) &&
-    (!undeliveredMergedObjectiveIds ||
-      undeliveredMergedObjectiveIds.length === 0)
-  ) {
-    return;
-  }
-
-  const scannedData: any[] = [];
-
-  if (deliveredMergedObjectiveIds && deliveredMergedObjectiveIds.length) {
-    let hasNextPage = true;
-    let offset = 0;
-    const limit = BULK_DATA_LIMIT;
-    let scans: IDispatch.IQueryWFIResponse = { data: [], totalCount: 0 };
-
-    do {
-      scans = await DispatchExecutor.filterWFIData(
-        taskName,
-        deliveredMergedObjectiveIds,
-        limit,
-        offset
-      );
-      scans.data.forEach((scan) => {
-        scannedData.push({
-          scanValue: scan.scannableId,
-        });
-      });
-
-      offset += limit;
-      hasNextPage = scans.totalCount - offset + 1 > 0;
-    } while (hasNextPage);
-  }
-  if (undeliveredMergedObjectiveIds && undeliveredMergedObjectiveIds.length) {
-    let hasNextPage = true;
-    let offset = 0;
-    const limit = BULK_DATA_LIMIT;
-    let scans: IDispatch.IQueryWFIResponse = { data: [], totalCount: 0 };
-
-    do {
-      scans = await DispatchExecutor.filterWFIData(
-        taskName,
-        undeliveredMergedObjectiveIds,
-        limit,
-        offset
-      );
-      scans.data.forEach((scan) => {
-        scannedData.push({
-          scanValue: scan.scannableId,
-        });
-      });
-
-      offset += limit;
-      hasNextPage = scans.totalCount - offset + 1 > 0;
-    } while (hasNextPage);
-  }
-  triggerScanEvent('ON_SCAN_REMOVE', scanProps.route, scannedData);
-  return;
-}