@os1-platform/dispatch-mobile 1.3.11 → 2.0.1

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

@@ -1,11 +1,21 @@
 import { BarCodeScanner } from 'expo-barcode-scanner';
-import { ExpoBarcodeTypes, SCAN_STATUS } from './interfaces';
+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 { getEventCodeByET } from '../../../manager/dispatchCodes/EventCodeContainer';
 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 {
@@ -60,10 +70,7 @@ export function getBarCodeTypes(input) {
 export async function checkForValidation(scannedInput, validation) {
   // Scans Array
   if (validation.selectedIndex === 0) {
-    //@ts-ignore
-    const scans = validation.logic;
-    const found = scans.find(s => s === scannedInput);
-    return found !== undefined;
+    return true;
   }
   // Validation Regex
   else if (validation.selectedIndex === 1 && typeof validation.logic === 'string') {
@@ -140,169 +147,94 @@ export function getScannedItemCount(scansMap) {
   }
   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;
+  }
 
-/**
- * Mode: SINGLE -> each scanned output will be passed on, corresponding to each jobId, based on the blindData(containing jobIds)
- * Mode: MULTI -> for scans array: output will be based on the jobId present in scansMap
- *             -> for blind with maxScanCount: output will be set incrementaly, based on the maxScanCount of each ET of job
- *             -> for blind without maxScanCount: output will be set in the first objective
- */
-
-export async function getScanETOutput(scansMap, selectedValidationIndex, blindData, scanMode) {
-  let scanCountLimit = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-  let defaultERC = arguments.length > 5 ? arguments[5] : undefined;
-  let isMultiObjectiveEnable = arguments.length > 6 ? arguments[6] : undefined;
-  let applicableCodes = arguments.length > 7 ? arguments[7] : undefined;
-  let isErcSelector = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;
-  let isCancelled = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;
-  let scanOutput = {
-    etData: {},
-    pendingEtData: {}
-  };
-  if (scansMap.size) for (let [, _scannedValue] of scansMap.entries()) {
-    const _isScannedSuccess = _scannedValue !== null && _scannedValue !== void 0 && _scannedValue.success ? true : false;
-    const _appRC = _isScannedSuccess ? applicableCodes === null || applicableCodes === void 0 ? void 0 : applicableCodes.success : applicableCodes === null || applicableCodes === void 0 ? void 0 : applicableCodes.failure;
-    if (scanMode === 'SINGLE' || isMultiObjectiveEnable) {
-      for (let [_jobId, blindValue] of blindData.entries()) {
-        if (_scannedValue.jobId === _jobId) {
-          if (blindValue.scannedCount === 1) continue;else {
-            if (_scannedValue.scanStatus === SCAN_STATUS.SCANNED) {
-              if (!isCancelled && isMultiObjectiveEnable && isErcSelector && !_scannedValue.success) {
-                scanOutput.pendingEtData[_jobId] = {
-                  scans: [{
-                    value: _scannedValue.value,
-                    validated: _scannedValue.validated || false,
-                    timestamp: _scannedValue.timestamp || Date.now()
-                  }]
-                };
-                if (isErcSelector) {
-                  scanOutput.pendingEtData[_jobId]['baseResponse'] = {
-                    ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.eventCode) || getEventCodeByET(ExecutionTaskID.SCAN, _isScannedSuccess, _appRC), (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.reasonCode) || ''))
-                  };
-                }
-              } else {
-                scanOutput.etData[_jobId] = {
-                  scans: getScannedItems(_scannedValue)
-                };
-                if (isErcSelector && !isCancelled) {
-                  scanOutput.etData[_jobId]['baseResponse'] = {
-                    ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.eventCode) || getEventCodeByET(ExecutionTaskID.SCAN, _isScannedSuccess, _appRC), (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.reasonCode) || ''))
-                  };
-                } else if (isCancelled) {
-                  scanOutput.etData[_jobId]['baseResponse'] = {
-                    ...(await getBaseETResponse(EntityCode.SCAN, false, defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.eventCode, (defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.reasonCode) || ''))
-                  };
-                }
-              }
-              blindData.set(_jobId, {
-                ...blindValue,
-                scannedCount: blindValue.scannedCount + 1
-              });
-            }
-            break;
+  // 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
           }
-        }
+        };
       }
-    } else {
-      /**
-       * Only successful scans are pushed to output for mode MULTI
-       */
-      if (selectedValidationIndex === 0 && _scannedValue.jobId) {
-        var _scanOutput$etData$_s;
-        scanOutput.etData[_scannedValue.jobId] = {
-          scans: (_scanOutput$etData$_s = scanOutput.etData[_scannedValue.jobId]) !== null && _scanOutput$etData$_s !== void 0 && _scanOutput$etData$_s.scans ? scanOutput.etData[_scannedValue.jobId].scans.concat(getScannedItems(_scannedValue)) : getScannedItems(_scannedValue)
+    case DeliverState.DELIVERE_LATER:
+      {
+        const output = await getBaseETResponse(EntityCode.SCAN, false, REASON_NOT_USED, '', mergedObjectiveId, ExecutionTaskID.SCAN);
+        mergeScannedOutput['default'] = {
+          output,
+          count
         };
-        if (isErcSelector && !isCancelled) {
-          scanOutput.etData[_scannedValue.jobId]['baseResponse'] = {
-            ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.eventCode) || getEventCodeByET(ExecutionTaskID.SCAN, _isScannedSuccess, _appRC), (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.reasonCode) || ''))
-          };
-        } else if (isCancelled) {
-          scanOutput.etData[_scannedValue.jobId]['baseResponse'] = {
-            ...(await getBaseETResponse(EntityCode.SCAN, false, defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.eventCode, (defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.reasonCode) || ''))
+        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
           };
-        }
-      } else {
-        for (let [_jobId, blindValue] of blindData.entries()) {
-          /**
-           * Blind scan without any maxCount limit
-           */
-          if (!scanCountLimit) {
-            var _scanOutput$etData$_j;
-            scanOutput.etData[_jobId] = {
-              scans: (_scanOutput$etData$_j = scanOutput.etData[_jobId]) !== null && _scanOutput$etData$_j !== void 0 && _scanOutput$etData$_j.scans ? scanOutput.etData[_jobId].scans.concat(getScannedItems(_scannedValue)) : getScannedItems(_scannedValue)
-            };
-            if (isErcSelector && !isCancelled) {
-              scanOutput.etData[_jobId]['baseResponse'] = {
-                ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.eventCode) || getEventCodeByET(ExecutionTaskID.SCAN, _isScannedSuccess, _appRC), (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.reasonCode) || ''))
-              };
-            } else if (isCancelled) {
-              scanOutput.etData[_jobId]['baseResponse'] = {
-                ...(await getBaseETResponse(EntityCode.SCAN, false, defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.eventCode, (defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.reasonCode) || ''))
-              };
-            }
-            break;
-          } else {
-            if (blindValue.maxCount === blindValue.scannedCount) continue;else {
-              var _scanOutput$etData$_j2;
-              scanOutput.etData[_jobId] = {
-                scans: (_scanOutput$etData$_j2 = scanOutput.etData[_jobId]) !== null && _scanOutput$etData$_j2 !== void 0 && _scanOutput$etData$_j2.scans ? scanOutput.etData[_jobId].scans.concat(getScannedItems(_scannedValue)) : getScannedItems(_scannedValue)
-              };
-              if (isErcSelector && !isCancelled) {
-                scanOutput.etData[_jobId]['baseResponse'] = {
-                  ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.eventCode) || getEventCodeByET(ExecutionTaskID.SCAN, _isScannedSuccess, _appRC), (_scannedValue === null || _scannedValue === void 0 ? void 0 : _scannedValue.reasonCode) || ''))
-                };
-              } else if (isCancelled) {
-                scanOutput.etData[_jobId]['baseResponse'] = {
-                  ...(await getBaseETResponse(EntityCode.SCAN, false, defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.eventCode, (defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.reasonCode) || ''))
-                };
-              }
-              blindData.set(_jobId, {
-                ...blindValue,
-                scannedCount: blindValue.scannedCount + 1
-              });
-              break;
-            }
-          }
+          return mergeScannedOutput;
+        } else {
+          return mergeScannedOutput;
         }
       }
-    }
-  }
-
-  /**
-   * Add unscanned objectives to pending_states
-   */
-  if (isMultiObjectiveEnable) {
-    if (scansMap.size) {
-      for (let [, _scannedValue] of scansMap.entries()) {
-        const _isScannedSuccess = _scannedValue !== null && _scannedValue !== void 0 && _scannedValue.success ? true : false;
-        for (let [_jobId, blindValue] of blindData.entries()) {
-          if (_scannedValue.jobId === _jobId) {
-            if (blindValue.scannedCount === 1) continue;else {
-              if (!_scannedValue.scanStatus || _scannedValue.scanStatus === SCAN_STATUS.FAILED) {
-                if (!scanOutput.pendingEtData) scanOutput.pendingEtData = {};
-                scanOutput.pendingEtData[_jobId] = {
-                  scans: [{
-                    value: _scannedValue.value,
-                    validated: _scannedValue.validated || false,
-                    timestamp: _scannedValue.timestamp || Date.now()
-                  }]
-                };
-                scanOutput.pendingEtData[_jobId]['baseResponse'] = {
-                  ...(await getBaseETResponse(EntityCode.SCAN, _isScannedSuccess, defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.eventCode, (defaultERC === null || defaultERC === void 0 ? void 0 : defaultERC.reasonCode) || ''))
-                };
-                blindData.set(_jobId, {
-                  ...blindValue,
-                  scannedCount: blindValue.scannedCount + 1
-                });
-              }
-              break;
-            }
-          }
-        }
+    default:
+      {
+        return mergeScannedOutput;
       }
-    }
   }
-  return scanOutput;
 }
 export function getScannedItems(scanValue) {
   const items = [];
@@ -355,4 +287,440 @@ export function isReplacement(scan, scansMap, selectedEventCode, selectedReason)
   }
   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