verant_id_cloud_scan 1.4.4-beta.0 → 1.4.4-beta.1

package/Api.js

@@ -1,136 +1,55 @@
+import { compressAndCompareImages } from "./FaceComparison.js";
+import { formatDateToISO } from "./DateUtils.js";
+import { FIELD_MAPPING, FIELD_DEFAULTS, getFieldValue } from "./FieldMapping.js";
+
 //prod
 const licenseServerAddress = "https://lic.verantid.com/api/v1";
 const dmvServerAddress = "https://dmv.verantid.com/api/v1/dmv_check";
-//staging
+// staging
 // const licenseServerAddress =
 //   "https://verant-license-server-staging-52b03b060a98.herokuapp.com/api/v1";
 // const dmvServerAddress =
 //   "https://dmv-check-server-staging-fcaab48bec21.herokuapp.com/api/v1/dmv_check";
 
-// Helper function that checks multiple possible keys and returns a non-empty value
-const getLicenseFieldValue = (data, possibleKeys) => {
-  for (const key of possibleKeys) {
-    if (data.hasOwnProperty(key)) {
-      const value = data[key];
-      if (value !== undefined && value !== null && value !== "") {
-        return value;
-      }
-    }
-  }
-  return undefined;
-};
-
 export const dmvCheck = async (clientId, scannerType, licenseData) => {
   const url = dmvServerAddress; // make sure dmvServerAddress is defined elsewhere
 
   // Build the driver object dynamically.
   const driver = {};
 
-  // Mapping of our driver field names to an array of possible keys
-  // Optionally include a default value if no valid value is found.
-  const fieldMapping = [
-    {
-      field: "jurisdiction_code",
-      keys: [
-        "jurisdiction_code",
-        "jurisdictionCode",
-        "JurisdictionCode",
-        "MailingJurisdictionCode",
-      ],
-    },
-    {
-      field: "document_category_code",
-      keys: [
-        "document_category_code",
-        "documentCategoryCode",
-        "DocumentCategoryCode",
-      ],
-      default: "1", // default value if nothing is found
-    },
-    {
-      field: "license_number",
-      keys: ["license_number", "licenseNumber", "LicenseNumber", "LicenseOrIDNumber"],
-    },
-    {
-      field: "expiration_date",
-      keys: [
-        "expiration_date",
-        "expirationDate",
-        "ExpirationDate",
-        "LicenseExpirationDate",
-      ],
-    },
-    {
-      field: "issue_date",
-      keys: [
-        "issue_date",
-        "issueDate",
-        "IssueDate",
-        "LicenseOrIDDocumentIssueDate",
-      ],
-    },
-    {
-      field: "first_name",
-      keys: ["first_name", "firstName", "FirstName"],
-    },
-    {
-      field: "last_name",
-      keys: ["last_name", "lastName", "LastName", "FamilyName"],
-    },
-    {
-      field: "birth_date",
-      keys: ["birth_date", "birthDate", "BirthDate", "DateOfBirth"],
-    },
-    {
-      field: "eye_color",
-      keys: ["eye_color", "eyeColor", "EyeColor"],
-    },
-    {
-      field: "sex_code",
-      keys: ["sex_code", "sexCode", "SexCode", "sex", "Sex"],
-    },
-    {
-      field: "address_line_1",
-      keys: [
-        "address_line_1",
-        "addressLine1",
-        "AddressLine1",
-        "MailingStreetAddress1",
-      ],
-    },
-    {
-      field: "city",
-      keys: ["city", "City", "MailingCity"],
-    },
-    {
-      field: "state",
-      keys: ["state", "State", "MailingJurisdictionCode"],
-    },
-    {
-      field: "postal_code",
-      keys: ["postal_code", "postalCode", "PostalCode", "MailingPostalCode"],
-    },
-    {
-      field: "height",
-      keys: ["height", "Height", "HeightInFT_IN", "HeightInCM"],
-    },
-    {
-      field: "weight",
-      keys: ["weight", "Weight", "WeightInLBS", "WeightInKG"],
-    },
-  ];
-
-  // Iterate over each mapping. If a non-empty value is found (or a default exists), add the field.
-  fieldMapping.forEach((mapping) => {
-    let value = getLicenseFieldValue(licenseData, mapping.keys);
-    if (value === undefined) {
-      if (mapping.hasOwnProperty("default")) {
-        value = mapping.default;
-      } else {
-        return; // Skip adding this field if no value (and no default) is found
+  // Iterate over each field in the mapping
+  Object.keys(FIELD_MAPPING).forEach((fieldName) => {
+    let value = getFieldValue(licenseData, fieldName);
+
+    // Use default value if no value found
+    if (value === undefined && FIELD_DEFAULTS.hasOwnProperty(fieldName)) {
+      value = FIELD_DEFAULTS[fieldName];
+    }
+
+    // Skip if still no value
+    if (value === undefined || value === null || value === '') {
+      return;
+    }
+
+    // Clean up the value (trim whitespace)
+    if (typeof value === 'string') {
+      value = value.trim();
+      // Skip if empty after trimming
+      if (value === '') {
+        return;
       }
     }
-    driver[mapping.field] = value;
+
+    // Format date fields to ISO format (YYYY-MM-DD)
+    if (fieldName === 'birth_date' || fieldName === 'expiration_date' || fieldName === 'issue_date') {
+      value = formatDateToISO(value);
+      // Skip if date formatting returned empty string (invalid date)
+      if (value === '') {
+        return;
+      }
+    }
+
+    driver[fieldName] = value;
   });
 
   // Assemble the data payload.
@@ -153,13 +72,43 @@ export const dmvCheck = async (clientId, scannerType, licenseData) => {
       const responseData = await response.json();
       return responseData; // Return the response data
     } else {
-      const errorText = await response.text(); // Read once and store
-      console.error("DMV check failed:", errorText);
-      return errorText; // Return the stored text
+      // Try to parse as JSON first (for structured error responses)
+      try {
+        const errorData = await response.json();
+        console.error("DMV check failed:", errorData);
+
+        // If there's a SOAP error message, try to extract a user-friendly message
+        let userMessage = errorData.message || 'DMV verification failed';
+
+        if (errorData.error_messages && typeof errorData.error_messages === 'string') {
+          // Try to extract text from SOAP fault
+          const reasonMatch = errorData.error_messages.match(/<s:Text[^>]*>([^<]+)<\/s:Text>/);
+          if (reasonMatch && reasonMatch[1]) {
+            userMessage = reasonMatch[1];
+          } else if (response.status === 503) {
+            userMessage = 'DMV verification service is temporarily unavailable. Please try again later.';
+          }
+        }
+
+        return { ...errorData, message: userMessage };
+      } catch (parseError) {
+        // If JSON parsing fails, fall back to text
+        const errorText = await response.text();
+        console.error("DMV check failed:", errorText);
+
+        let userMessage = 'DMV verification failed';
+        if (response.status === 503) {
+          userMessage = 'DMV verification service is temporarily unavailable. Please try again later.';
+        } else if (response.status === 500) {
+          userMessage = 'DMV verification service encountered an error. Please check your data and try again.';
+        }
+
+        return { status: 'error', message: userMessage, raw_error: errorText };
+      }
     }
   } catch (error) {
     console.error("There was a problem with the dmv_check request:", error);
-    return null; // Error occurred
+    return { status: 'error', message: error.message || 'Unable to connect to DMV verification service.' };
   }
 };
 
@@ -256,6 +205,41 @@ export const checkLicense = async (clientId, macAddress) => {
   }
 };
 
+/**
+ * Check if client has autoDmv feature enabled
+ *
+ * TODO: This will eventually call the /check_license endpoint and return
+ * the feature_licenses.autoDmv value. For now, we're manually returning true
+ * for testing purposes.
+ *
+ * @param {string} clientId - Client ID to check
+ * @returns {Promise<boolean>} True if autoDmv is enabled
+ */
+export const checkAutoDmvEnabled = async (clientId) => {
+    const url = licenseServerAddress + "/check_feature_license";
+    const data = { client_id: clientId };
+
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(data),
+      });
+
+      const responseData = await response.json();
+      console.log("Response from checkAutoDmvEnabled:", responseData);
+
+      if (response.ok && responseData.dmv_verifications) {
+        return responseData.dmv_verifications.auto_dmv === true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error checking autoDmv feature:", error);
+      return false;
+    }
+  };
 export const getBarcodeLicenseKey = async () => {
   const url = licenseServerAddress + "/get_barcode_license_key";
 
@@ -284,13 +268,7 @@ const postToScannerApi = async (
   commandObj,
   timeout = 10000
 ) => {
-  // Ensure the scanner address has a protocol (http:// or https://)
-  let formattedAddress = scannerAddress;
-  if (!scannerAddress.startsWith('http://') && !scannerAddress.startsWith('https://')) {
-    formattedAddress = `http://${scannerAddress}`;
-  }
-
-  let apiAddress = `${formattedAddress}/securelink`;
+  let apiAddress =`${scannerAddress}/securelink`;
 
   const controller = new AbortController();
   const signal = controller.signal;
@@ -342,41 +320,3 @@ export const stopScanning = (scannerAddress, commandObj) =>
 
 export const closeConnection = (scannerAddress, commandObj) =>
   postToScannerApi(scannerAddress, commandObj);
-
-// Check if scanner is present by attempting to connect and disconnect
-export const checkScannerPresent = async (scannerAddress) => {
-  try {
-    // Generate a unique message ID for this check
-    const messageId = new Date().toISOString();
-
-    // Attempt to establish connection
-    const connectCommand = {
-      Command: "Connect",
-      MessageId: messageId,
-      Exclusive: "false", // Use non-exclusive mode for just checking
-      IdleTimeout: "5",
-    };
-
-    const connectResponse = await postToScannerApi(scannerAddress, connectCommand, 5000);
-
-    // If connection failed or no session ID, scanner not present
-    if (!connectResponse || !connectResponse.SessionId) {
-      return false;
-    }
-
-    // Got a session ID, now disconnect
-    const disconnectCommand = {
-      Command: "Disconnect",
-      MessageId: new Date().toISOString(),
-      SessionId: connectResponse.SessionId,
-    };
-
-    await postToScannerApi(scannerAddress, disconnectCommand, 5000);
-
-    // Successfully connected and disconnected
-    return true;
-  } catch (error) {
-    // Any error means scanner is not reachable
-    return false;
-  }
-};

package/CloudScan.js

@@ -4,7 +4,7 @@ import {
   readBarcode,
 } from "./BarcodeScanner.js";
 import { driverLicenseFields } from "./DriverLicenseFields.js";
-import { localScannerChain, scanBack, scanFrontOnly } from "./LocalScannerApi.js";
+import { localScannerChain, scanBack, scanFrontOnly, getCachedClientId } from "./LocalScannerApi.js";
 import { compressAndCompareImages, compressImage } from "./FaceComparison.js";
 import {
   checkDmvFeatureLicense,
@@ -12,8 +12,9 @@ import {
   dmvCheck,
   getBarcodeLicenseKey,
   scannerChain,
-  scannerPresent,
 } from "./ScannerApi.js";
+import { VerificationModal } from "./VerificationModal.js";
+import { checkAutoDmvEnabled } from "./Api.js";
 
 let cachedLicenseFrontBase64 = "";
 
@@ -33,8 +34,6 @@ export const checkFaceCompareFeature = async (clientId) => {
   return await checkFaceComparisonFeatureLicense(clientId);
 }
 
-export { scannerPresent };
-
 export async function readImageBarcode(imageFile) {
   let returnObj = {
     barcodeResultsObject: {},
@@ -138,6 +137,33 @@ export const scanId = async (
     }
     barcodeResultsObject = extractInformation(res.barcodeResults);
     returnObj.barcodeResultsObject = barcodeResultsObject;
+
+    // Check if autoDmv is enabled and trigger modal
+    const autoDmvEnabled = await checkAutoDmvEnabled(clientId);
+    if (autoDmvEnabled) {
+      console.log('[AUTO-DMV] Feature enabled, showing verification modal');
+
+      // Determine scanner type - you can customize this based on your needs
+      const scannerType = 'DigitalCheck'; // Default scanner type
+
+      // Create and open the modal
+      const modal = new VerificationModal(clientId, scannerType, barcodeResultsObject, {
+        primaryColor: '#0074CB' // VerantID blue
+      });
+
+      try {
+        const dmvResult = await modal.open();
+        console.log('[AUTO-DMV] Modal result:', dmvResult);
+
+        // Attach DMV result to return object
+        returnObj.dmvVerificationResult = dmvResult;
+      } catch (error) {
+        console.error('[AUTO-DMV] Modal error:', error);
+        returnObj.dmvVerificationResult = { status: 'error', error: error.message };
+      }
+    } else {
+      console.log('[AUTO-DMV] Feature disabled for client:', clientId);
+    }
   }
   return returnObj;
 };
@@ -159,6 +185,26 @@ function getField(keyword, foundBarcodeString, beginNewline = true) {
   return subtext;
 }
 
+/**
+ * Formats sex code for display
+ * Converts AAMVA numeric codes (1=Male, 2=Female) to letters (M, F)
+ * Preserves any other values unchanged
+ * @param {string} sexCode - The sex code from the barcode
+ * @returns {string} Formatted sex code
+ */
+function formatSexCodeForDisplay(sexCode) {
+  if (!sexCode) return '';
+
+  const code = String(sexCode).trim();
+
+  // AAMVA standard: 1 = Male, 2 = Female
+  if (code === '1') return 'M';
+  if (code === '2') return 'F';
+
+  // Return original value for anything else (9, X, M, F, etc.)
+  return sexCode;
+}
+
 //extracts the information from the barcode
 function extractInformation(foundBarcodeString) {
   var resultsArray = {};
@@ -167,7 +213,13 @@ function extractInformation(foundBarcodeString) {
     var item = driverLicenseFields[i];
     var fieldValue = getField(item.abbreviation, foundBarcodeString);
     if (fieldValue !== false) {
-      resultsArray[item.description] = fieldValue;
+      // Format sex code for display while preserving original in OriginalSexCode
+      if (item.description === 'Sex') {
+        resultsArray['OriginalSexCode'] = fieldValue; // Store original for DMV verification
+        resultsArray[item.description] = formatSexCodeForDisplay(fieldValue);
+      } else {
+        resultsArray[item.description] = fieldValue;
+      }
     }
     if (item.abbreviation === "DAQ" && !fieldValue) {
       fieldValue = getField("DLDAQ", foundBarcodeString, false);
@@ -196,18 +248,15 @@ export const localScanId = async (scannerAddress, clientId) => {
   console.log("scanner address: " + scannerAddress);
   let scannerResponseObj = await localScannerChain(scannerAddress, clientId);
 
-  //console.log(scannerResponseObj);
   if (scannerResponseObj.errorMessages.length > 0) {
     returnObj.errorMessages = scannerResponseObj.errorMessages;
     return returnObj;
-    //return error
   }
   cachedLicenseFrontBase64 = scannerResponseObj.licenseFrontBase64;
-  //console.log(cachedLicenseFrontBase64);
   return true;
 };
 
-export const localContinueScanId = async (scannerAddress, includeData, skipBackScan = false) => {
+export const localContinueScanId = async (scannerAddress, includeData, clientId = null, skipBackScan = false) => {
   let barcodeResultsObject = {};
   let returnObj = {
     barcodeResultsObject,
@@ -229,7 +278,8 @@ export const localContinueScanId = async (scannerAddress, includeData, skipBackS
   else {
       scannerResponseObj = await scanBack(scannerAddress, includeData);
   }
-  
+
+  //console.log(scannerResponseObj);
   if (scannerResponseObj.errorMessages.length > 0) {
     returnObj.errorMessages = scannerResponseObj.errorMessages;
     return returnObj;
@@ -285,6 +335,42 @@ export const localContinueScanId = async (scannerAddress, includeData, skipBackS
     }
     barcodeResultsObject = extractInformation(barcodeResponse.barcodeResults);
     returnObj.barcodeResultsObject = barcodeResultsObject;
+
+    // Check if autoDmv is enabled and trigger modal
+    // Use provided clientId, or fall back to cached clientId from localScanId
+    const effectiveClientId = clientId || getCachedClientId();
+
+    if (!effectiveClientId) {
+      console.warn('[AUTO-DMV] No clientId available. Auto-DMV verification will be skipped. Please ensure clientId is passed to localContinueScanId or that localScanId was called first.');
+    }
+
+    if (effectiveClientId) {
+      const autoDmvEnabled = await checkAutoDmvEnabled(effectiveClientId);
+      if (autoDmvEnabled) {
+        console.log('[AUTO-DMV] Feature enabled, showing verification modal');
+
+        // Determine scanner type - you can customize this based on your needs
+        const scannerType = 'VerantId6S'; // Default scanner type for local scanner
+
+        // Create and open the modal
+        const modal = new VerificationModal(effectiveClientId, scannerType, barcodeResultsObject, {
+          primaryColor: '#0074CB' // VerantID blue
+        });
+
+        try {
+          const dmvResult = await modal.open();
+          console.log('[AUTO-DMV] Modal result:', dmvResult);
+
+          // Attach DMV result to return object
+          returnObj.dmvVerificationResult = dmvResult;
+        } catch (error) {
+          console.error('[AUTO-DMV] Modal error:', error);
+          returnObj.dmvVerificationResult = { status: 'error', error: error.message };
+        }
+      } else {
+        console.log('[AUTO-DMV] Feature disabled for client:', effectiveClientId);
+      }
+    }
   }
   return returnObj;
 };

package/DateUtils.js

@@ -0,0 +1,57 @@
+/**
+ * Shared date formatting utilities
+ */
+
+/**
+ * Formats a date from MMDDYYYY to YYYY-MM-DD (ISO format)
+ * Used for API submissions
+ * @param {string} mmddyyyy - Date string in MMDDYYYY format
+ * @returns {string} Date in YYYY-MM-DD format, or empty string if invalid
+ */
+export const formatDateToISO = (mmddyyyy) => {
+  if (!mmddyyyy || mmddyyyy.length < 8) {
+    return "";
+  }
+  const month = mmddyyyy.slice(0, 2);
+  const day = mmddyyyy.slice(2, 4);
+  const year = mmddyyyy.slice(4, 8);
+  return `${year}-${month}-${day}`;
+};
+
+/**
+ * Formats a date from MMDDYYYY to MM/DD/YYYY (display format)
+ * Used for UI display
+ * @param {string} dateStr - Date string in MMDDYYYY, YYYY-MM-DD, or MM/DD/YYYY format
+ * @returns {string} Date in MM/DD/YYYY format, or original string if already formatted
+ */
+export const formatDateToDisplay = (dateStr) => {
+  if (!dateStr || dateStr.length < 8) {
+    return dateStr;
+  }
+
+  // Already in MM/DD/YYYY or YYYY-MM-DD format
+  if (dateStr.includes('/') || dateStr.includes('-')) {
+    return dateStr;
+  }
+
+  // Convert MMDDYYYY to MM/DD/YYYY
+  const month = dateStr.slice(0, 2);
+  const day = dateStr.slice(2, 4);
+  const year = dateStr.slice(4, 8);
+
+  return `${month}/${day}/${year}`;
+};
+
+/**
+ * List of date field names
+ */
+export const DATE_FIELDS = ['birth_date', 'expiration_date', 'issue_date'];
+
+/**
+ * Checks if a field name represents a date field
+ * @param {string} fieldName - Field name to check
+ * @returns {boolean} True if field is a date field
+ */
+export const isDateField = (fieldName) => {
+  return DATE_FIELDS.includes(fieldName);
+};

package/FieldMapping.js

@@ -0,0 +1,72 @@
+/**
+ * Shared field mapping configuration for license data
+ * Maps standardized field names to various possible keys found in license data
+ */
+
+export const FIELD_MAPPING = {
+  jurisdiction_code: ['jurisdiction_code', 'jurisdictionCode', 'JurisdictionCode', 'MailingJurisdictionCode'],
+  document_category_code: ['document_category_code', 'documentCategoryCode', 'DocumentCategoryCode'],
+  license_number: ['license_number', 'licenseNumber', 'LicenseNumber', 'LicenseOrIDNumber'],
+  expiration_date: ['expiration_date', 'expirationDate', 'ExpirationDate', 'LicenseExpirationDate'],
+  issue_date: ['issue_date', 'issueDate', 'IssueDate', 'LicenseOrIDDocumentIssueDate'],
+  first_name: ['first_name', 'firstName', 'FirstName'],
+  last_name: ['last_name', 'lastName', 'LastName', 'FamilyName'],
+  birth_date: ['birth_date', 'birthDate', 'BirthDate', 'DateOfBirth'],
+  eye_color: ['eye_color', 'eyeColor', 'EyeColor'],
+  sex_code: ['OriginalSexCode', 'sex_code', 'sexCode', 'SexCode', 'sex', 'Sex'],
+  address_line_1: ['address_line_1', 'addressLine1', 'AddressLine1', 'MailingStreetAddress1'],
+  city: ['city', 'City', 'MailingCity'],
+  state: ['state', 'State', 'MailingJurisdictionCode'],
+  postal_code: ['postal_code', 'postalCode', 'PostalCode', 'MailingPostalCode'],
+  height: ['height', 'Height', 'HeightInFT_IN', 'HeightInCM'],
+  weight: ['weight', 'Weight', 'WeightInLBS', 'WeightInKG']
+};
+
+/**
+ * Default values for certain fields
+ */
+export const FIELD_DEFAULTS = {
+  document_category_code: '1'
+};
+
+/**
+ * Gets the value of a field from license data by checking multiple possible keys
+ * @param {Object} data - License data object
+ * @param {string} fieldName - Standardized field name (e.g., 'first_name')
+ * @returns {string|undefined} Field value or undefined if not found
+ */
+export const getFieldValue = (data, fieldName) => {
+  const possibleKeys = FIELD_MAPPING[fieldName] || [fieldName];
+
+  for (const key of possibleKeys) {
+    if (data.hasOwnProperty(key)) {
+      const value = data[key];
+      if (value !== undefined && value !== null && value !== '') {
+        return value;
+      }
+    }
+  }
+  return undefined;
+};
+
+/**
+ * Field name labels for display
+ */
+export const FIELD_LABELS = {
+  first_name: 'First Name',
+  last_name: 'Last Name',
+  license_number: 'License Number',
+  birth_date: 'Date of Birth',
+  address_line_1: 'Address',
+  expiration_date: 'Expiration Date',
+  issue_date: 'Issue Date',
+  eye_color: 'Eye Color',
+  sex_code: 'Sex',
+  height: 'Height',
+  weight: 'Weight',
+  city: 'City',
+  state: 'State',
+  postal_code: 'Postal Code',
+  jurisdiction_code: 'Jurisdiction',
+  document_category_code: 'Document Category'
+};

package/LocalScannerApi.js

@@ -8,6 +8,7 @@ let scanDataResults = {};
 let licenseFrontBase64 = "";
 let licenseBackBase64 = "";
 let imageCount = 0;
+let cachedClientId = "";
 
 function buildError(errorText) {
   if (errorText.includes("Invalid URL")) {
@@ -26,6 +27,7 @@ function buildError(errorText) {
 export async function localScannerChain(ambirApiAddress, clientId) {
   errorMessages = [];
   localApiAddress = ambirApiAddress;
+  cachedClientId = clientId; // Cache clientId for use in localContinueScanId
 
   //0 get list of local scanners
   const localScannerResults = await getLocalScanners();
@@ -507,3 +509,8 @@ async function clearImageAndCloseScannerConnection() {
     return false;
   }
 }
+
+// Getter for cached clientId
+export function getCachedClientId() {
+  return cachedClientId;
+}

package/ScannerApi.js

@@ -41,10 +41,6 @@ export async function dmvCheck(clientId, scannerType, licenseData) {
   return await API.dmvCheck(clientId, scannerType, licenseData);
 }
 
-export async function scannerPresent(scannerAddress) {
-  return await API.checkScannerPresent(scannerAddress);
-}
-
 //This is the top level function that calls the other functions in order
 export async function scannerChain(
   scannerAddress,