@os1-platform/dispatch-mobile 1.0.8 → 2.0.0

package/lib/module/components/executiontasks/scan/utils.js

@@ -0,0 +1,726 @@
+import { BarCodeScanner } from 'expo-barcode-scanner';
+import { ExpoBarcodeTypes, SCAN_STATUS, SummaryPageTabs } from './interfaces';
+import { DeliverState } from './ScanSchema';
+import * as jsonLogic from 'json-logic-js';
+import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
+import { EntityCode, ExecutionTaskID } from '../../../models/execTasks/ETConfig';
+import { 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 { 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, 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 { getDefaultERCLabel } from './sub_components/DropDownUtils';
+import { SnackBarType } from '../../../components/widgets/SnackBarCustom';
+export function getBarCodeTypes(input) {
+  const barCodeType = [];
+  const {
+    scannedInput: {
+      scanType
+    }
+  } = input;
+  scanType.forEach(type => {
+    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, validation) {
+  // 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 = validation.logic;
+      const 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(api.responseJsonLogic, apiResponse.data);
+    } catch (error) {
+      Logger.getInstance().logEvent('~ checkForValidation', error.message, LOG_TYPE.SDK_ERROR);
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+export function getShipmentData(selectedIndex, scansMap) {
+  const pendingShipments = [];
+  const scannedShipments = [];
+  //@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 === null || value === void 0 ? void 0 : value.scanStatus) != undefined) {
+      if ((value === null || value === void 0 ? void 0 : value.scanStatus) === SCAN_STATUS.SCANNED) {
+        scannedShipments.push(key);
+      } else if ((value === null || value === void 0 ? void 0 : value.scanStatus) === SCAN_STATUS.FAILED) {
+        pendingShipments.push(key);
+      }
+    } else if (selectedIndex === 0) {
+      pendingShipments.push(key);
+    }
+  }
+  return [pendingShipments, scannedShipments];
+}
+export function getScannedItemCount(scansMap) {
+  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, wiMappingUpdate) {
+  const {
+    mwId: mergedObjectiveId
+  } = wiMappingUpdate.data;
+  if (scanOutput[mergedObjectiveId]) {
+    return scanOutput[mergedObjectiveId].count + 1;
+  } else {
+    return 1;
+  }
+}
+export async function getUpdatedScanETOutput(scanOutput, wiMappingUpdate, success, eventCode, reasonCode, route, scannedData) {
+  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 = [{
+    groupId: scannedData.displayInfo.groupId,
+    jobId: scannedData.jobId,
+    shipmentFlow: scannedData.displayInfo.shipmentFlow,
+    scanValue: scannedData.scanId
+  }];
+  scannedData !== null && scannedData !== void 0 && 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, mergedObjectiveId, ercItems, defaultERC, deliverState, isPartial, count) {
+  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) {
+  const items = [];
+  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, scansMap, scanMode, isMultiObjectiveEnable, scannedShipmentCount, singleModeCount, allowMultiObjectivePartial) {
+  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 = 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, scansMap, selectedEventCode, selectedReason) {
+  var _scansMap$get, _scansMap$get2;
+  if (
+  //(selectedEventCode || selectedReason) &&
+  //scansMap.get(scan)?.eventCode &&
+  ((_scansMap$get = scansMap.get(scan)) === null || _scansMap$get === void 0 ? void 0 : _scansMap$get.eventCode) !== (selectedEventCode === null || selectedEventCode === void 0 ? void 0 : selectedEventCode.code) ||
+  //scansMap.get(scan)?.reasonCode !== undefined &&
+  ((_scansMap$get2 = scansMap.get(scan)) === null || _scansMap$get2 === void 0 ? void 0 : _scansMap$get2.reasonCode) !== (selectedReason === null || selectedReason === void 0 ? void 0 : selectedReason.code)) {
+    return true;
+  }
+  return false;
+}
+export function getEventType(eventList, eventCode) {
+  const result = eventList.find(code => code.code === eventCode);
+  if (result) {
+    return Boolean(result.success);
+  } else {
+    return false;
+  }
+}
+export async function getScanMappedOutput() {
+  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, route, scannedData, etOutput) {
+  switch (type) {
+    case 'ON_SCAN':
+      {
+        const nextStates = route.params[RouteParams.NEXT_STATES];
+        const eventOutputData = {
+          meta: (etOutput === null || etOutput === void 0 ? void 0 : etOutput.meta) || {},
+          etData: {
+            eventCode: (etOutput === null || etOutput === void 0 ? void 0 : etOutput.eventCode) || '',
+            reasonCode: (etOutput === null || etOutput === void 0 ? void 0 : etOutput.reasonCode) || '',
+            success: (etOutput === null || etOutput === void 0 ? void 0 : 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 = {
+          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, scanProps) => {
+  let prefixedMergedObjectiveId = scanProps.route.params[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  let mergedObjectiveIds;
+  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, reasonCode) => {
+  return await getDefaultERCLabel({
+    eventCode,
+    reasonCode
+  });
+};
+const modifyDisplayScanData = async response => {
+  const {
+    data: scans
+  } = response;
+  const updatedScanData = await Promise.all(scans.map(async scan => {
+    var _scan$displayInfo, _scan$displayInfo2;
+    const {
+      eventCode,
+      reasonCode
+    } = await fetchLabel(scan.eventCode, scan.reasonCode);
+    return {
+      scanId: scan.scannableId,
+      clientName: ((_scan$displayInfo = scan.displayInfo) === null || _scan$displayInfo === void 0 ? void 0 : _scan$displayInfo.clientName) || '--',
+      orderId: ((_scan$displayInfo2 = scan.displayInfo) === null || _scan$displayInfo2 === void 0 ? void 0 : _scan$displayInfo2.orderId) || '--',
+      eventCode: eventCode || '--',
+      reasonCode: reasonCode || '--',
+      prefixedMergedObjectiveId: scan.originalMergedObjId,
+      lastStatus: scan.lastStatus
+    };
+  }));
+  return {
+    data: updatedScanData,
+    totalCount: response.totalCount
+  };
+};
+export async function getScanData(activeTab, scanProps, limit, offset, scan) {
+  const taskName = scanProps.taskName || '';
+  const mergedObjectiveId = scanProps.mergedObjectiveId;
+  const mergedObjectiveIds = await fetchMergedObjectiveIdBasedOnStatus(activeTab, scanProps);
+  if (!mergedObjectiveIds || mergedObjectiveIds.length === 0) {
+    return {
+      data: [],
+      totalCount: 0
+    };
+  }
+  if (scan) {
+    const scans = await DispatchExecutor.filterWFIData(taskName, mergedObjectiveIds, limit, offset, scan);
+    return await modifyDisplayScanData(scans);
+  } else {
+    const scans = await DispatchExecutor.filterWFIData(taskName, mergedObjectiveIds, limit, offset);
+    return await modifyDisplayScanData(scans);
+  }
+}
+export async function addScans(scan, scanProps, scanOutput, ercItems, eventCode, reasonCode) {
+  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 === null || eventCode === void 0 ? void 0 : eventCode.code) || '');
+      const result = await DispatchExecutor.updateWIMapping(prefixedMergedObjectiveId, scan, {
+        ec: (eventCode === null || eventCode === void 0 ? void 0 : eventCode.code) || '',
+        rc: (reasonCode === null || reasonCode === void 0 ? void 0 : reasonCode.code) || ''
+      }, scanProps.scanToMerge || false);
+      if ('data' in result) {
+        const data = result.data;
+        const {
+          message: {
+            title,
+            subTitle
+          }
+        } = data;
+
+        // UPDATE SHARED PREFERENCE
+        updateSharedPreference(eventType, data.mwId, prefixedMergedObjectiveId);
+        const _scanOutput = await getUpdatedScanETOutput(scanOutput, result, eventType, (eventCode === null || eventCode === void 0 ? void 0 : eventCode.code) || '', (reasonCode === null || reasonCode === void 0 ? void 0 : 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) {
+      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, scans, route, scanOutput) {
+  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 = 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, mergedObjectiveId, prefixedMergedObjectiveId) {
+  let storage = Storage.getInstance();
+  const mergedIdOutput = await getScanMergedObjectID();
+  if (mergedIdOutput) {
+    const _mergedIds = 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, prefixedMergedObjectiveId) {
+  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 => {
+  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 = {};
+  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 => {
+  let storage = Storage.getInstance();
+  const promises = [];
+
+  // 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() {
+  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() {
+  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, error) => {
+  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 => {
+  const splitMergedObjectiveIds = Object.keys(scanOutput).filter(mergedObjectiveID => {
+    const scan = scanOutput[mergedObjectiveID];
+    if (scan.count > 0) return true;
+    return false;
+  }).map(mergedObjectiveIds => mergedObjectiveIds);
+  return splitMergedObjectiveIds;
+};
+export function filterERCItems(eventCodeItems, type) {
+  return eventCodeItems.filter(erc => Boolean(erc.success) === (type === 'SUCCESS' ? true : false));
+}
+//# sourceMappingURL=utils.js.map