@trustchex/react-native-sdk 1.374.0 → 1.409.0

package/src/Shared/Services/DataUploadService.ts

@@ -0,0 +1,395 @@
+import RNFS from 'react-native-fs';
+import { Platform } from 'react-native';
+import type {
+  IdentificationInfo,
+  ScannedIdentityDocument,
+  LivenessDetection,
+} from '../Types/identificationInfo';
+import { getSessionKey, encryptWithAes } from '../Libs/crypto.utils';
+import mrzUtils from '../Libs/mrz.utils';
+import httpClient from '../Libs/http-client';
+import { NotFoundError } from '../Libs/http-client';
+import { runWithRetry } from '../Libs/promise.utils';
+
+/**
+ * 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 {
+  private baseUrl: string;
+  private apiUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+    this.apiUrl = `${baseUrl}/api/app/mobile`;
+  }
+
+  private async ensureIdentificationExists(
+    identificationId: string
+  ): Promise<void> {
+    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: string,
+    scannedDocument: ScannedIdentityDocument,
+    sessionKey: string
+  ): Promise<void> {
+    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: string,
+    scannedDocument?: ScannedIdentityDocument,
+    livenessDetection?: LivenessDetection,
+    onProgress?: (progress: number) => void
+  ): Promise<void> {
+    const uploadFileOptions: RNFS.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: string;
+      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: IdentificationInfo,
+    onProgress?: (progress: number) => void
+  ): Promise<boolean> {
+    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;
+    }
+  }
+
+  private getGenderEnumType(sex: string | undefined): string {
+    switch (sex?.toLowerCase()) {
+      case 'male':
+      case 'm':
+        return 'M';
+      case 'female':
+      case 'f':
+        return 'F';
+      default:
+        return 'X';
+    }
+  }
+}

package/src/Shared/Services/VideoSessionService.ts

@@ -0,0 +1,190 @@
+export interface VideoSessionInfo {
+  sessionId: string;
+  identificationId: string;
+  callState: 'WAITING' | 'CONNECTING' | 'ACTIVE' | 'COMPLETED' | 'FAILED';
+  queuePosition?: number;
+  connectedAt?: string;
+}
+
+export class VideoSessionService {
+  private baseUrl: string;
+  private identificationId?: string;
+
+  constructor(baseUrl: string, identificationId?: string) {
+    this.baseUrl = baseUrl;
+    this.identificationId = identificationId;
+  }
+
+  /**
+   * Get current active video session for customer
+   */
+  public async getCurrentSession(): Promise<VideoSessionInfo> {
+    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
+   */
+  public async joinSession(sessionId: string): Promise<VideoSessionInfo> {
+    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
+   */
+  public async sendHeartbeat(sessionId: string): Promise<void> {
+    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)
+   */
+  public async leaveSession(sessionId: string): Promise<void> {
+    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)
+   */
+  public subscribeToQueueUpdates(
+    sessionId: string,
+    onUpdate: (position: number) => void,
+    onError: (error: Error) => void
+  ): () => void {
+    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: NodeJS.Timeout | null = 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: any) => {
+        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: any) => {
+        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 () => {};
+    }
+  }
+}