@os1-platform/dispatch-mobile 2.1.2 → 2.1.3

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

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