@os1-platform/dispatch-mobile 1.0.8 → 2.0.0

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

@@ -0,0 +1,762 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addScans = addScans;
+exports.checkForValidation = checkForValidation;
+exports.clearScanOutput = void 0;
+exports.filterERCItems = filterERCItems;
+exports.getBarCodeTypes = getBarCodeTypes;
+exports.getErrorMessage = void 0;
+exports.getEventType = getEventType;
+exports.getMappingCount = getMappingCount;
+exports.getScanData = getScanData;
+exports.getScanETOutput = getScanETOutput;
+exports.getScanMappedOutput = getScanMappedOutput;
+exports.getScanMergedObjectID = getScanMergedObjectID;
+exports.getScanMergedOutput = getScanMergedOutput;
+exports.getScannedItemCount = getScannedItemCount;
+exports.getScannedItems = getScannedItems;
+exports.getShipmentData = getShipmentData;
+exports.getTabCount = exports.getSplitIds = void 0;
+exports.getUpdatedScanETOutput = getUpdatedScanETOutput;
+exports.isETCompleted = isETCompleted;
+exports.isReplacement = isReplacement;
+exports.removeScan = removeScan;
+exports.triggerScanEvent = triggerScanEvent;
+exports.updatePendingSharedPreference = updatePendingSharedPreference;
+exports.updateSharedPreference = updateSharedPreference;
+var _expoBarcodeScanner = require("expo-barcode-scanner");
+var _interfaces = require("./interfaces");
+var _ScanSchema = require("./ScanSchema");
+var jsonLogic = _interopRequireWildcard(require("json-logic-js"));
+var _ExecTaskUtils = require("../../../utils/ExecTaskUtils");
+var _ETConfig = require("../../../models/execTasks/ETConfig");
+var _ApiUtils = require("../../../utils/ApiUtils");
+var _Logger = _interopRequireWildcard(require("../../../utils/Logger"));
+var _constants = require("../../../constants/constants");
+var _storage = _interopRequireDefault(require("../../../utils/storage"));
+var _constants2 = require("../../../manager/syncmanager/constants");
+var _RouteParams = require("../../../ui/uiConfig/RouteParams");
+var _EventDispatcher = _interopRequireDefault(require("../../../events/EventDispatcher"));
+var _platformCoreosExecutionEngineSdk = require("@os1-platform/platform-coreos-execution-engine-sdk");
+var _utils = require("../../../utils/utils");
+var _constants3 = require("./constants");
+var _DropDownUtils = require("./sub_components/DropDownUtils");
+var _SnackBarCustom = require("../../../components/widgets/SnackBarCustom");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function getBarCodeTypes(input) {
+  const barCodeType = [];
+  const {
+    scannedInput: {
+      scanType
+    }
+  } = input;
+  scanType.forEach(type => {
+    switch (type) {
+      case _interfaces.ExpoBarcodeTypes.QRCODE:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.qr);
+        break;
+      case _interfaces.ExpoBarcodeTypes.aztec:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.aztec);
+        break;
+      case _interfaces.ExpoBarcodeTypes.codabar:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.codabar);
+        break;
+      case _interfaces.ExpoBarcodeTypes.code128:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.code128);
+        break;
+      case _interfaces.ExpoBarcodeTypes.code39:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.code39);
+        break;
+      case _interfaces.ExpoBarcodeTypes.code93:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.code93);
+        break;
+      case _interfaces.ExpoBarcodeTypes.datamatrix:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.datamatrix);
+        break;
+      case _interfaces.ExpoBarcodeTypes.ean13:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.ean13);
+        break;
+      case _interfaces.ExpoBarcodeTypes.ean8:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.ean8);
+        break;
+      case _interfaces.ExpoBarcodeTypes.itf14:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.itf14);
+        break;
+      case _interfaces.ExpoBarcodeTypes.pdf417:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.pdf417);
+        break;
+      case _interfaces.ExpoBarcodeTypes.upc_e:
+        barCodeType.push(_expoBarcodeScanner.BarCodeScanner.Constants.BarCodeType.upc_e);
+        break;
+      default:
+        break;
+    }
+  });
+  return barCodeType;
+}
+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 = (0, _ApiUtils.parseBody)(api.requestBody, scannedInput);
+        apiData.requestBody = parsedRequestBody;
+      }
+      if (api.pathParams) {
+        (0, _ApiUtils.parseKeyValue)(api.pathParams, scannedInput);
+        apiData.pathParams = api.pathParams;
+      }
+      if (api.queryParams) {
+        (0, _ApiUtils.parseKeyValue)(api.queryParams, scannedInput);
+        apiData.queryParams = api.queryParams;
+      }
+      const apiResponse = await (0, _ApiUtils.getApiResponse)(apiData);
+      return jsonLogic.apply(api.responseJsonLogic, apiResponse.data);
+    } catch (error) {
+      _Logger.default.getInstance().logEvent('~ checkForValidation', error.message, _Logger.LOG_TYPE.SDK_ERROR);
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+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) === _interfaces.SCAN_STATUS.SCANNED) {
+        scannedShipments.push(key);
+      } else if ((value === null || value === void 0 ? void 0 : value.scanStatus) === _interfaces.SCAN_STATUS.FAILED) {
+        pendingShipments.push(key);
+      }
+    } else if (selectedIndex === 0) {
+      pendingShipments.push(key);
+    }
+  }
+  return [pendingShipments, scannedShipments];
+}
+function getScannedItemCount(scansMap) {
+  let scannedShipments = 0;
+  if (scansMap) {
+    for (let [, value] of scansMap.entries()) {
+      if (value.scanStatus === _interfaces.SCAN_STATUS.SCANNED) {
+        scannedShipments++;
+      }
+    }
+    return scannedShipments;
+  }
+  return scannedShipments;
+}
+function getMappingCount(scanOutput, wiMappingUpdate) {
+  const {
+    mwId: mergedObjectiveId
+  } = wiMappingUpdate.data;
+  if (scanOutput[mergedObjectiveId]) {
+    return scanOutput[mergedObjectiveId].count + 1;
+  } else {
+    return 1;
+  }
+}
+async function getUpdatedScanETOutput(scanOutput, wiMappingUpdate, success, eventCode, reasonCode, route, scannedData) {
+  const prefixedMergedObjectiveId = route.params[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  const {
+    mwId: mergedObjectiveId,
+    previousMWID: previousMergedObjectiveId
+  } = wiMappingUpdate.data;
+  const output = await (0, _ExecTaskUtils.getBaseETResponse)(_ETConfig.EntityCode.SCAN, success, eventCode, reasonCode, [mergedObjectiveId], _ETConfig.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.default.getInstance();
+  await storage.setSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify({
+    ...allScansOutput,
+    [prefixedMergedObjectiveId]: scanOutput
+  }));
+  return scanOutput;
+}
+async function getScanETOutput(mergeScannedOutput, mergedObjectiveId, ercItems, defaultERC, deliverState, isPartial, count) {
+  switch (deliverState) {
+    case _ScanSchema.DeliverState.CANCELLED:
+      {
+        const output = await (0, _ExecTaskUtils.getBaseETResponse)(_ETConfig.EntityCode.SCAN, false, defaultERC.eventCode, defaultERC.reasonCode || '', mergedObjectiveId, _ETConfig.ExecutionTaskID.SCAN);
+        return {
+          [mergedObjectiveId[0]]: {
+            output,
+            count
+          }
+        };
+      }
+    case _ScanSchema.DeliverState.DELIVERE_LATER:
+      {
+        const output = await (0, _ExecTaskUtils.getBaseETResponse)(_ETConfig.EntityCode.SCAN, false, _constants.REASON_NOT_USED, '', mergedObjectiveId, _ETConfig.ExecutionTaskID.SCAN);
+        mergeScannedOutput['default'] = {
+          output,
+          count
+        };
+        return mergeScannedOutput;
+      }
+    case _ScanSchema.DeliverState.DELIVER_NOW:
+      {
+        if (isPartial) {
+          const output = await (0, _ExecTaskUtils.getBaseETResponse)(_ETConfig.EntityCode.SCAN, getEventType(ercItems, defaultERC.eventCode), defaultERC.eventCode, defaultERC.reasonCode || '', mergedObjectiveId, _ETConfig.ExecutionTaskID.SCAN);
+          mergeScannedOutput['default'] = {
+            output,
+            count
+          };
+          return mergeScannedOutput;
+        } else {
+          return mergeScannedOutput;
+        }
+      }
+    default:
+      {
+        return mergeScannedOutput;
+      }
+  }
+}
+function getScannedItems(scanValue) {
+  const items = [];
+  if (scanValue.scanStatus === _interfaces.SCAN_STATUS.SCANNED) items.push({
+    value: scanValue.value,
+    validated: scanValue.validated || false,
+    timestamp: scanValue.timestamp || Date.now()
+  });
+  return items;
+}
+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;
+    }
+  }
+}
+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;
+}
+function getEventType(eventList, eventCode) {
+  const result = eventList.find(code => code.code === eventCode);
+  if (result) {
+    return Boolean(result.success);
+  } else {
+    return false;
+  }
+}
+async function getScanMappedOutput() {
+  let storage = _storage.default.getInstance();
+  const mergedScanOutput = await storage.getSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT);
+  if (mergedScanOutput) {
+    return JSON.parse(mergedScanOutput);
+  } else {
+    return {};
+  }
+}
+function triggerScanEvent(type, route, scannedData, etOutput) {
+  switch (type) {
+    case 'ON_SCAN':
+      {
+        const nextStates = route.params[_RouteParams.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.RouteParams.ROOT_META_DATA].customEventsData
+        };
+        (0, _EventDispatcher.default)('ON_SCAN', nextStates.taskName, eventOutputData);
+        break;
+      }
+    case 'ON_SCAN_REMOVE':
+      {
+        const nextStates = route.params[_RouteParams.RouteParams.NEXT_STATES];
+        const eventOutputData = {
+          etData: {
+            scannedData
+          },
+          taskId: nextStates.taskId,
+          timestamp: Date.now(),
+          customData: route.params[_RouteParams.RouteParams.ROOT_META_DATA].customEventsData
+        };
+        (0, _EventDispatcher.default)('ON_SCAN_REMOVE', nextStates.taskName, eventOutputData);
+        break;
+      }
+    default:
+      break;
+  }
+}
+const fetchMergedObjectiveIdBasedOnStatus = async (activeTab, scanProps) => {
+  let prefixedMergedObjectiveId = scanProps.route.params[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  let mergedObjectiveIds;
+  let filterIds = await getScanMergedObjectID();
+  if (filterIds) {
+    mergedObjectiveIds = filterIds[prefixedMergedObjectiveId] || [];
+  } else {
+    return [];
+  }
+  switch (activeTab) {
+    case _interfaces.SummaryPageTabs.ALL:
+      return [...mergedObjectiveIds['pending'], ...mergedObjectiveIds['success'], ...mergedObjectiveIds['failure']];
+    case _interfaces.SummaryPageTabs.PENDING:
+      return mergedObjectiveIds['pending'];
+    case _interfaces.SummaryPageTabs.DELIVERED:
+      return mergedObjectiveIds['success'];
+    case _interfaces.SummaryPageTabs.UNDELIVERED:
+      return mergedObjectiveIds['failure'];
+    default:
+      return [];
+  }
+};
+const fetchLabel = async (eventCode, reasonCode) => {
+  return await (0, _DropDownUtils.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
+  };
+};
+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 _platformCoreosExecutionEngineSdk.DispatchExecutor.filterWFIData(taskName, mergedObjectiveIds, limit, offset, scan);
+    return await modifyDisplayScanData(scans);
+  } else {
+    const scans = await _platformCoreosExecutionEngineSdk.DispatchExecutor.filterWFIData(taskName, mergedObjectiveIds, limit, offset);
+    return await modifyDisplayScanData(scans);
+  }
+}
+async function addScans(scan, scanProps, scanOutput, ercItems, eventCode, reasonCode) {
+  const prefixedMergedObjectiveId = scanProps.route.params[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  const isErcSelector = scanProps.ercSelector ? true : false;
+  if ((0, _utils.isEmptyOrBlank)(scan)) {
+    return {
+      status: false,
+      message: _constants3.EMPTY_AWB,
+      type: _SnackBarCustom.SnackBarType.FAILURE
+    };
+  }
+  if (isErcSelector && (!eventCode || !eventCode.code)) {
+    return {
+      status: false,
+      type: _SnackBarCustom.SnackBarType.FAILURE,
+      message: _constants3.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 _platformCoreosExecutionEngineSdk.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 ? _SnackBarCustom.SnackBarType.WARNING : _SnackBarCustom.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: _SnackBarCustom.SnackBarType.FAILURE,
+          message: 'Error occurred while scanning'
+        };
+      }
+    } catch (error) {
+      if (scanProps.exitOnError) {
+        return {
+          status: false,
+          type: _SnackBarCustom.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: _SnackBarCustom.SnackBarType.FAILURE,
+        exit: true,
+        message: 'Error occurred while scanning'
+      };
+    } else {
+      return {
+        status: false,
+        message: _constants3.INVALID_SHIPMENT,
+        type: _SnackBarCustom.SnackBarType.FAILURE
+      };
+    }
+  }
+}
+async function removeScan(taskName, scans, route, scanOutput) {
+  const prefixedMergedObjectiveId = route.params[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  const result = await _platformCoreosExecutionEngineSdk.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.default.getInstance();
+  const mergedIdOutput = await getScanMergedObjectID();
+  if (mergedIdOutput) {
+    const _mergedIds = mergedIdOutput[prefixedMergedObjectiveId];
+    _mergedIds.pending.push(prefixedMergedObjectiveId);
+    await storage.setSharedItem(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify({
+      ...mergedIdOutput,
+      [prefixedMergedObjectiveId]: _mergedIds
+    }));
+  }
+  let outputAtPrefixedId = allScansOutput[prefixedMergedObjectiveId] || {};
+  await storage.setSharedItem(_constants2.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);
+}
+async function updateSharedPreference(eventType, mergedObjectiveId, prefixedMergedObjectiveId) {
+  let storage = _storage.default.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(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify({
+      ...mergedIdOutput,
+      [prefixedMergedObjectiveId]: _mergedIds
+    }));
+  }
+}
+async function updatePendingSharedPreference(eventType, prefixedMergedObjectiveId) {
+  let storage = _storage.default.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(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify({
+        ...mergedIdOutput,
+        [prefixedMergedObjectiveId]: _mergedIds
+      }));
+    }
+  }
+}
+const getTabCount = async scanProps => {
+  let prefixedMergedObjectiveId = scanProps.route.params[_RouteParams.RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+  const mergedIdOutput = await getScanMergedObjectID();
+  const defaultResult = {
+    [_interfaces.SummaryPageTabs.ALL]: 0,
+    [_interfaces.SummaryPageTabs.PENDING]: 0,
+    [_interfaces.SummaryPageTabs.DELIVERED]: 0,
+    [_interfaces.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[_interfaces.SummaryPageTabs.ALL] = [...success, ...failure, ...pending];
+      if (pending.length > 0) input[_interfaces.SummaryPageTabs.PENDING] = pending;
+      if (success.length > 0) input[_interfaces.SummaryPageTabs.DELIVERED] = success;
+      if (failure.length > 0) input[_interfaces.SummaryPageTabs.UNDELIVERED] = failure;
+      const result = await _platformCoreosExecutionEngineSdk.DispatchExecutor.getWFICountByMWIIds(input);
+      return {
+        ...defaultResult,
+        ...result
+      };
+    } else {
+      return defaultResult;
+    }
+  } else {
+    return defaultResult;
+  }
+};
+exports.getTabCount = getTabCount;
+const clearScanOutput = async prefixedMergedObjectiveId => {
+  let storage = _storage.default.getInstance();
+  const promises = [];
+
+  // Clear Scan Record
+  const scanRecord = (await getScanMergedObjectID()) || {};
+  if (scanRecord) {
+    delete scanRecord[prefixedMergedObjectiveId];
+    promises.push(storage.setSharedItem(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT, JSON.stringify(scanRecord)));
+  }
+
+  // Clear Scan Output
+  const scanOutputs = (await getScanMappedOutput()) || {};
+  if (scanOutputs) {
+    delete scanOutputs[prefixedMergedObjectiveId];
+    promises.push(storage.setSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT, JSON.stringify(scanOutputs)));
+  }
+  return Promise.all(promises);
+};
+exports.clearScanOutput = clearScanOutput;
+async function getScanMergedObjectID() {
+  let storage = _storage.default.getInstance();
+  const mergedIdOutput = await storage.getSharedItem(_constants2.SCAN_MERGED_OBJ_ID_OUTPUT);
+  if (mergedIdOutput) {
+    return JSON.parse(mergedIdOutput);
+  } else {
+    return null;
+  }
+}
+async function getScanMergedOutput() {
+  let storage = _storage.default.getInstance();
+  const mergedIdOutput = await storage.getSharedItem(_constants2.SHARED_PREFERENCE_SCAN_OUTPUT);
+  if (mergedIdOutput) {
+    return JSON.parse(mergedIdOutput);
+  } else {
+    return null;
+  }
+}
+const getErrorMessage = (scan, error) => {
+  switch (error.errorCode) {
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdAlreadyCompleted:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdAlreadyCompleted]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdNotInDispatch:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdNotInDispatch]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdNotReady:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdNotReady]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.DifferentGroupUpdateNotAllowed:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.DifferentGroupUpdateNotAllowed]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ObjectiveAndJobWFMismatch:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ObjectiveAndJobWFMismatch]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdAlreadyUpdated:
+      return {
+        type: _SnackBarCustom.SnackBarType.WARNING,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdAlreadyUpdated]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.JobAlreadyCompleted:
+      return {
+        type: _SnackBarCustom.SnackBarType.WARNING,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.JobAlreadyCompleted]}`
+      };
+    case _platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdPartOfAnotherMO:
+      return {
+        type: _SnackBarCustom.SnackBarType.WARNING,
+        message: `#${scan}\n${_platformCoreosExecutionEngineSdk.ErrorCodeMessages[_platformCoreosExecutionEngineSdk.WIErrorCodes.ScannableIdPartOfAnotherMO]}`
+      };
+    default:
+      return {
+        type: _SnackBarCustom.SnackBarType.FAILURE,
+        message: 'Error occurred while scanning'
+      };
+  }
+};
+exports.getErrorMessage = getErrorMessage;
+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;
+};
+exports.getSplitIds = getSplitIds;
+function filterERCItems(eventCodeItems, type) {
+  return eventCodeItems.filter(erc => Boolean(erc.success) === (type === 'SUCCESS' ? true : false));
+}
+//# sourceMappingURL=utils.js.map