@trustchex/react-native-sdk 1.374.0 → 1.409.0

package/lib/module/Shared/Services/DataUploadService.js

@@ -0,0 +1,294 @@
+"use strict";
+
+import RNFS from 'react-native-fs';
+import { Platform } from 'react-native';
+import { getSessionKey, encryptWithAes } from "../Libs/crypto.utils.js";
+import mrzUtils from "../Libs/mrz.utils.js";
+import httpClient from "../Libs/http-client.js";
+import { NotFoundError } from "../Libs/http-client.js";
+import { runWithRetry } from "../Libs/promise.utils.js";
+
+/**
+ * Service to upload collected identification data to the backend.
+ * This is used to send data before/during video call so agents can see it.
+ */
+export class DataUploadService {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.apiUrl = `${baseUrl}/api/app/mobile`;
+  }
+  async ensureIdentificationExists(identificationId) {
+    console.log('[DataUploadService] POST', `${this.apiUrl}/identifications/${identificationId}`);
+    await httpClient.post(`${this.apiUrl}/identifications/${identificationId}`, {});
+    console.log('[DataUploadService] ✓ Identification created/verified');
+  }
+
+  /**
+   * Submit document data to the backend (same approach as ResultScreen)
+   */
+  async submitDocumentData(identificationId, scannedDocument, sessionKey) {
+    if (!scannedDocument || scannedDocument.documentType === 'UNKNOWN') {
+      console.log('[DataUploadService] No document data to submit');
+      return;
+    }
+    const mrzFields = scannedDocument.mrzFields;
+    if (!mrzFields) {
+      console.log('[DataUploadService] No MRZ fields to submit');
+      return;
+    }
+    const identificationDocument = {
+      type: mrzFields.documentCode,
+      name: mrzFields.firstName,
+      surname: mrzFields.lastName,
+      gender: this.getGenderEnumType(mrzFields.sex),
+      number: mrzFields.documentNumber,
+      country: mrzFields.issuingState,
+      barcodeValue: scannedDocument.barcodeValue,
+      personalNumber: mrzFields.personalNumber || mrzFields.optional1,
+      birthDate: mrzUtils.convertMRZDateToISODate(mrzFields.birthDate),
+      expiryDate: mrzUtils.convertMRZDateToISODate(mrzFields.expirationDate),
+      dataSource: scannedDocument.dataSource,
+      mrzText: scannedDocument.mrzText
+    };
+    console.log('[DataUploadService] Submitting document data:', identificationDocument.type, identificationDocument.number);
+    const {
+      encryptedData,
+      nonce
+    } = encryptWithAes(JSON.stringify(identificationDocument), sessionKey);
+    console.log('[DataUploadService] POST', `${this.apiUrl}/identifications/${identificationId}/documents`);
+    await runWithRetry(() => httpClient.post(`${this.apiUrl}/identifications/${identificationId}/documents`, {
+      encryptedData,
+      nonce
+    }));
+    console.log('[DataUploadService] ✓ Document data submitted');
+  }
+
+  /**
+   * Upload media files (document images, selfies, etc.)
+   */
+  async uploadMedia(identificationId, scannedDocument, livenessDetection, onProgress) {
+    const uploadFileOptions = {
+      toUrl: `${this.apiUrl}/identifications/${identificationId}/media`,
+      method: 'POST',
+      headers: {
+        Accept: 'application/json'
+      },
+      files: [],
+      progress: res => {
+        const progress = res.totalBytesSent / res.totalBytesExpectedToSend;
+        onProgress?.(progress);
+      }
+    };
+
+    // Add document front image
+    const frontImage = scannedDocument?.frontImage;
+    if (frontImage && frontImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), frontImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_FRONT_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add document back image
+    const backImage = scannedDocument?.backImage;
+    if (backImage && backImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), backImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_BACK_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add face image from document
+    const faceImage = scannedDocument?.faceImage;
+    if (faceImage && faceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), faceImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add secondary face image from document (optional)
+    const secondaryFaceImage = scannedDocument?.secondaryFaceImage;
+    if (secondaryFaceImage && secondaryFaceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), secondaryFaceImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add hologram image from document (optional)
+    const hologramImage = scannedDocument?.hologramImage;
+    if (hologramImage && hologramImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), hologramImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add liveness images and selfie from liveness detection
+    if (livenessDetection?.instructions) {
+      for (const instruction of livenessDetection.instructions) {
+        if (instruction?.photo) {
+          const filePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`;
+          await RNFS.writeFile(decodeURIComponent(filePath), instruction.photo, 'base64');
+          uploadFileOptions.files.push({
+            name: 'files',
+            filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
+            filepath: decodeURIComponent(filePath),
+            filetype: 'image/jpeg'
+          });
+          if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+            uploadFileOptions.files.push({
+              name: 'files',
+              filename: 'SELFIE_IMAGE.jpg',
+              filepath: decodeURIComponent(filePath),
+              filetype: 'image/jpeg'
+            });
+          }
+        }
+      }
+    }
+
+    // Add liveness video (optional)
+    if (livenessDetection?.videoPath) {
+      let videoFilePath;
+      if (Platform.OS === 'ios') {
+        const tempDir = `${RNFS.TemporaryDirectoryPath}/${new Date().getTime()}`;
+        await RNFS.mkdir(tempDir);
+        videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+      } else {
+        videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+      }
+      await RNFS.copyFile(livenessDetection.videoPath, videoFilePath);
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'LIVENESS_VIDEO.mp4',
+        filepath: decodeURIComponent(videoFilePath),
+        filetype: 'video/mp4'
+      });
+    }
+
+    // Skip upload if no files
+    if (uploadFileOptions.files.length === 0) {
+      console.log('[DataUploadService] No media files to upload');
+      return;
+    }
+    console.log('[DataUploadService] Uploading', uploadFileOptions.files.length, 'media files to', uploadFileOptions.toUrl);
+    const response = await runWithRetry(() => RNFS.uploadFiles(uploadFileOptions).promise);
+    console.log('[DataUploadService] Upload response status:', response.statusCode);
+    if (![200, 201, 204].includes(response.statusCode)) {
+      console.error('[DataUploadService] Media upload failed:', response.statusCode, response.body);
+      throw new Error(`Media upload failed: ${response.statusCode}`);
+    }
+    console.log('[DataUploadService] ✓ Media uploaded successfully');
+  }
+
+  /**
+   * Upload all collected data (document + media) before video call
+   */
+  async uploadCollectedData(identificationInfo, onProgress) {
+    const {
+      identificationId,
+      sessionId,
+      scannedDocument,
+      livenessDetection
+    } = identificationInfo;
+    let {
+      authToken
+    } = identificationInfo;
+    if (!identificationId) {
+      console.log('[DataUploadService] No identification ID, skipping upload');
+      return false;
+    }
+    console.log('[DataUploadService] ========== UPLOADING COLLECTED DATA ==========');
+    console.log('[DataUploadService] Identification ID:', identificationId);
+    console.log('[DataUploadService] Has document:', !!scannedDocument);
+    console.log('[DataUploadService] Has liveness:', !!livenessDetection);
+    console.log('[DataUploadService] Has auth token:', !!authToken);
+    try {
+      await runWithRetry(() => this.ensureIdentificationExists(identificationId));
+
+      // Always refresh session key for current session (required for encrypted submission)
+      if (sessionId) {
+        const existingAuthToken = authToken;
+        console.log('[DataUploadService] Getting session key...');
+        try {
+          authToken = await runWithRetry(() => getSessionKey(this.apiUrl, sessionId));
+          console.log('[DataUploadService] ✓ Session key obtained');
+        } catch (error) {
+          if (existingAuthToken) {
+            console.warn('[DataUploadService] Session key refresh failed, using existing token');
+            authToken = existingAuthToken;
+          } else {
+            throw error;
+          }
+        }
+      }
+      if (!authToken) {
+        console.log('[DataUploadService] No session key available, skipping upload');
+        return false;
+      }
+
+      // Step 1: Submit document data (using same encryption as ResultScreen)
+      if (scannedDocument) {
+        onProgress?.(0.1);
+        await runWithRetry(() => this.submitDocumentData(identificationId, scannedDocument, authToken));
+        onProgress?.(0.3);
+      }
+
+      // Step 2: Upload media files (images only, skip video for now - too slow)
+      onProgress?.(0.4);
+      await runWithRetry(() => this.uploadMedia(identificationId, scannedDocument, livenessDetection, p => {
+        onProgress?.(0.4 + p * 0.5);
+      }));
+      onProgress?.(1.0);
+      console.log('[DataUploadService] ✓ All collected data uploaded');
+
+      // Mark media as uploaded during video call
+      identificationInfo.mediaUploadedDuringVideoCall = true;
+
+      // Store the auth token back for future use
+      identificationInfo.authToken = authToken;
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        console.warn('[DataUploadService] Upload skipped: identification is not active anymore');
+        return false;
+      }
+      console.error('[DataUploadService] Failed to upload collected data:', error);
+      return false;
+    }
+  }
+  getGenderEnumType(sex) {
+    switch (sex?.toLowerCase()) {
+      case 'male':
+      case 'm':
+        return 'M';
+      case 'female':
+      case 'f':
+        return 'F';
+      default:
+        return 'X';
+    }
+  }
+}

package/lib/module/Shared/Services/VideoSessionService.js

@@ -0,0 +1,156 @@
+"use strict";
+
+export class VideoSessionService {
+  constructor(baseUrl, identificationId) {
+    this.baseUrl = baseUrl;
+    this.identificationId = identificationId;
+  }
+
+  /**
+   * Get current active video session for customer
+   */
+  async getCurrentSession() {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/current${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to get current session: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('[VideoSessionService] Error getting current session:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Join a video session
+   */
+  async joinSession(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/join${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to join session: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('[VideoSessionService] Error joining session:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send a heartbeat to keep the queue-status SSE watchdog alive
+   */
+  async sendHeartbeat(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/heartbeat${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      await fetch(url, {
+        method: 'POST'
+      });
+    } catch {
+      // best-effort, ignore errors
+    }
+  }
+
+  /**
+   * Leave the session queue (drops customer from WAITING state)
+   */
+  async leaveSession(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/join${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      await fetch(url, {
+        method: 'DELETE'
+      });
+    } catch (error) {
+      console.error('[VideoSessionService] Error leaving session:', error);
+    }
+  }
+
+  /**
+   * Subscribe to queue status updates via Server-Sent Events (SSE)
+   */
+  subscribeToQueueUpdates(sessionId, onUpdate, onError) {
+    try {
+      // Use react-native-sse for real SSE support
+      const EventSource = require('react-native-sse').default;
+      const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/queue-status?identificationId=${this.identificationId}`;
+      console.log('[VideoSessionService] Creating SSE connection to:', url);
+      const es = new EventSource(url);
+      let heartbeatInterval = null;
+      es.addEventListener('open', () => {
+        console.log('[VideoSessionService] Queue SSE connected');
+        // Send initial heartbeat
+        this.sendHeartbeat(sessionId).catch(() => {});
+        // Set up periodic heartbeat (every 20s to stay under 30s watchdog)
+        heartbeatInterval = setInterval(() => {
+          this.sendHeartbeat(sessionId).catch(() => {});
+        }, 20000);
+      });
+      es.addEventListener('ping', () => {
+        // Server sent a ping, respond with heartbeat
+        this.sendHeartbeat(sessionId).catch(() => {});
+      });
+      es.addEventListener('message', event => {
+        try {
+          const data = JSON.parse(event.data);
+          console.log('[VideoSessionService] Queue update:', data);
+          if (data.queuePosition !== undefined) {
+            onUpdate(data.queuePosition);
+          }
+
+          // Close connection if no longer waiting
+          if (data.callState !== 'WAITING') {
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+            es.close();
+          }
+        } catch (error) {
+          console.error('[SSE] Failed to parse queue update:', error);
+        }
+      });
+      es.addEventListener('error', event => {
+        console.error('[SSE] Connection error:', event);
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        onError(new Error('SSE connection failed'));
+        es.close();
+      });
+
+      // Return cleanup function
+      return () => {
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        es.close();
+      };
+    } catch (error) {
+      console.error('[VideoSessionService] Failed to create SSE connection:', error);
+      onError(error instanceof Error ? error : new Error('Failed to create SSE connection'));
+      return () => {};
+    }
+  }
+}