@transfergratis/react-native-sdk 0.1.4 → 0.1.6

package/src/modules/api/CardAuthentification.ts

@@ -0,0 +1,114 @@
+import kycService, { authentification, errorMessage } from "./KYCService";
+import { cropByObb } from "../../utils/cropByObb";
+import { IBbox } from "../../types/KYC.types";
+
+export async function frontVerification(result: { path?: string, regionMapping: string[], selectedDocumentType: string, code: string, currentSide: string, }) {
+    try {
+
+        console.log("Front verification", JSON.stringify({ result }, null, 2));
+        const token = await authentification();
+        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '')
+
+        if (!detected.result) {
+            throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
+        }
+
+        // Optional: crop image using card_obb for better MRZ/barcode extraction
+        let croppedBase64: string | undefined;
+        let bbox: IBbox | undefined;
+        let mrz: any | undefined;
+        try {
+            const crop = await cropByObb(result?.path || '', (detected as any).card_obb);
+            croppedBase64 = crop.base64;
+            bbox = crop.bbox;
+        } catch { }
+
+        if (result.regionMapping.length > 0 && result.regionMapping.includes('MRZ')) {
+            mrz = await kycService.extractMrzText({ fileUri: result.path || '', docType: result?.selectedDocumentType || '', docRegion: result?.code || "", postfix: result?.currentSide, token: token })
+
+        }
+
+        return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
+    } catch (e: any) {
+        console.error('Error front verification:', JSON.stringify(errorMessage(e), null, 2));
+        throw new Error(e?.message || 'Erreur de détection du visage');
+    }
+}
+
+export async function backVerification(result: { path?: string, regionMapping: string[], selectedDocumentType: string, code: string, currentSide: string, }) {
+    try {
+        if (!result.path) throw new Error('No path provided');
+        console.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
+        const token = await authentification();
+
+
+
+        // Fonction helper pour essayer MRZ puis barcode en fallback
+        const tryMrzWithBarcodeFallback = async () => {
+            try {
+                console.log("Tentative d'extraction MRZ");
+                const mrz = await kycService.extractMrzText({
+                    fileUri: result.path!,
+                    docType: result?.selectedDocumentType || '',
+                    docRegion: result?.code || '',
+                    postfix: 'back',
+                    token: token
+                });
+                return mrz;
+            } catch (mrzError: any) {
+                console.log("MRZ échoué, tentative d'extraction barcode");
+                try {
+                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                    return barcode;
+                } catch (barcodeError: any) {
+                    throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
+                }
+            }
+        };
+
+
+
+        if (result.regionMapping.length > 2) {
+            return await tryMrzWithBarcodeFallback();
+        }
+
+        if (result.regionMapping.length > 0 && result.regionMapping.includes('MRZ')) {
+            try {
+                const mrz = await kycService.extractMrzText({
+                    fileUri: result.path!,
+                    docType: result?.selectedDocumentType || '',
+                    docRegion: result?.code || '',
+                    postfix: 'back',
+                    token: token
+                });
+                let bbox: IBbox | undefined;
+                try {
+                    const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
+                    bbox = crop.bbox;
+                } catch { }
+                return { ...mrz, bbox };
+            } catch (mrzError: any) {
+                throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${mrzError?.message}`);
+            }
+        }
+
+        if (result.regionMapping.length > 0 && result.regionMapping.includes('2D_barcode')) {
+            try {
+                console.log("Tentative d'extraction barcode");
+                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                let bbox: IBbox | undefined;
+                try {
+                    const crop = await cropByObb(result?.path || '', (barcode as any).card_obb);
+                    bbox = crop.bbox;
+                } catch { }
+                return { ...barcode, bbox };
+            } catch (barcodeError: any) {
+                throw new Error(`Barcode et MRZ ont échoué. Barcode: ${barcodeError?.message}, MRZ: ${barcodeError?.message}`);
+            }
+        }
+        return null;
+    } catch (e: any) {
+        throw new Error(e?.message || 'Erreur de détection du MRZ ou barcode');
+    }
+}
+

package/src/modules/api/KYCService.ts

@@ -1,5 +1,7 @@
 import axios from 'axios';
-import { OrientationVideoResponse } from '../../types/KYC.types';
+import { GovernmentDocumentType, GovernmentDocumentTypeShorted, OrientationVideoResponse } from '../../types/KYC.types';
+import { ExtractMrzTextResponse } from '../../components/OverLay/type';
+import { SessionResponse, VerificationResult, VerificationSessionRequest } from './types';
 
 export interface KYCRequest {
   userId: string;
@@ -26,9 +28,26 @@ export interface FaceDetectionResponse {
   message: string;
 }
 
+export interface SelfieVideoResponse {
+  orientation_direction: "center" | "left" | "right",
+  turn_score: number;
+  bbox: number[];
+  capture: boolean;
+  instruction: string;
+  error: string;
+}
+
+
 export class KYCService {
   private baseURL: string;
   private apiKey: string;
+  // Additional service base URLs (fixed as per current infra)
+  private faceServiceURL = 'http://kyc-ecs-alb-278715158.us-east-2.elb.amazonaws.com:8000';
+  private textExtractionServiceURL = 'http://kyc-ecs-alb-278715158.us-east-2.elb.amazonaws.com:8006';
+  private mrzServiceURL = 'http://kyc-ecs-alb-278715158.us-east-2.elb.amazonaws.com:8002';
+  private barcodeServiceURL = 'http://kyc-ecs-alb-278715158.us-east-2.elb.amazonaws.com:8000';
+  private orientationServiceURL = 'http://18.188.180.154:8080';
+  private backendServiceURL = 'http://16.170.133.50/api/v1';
 
   constructor(baseURL: string, apiKey: string) {
     this.baseURL = baseURL;
@@ -97,40 +116,48 @@ export class KYCService {
     }
   }
 
-  async processOrientationVideo(videoFile: string): Promise<OrientationVideoResponse> {
+  async processSelfieOrientationPicture(videoFile: string, token: string): Promise<SelfieVideoResponse[]> {
     try {
-      // Create FormData for multipart/form-data request
       const formData = new FormData();
-      
-      // Convert base64 to blob if needed, or use file path
-      let fileData;
-      if (videoFile.startsWith('data:') || videoFile.startsWith('file://')) {
-        // Handle base64 or file URI
-        if (videoFile.startsWith('data:')) {
-          const response = await fetch(videoFile);
-          fileData = await response.blob();
-        } else {
-          // For file:// URIs, we need to handle this differently
-          // This is a simplified approach - in a real implementation,
-          // you might need platform-specific handling
-          const response = await fetch(videoFile);
-          fileData = await response.blob();
+      const rnFile: any = {
+        uri: videoFile,
+        type: 'image/jpeg',
+        name: 'selfie_picture.jpg',
+      };
+      formData.append('file', rnFile);
+      const response = await axios.post<SelfieVideoResponse[]>(
+        `${this.faceServiceURL}/detect_face_orientation/`,
+        formData,
+        {
+          timeout: 20000,
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
         }
-      } else {
-        // Assume it's already a blob or file object
-        fileData = videoFile as any;
-      }
+      );
+      return response.data;
+    } catch (error) {
+      console.error('Error processing selfie orientation:', error);
+      throw error;
+    }
+  }
 
-      formData.append('file', fileData, 'orientation_video.mp4');
+  async processOrientationVideo(videoFile: string): Promise<OrientationVideoResponse> {
+    try {
+      // Create FormData for multipart/form-data request
+      const formData = new FormData();
+      // In React Native, prefer the { uri, type, name } pattern rather than Blob
+      const rnFile: any = {
+        uri: videoFile,
+        type: 'video/mp4',
+        name: 'orientation_video.mp4',
+      };
+      formData.append('file', rnFile);
 
       const response = await axios.post(
-        `${this.baseURL}/process_orientation_video_stream/`,
+        `${this.orientationServiceURL}/process_orientation_video_stream/`,
         formData,
-        { 
-          headers: {
-            // 'Authorization': `Bearer ${this.apiKey}`,
-            'Content-Type': 'multipart/form-data',
-          }
+        {
+          // Let axios set the proper multipart boundary header automatically
+          timeout: 90000,
         }
       );
 
@@ -141,7 +168,7 @@ export class KYCService {
       };
     } catch (error: any) {
       console.error('Error processing orientation video:', JSON.stringify(error, null, 2));
-      
+
       // Handle specific error cases
       if (error.response?.status === 503) {
         return {
@@ -166,6 +193,299 @@ export class KYCService {
       };
     }
   }
+
+  // STEP 1 - ID CARD VALIDATION
+  async detectFaceOnId(idCardImageUri: string, token: string, docType: string): Promise<{ result: boolean, detail: any[] }> {
+    const formData = new FormData();
+    const rnFile: any = { uri: idCardImageUri, type: 'image/jpeg', name: 'id_card_photo.jpg' };
+    formData.append('file', rnFile);
+
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+
+    try {
+      const res = await axios.post(`${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`, formData,
+        {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          timeout: 20000
+        });
+      console.log('detectFaceOnId res', JSON.stringify(res.data, null, 2));
+
+      if (res.data?.result) return res.data;
+      throw new Error(res.data?.detail || 'detect_face failed');
+    } catch (error) {
+      console.error('Error detecting face on id:', JSON.stringify(error));
+      throw error;
+    }
+  }
+
+  async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; token: string }): Promise<any> {
+    const { fileUri, docType, docRegion, token } = params;
+    const formData = new FormData();
+    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_front.jpg' };
+    formData.append('file', rnFile);
+
+    const url = `${this.textExtractionServiceURL}/extract_doc_information/?doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}`;
+    const attempt = async () => {
+      const res = await axios.post(url, formData, {
+        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+        timeout: 60000,
+      });
+      console.log('extractDocumentInformation res', JSON.stringify(res));
+
+      if (res.data?.detail) throw new Error(res.data.detail);
+      return res.data;
+    };
+    try {
+      return await attempt();
+    } catch (e) {
+      console.error('Error extracting document information:', JSON.stringify(e));
+      throw e;
+      // await new Promise(r => setTimeout(r, 1500));
+      // return await attempt();
+    }
+  }
+  // STEP 2 - barcode extraction
+  async extractBarcode(params: { fileUri: string; token: string }): Promise<any> {
+    const { fileUri, token } = params;
+    const formData = new FormData();
+    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_back.jpg' };
+    formData.append('file', rnFile);
+
+    const url = `${this.barcodeServiceURL}/decode_barcode/`;
+    const attempt = async () => {
+      try {
+        const res = await axios.post(url, formData, {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          timeout: 60000,
+        });
+        console.log('extractBarcode res', JSON.stringify(res.data));
+        //check if  res.data has aleast one key
+        if (Object.keys(res.data).length === 0) throw new Error('No data found');
+        return res.data;
+      } catch (e: any) {
+        throw new Error(e?.message || 'Erreur de détection du barcode');
+      }
+    };
+    try {
+      return await attempt();
+    } catch (e) {
+      console.error('Error extracting Barcode text:', JSON.stringify(e));
+      throw e;
+    }
+  }
+  // STEP 3 - MRZ TEXT EXTRACTION
+  async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string }): Promise<any> {
+    const { fileUri, docType, docRegion, postfix = 'back', token } = params;
+    const formData = new FormData();
+    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_back.jpg' };
+    formData.append('file', rnFile);
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    console.log("docTypeShorted", docTypeShorted, docRegion, postfix);
+
+    const url = `${this.mrzServiceURL}/extract_mrz_text/?doc_type=${docTypeShorted}&doc_region=${docRegion}&postfix=${postfix}`;
+    console.log("url", url);
+
+    const attempt = async () => {
+      try {
+        const res = await axios.post<ExtractMrzTextResponse>(url, formData, {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          timeout: 60000,
+        });
+        console.log('extractMrzText res', JSON.stringify(res.data));
+        //check if  res.data has aleast one key
+        if (Object.keys(res.data).length === 0) throw new Error('No data found');
+        if (res.data?.success === false) throw new Error(res.data.parsed_data.status);
+        return res.data;
+      } catch (e: any) {
+        throw new Error(e?.message || 'Erreur de détection du MRZ');
+      }
+    };
+    try {
+      return await attempt();
+    } catch (e) {
+      console.error('Error extracting MRZ text:', JSON.stringify(errorMessage(e), null, 2));
+      throw e;
+    }
+  }
+
+  // STEP 2 - SELFIE VALIDATION
+  async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
+    const { idPhotoUri, selfiePhotoUri } = params;
+    const formData = new FormData();
+    const idFile: any = { uri: idPhotoUri, type: 'image/jpeg', name: 'id_card_photo.jpg' };
+    const selfieFile: any = { uri: selfiePhotoUri, type: 'image/jpeg', name: 'selfie_final.jpg' };
+    formData.append('id_photo', idFile);
+    formData.append('selfie_photo', selfieFile);
+
+    const res = await axios.post(`${this.faceServiceURL}/recognize_face/`, formData, { timeout: 45000 });
+    if (res.data?.detail) throw new Error(res.data.detail);
+    return res.data;
+  }
+
+  // HEALTH CHECKS
+  async healthFaceDetection(): Promise<any> {
+    const res = await axios.get(`${this.faceServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthTextExtraction(): Promise<any> {
+    const res = await axios.get(`${this.textExtractionServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthMrzService(): Promise<any> {
+    const res = await axios.get(`${this.mrzServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthOrientationService(): Promise<any> {
+    const res = await axios.get(`${this.orientationServiceURL}/health`);
+    return res.data;
+  }
+
+  async newSession(token: string): Promise<SessionResponse> {
+    try {
+      const data = {
+        "status": "PENDING",
+        "metadata": {},
+      }
+      const res = await axios.post<SessionResponse>(`${this.backendServiceURL}/verification/sessions/`,
+        data, { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` } });
+      return res.data;
+    } catch (error: any) {
+      console.error('Error creating session:', JSON.stringify(errorMessage(error), null, 2));
+
+      // Extract backend error message if available
+      const backendMessage = errorMessage(error);
+
+      if (backendMessage) {
+        console.error('Backend error message:', JSON.stringify(backendMessage, null, 2));
+        throw new Error(`Backend error: ${JSON.stringify(backendMessage)}`);
+      }
+
+      throw error;
+    }
+  }
+
+  async verificationSession(payload: VerificationSessionRequest): Promise<any> {
+
+    try {
+
+      const token = await authentification();
+
+      // /api/v1/verification/api/kyc/sessions/{session_id}/steps/{step}/
+      const { session_id, step, data, templateId, action } = payload;
+      // const session_id = "kyc-8b4e069258d8";
+      const payloadData = {
+        action: action,
+        data: {
+          step,
+          templateId,
+          ...(action === "location_permission" ? { permissionGranted: true, } : {}),
+          ...data,
+        },
+        ...({ session_id: session_id }),
+        timestamp: new Date().toISOString()
+      }
+      const url = `${this.backendServiceURL}/verification/api/kyc/sessions/${session_id}/steps/${step}/`;
+
+
+      const logPayload = truncateFields({ payloadData, session_id, step });
+      console.log('verificationSession payload',
+        JSON.stringify({ logPayload, token, path: url },
+          null, 2))
+
+      const res = await axios.post<SessionResponse>(url,
+        payloadData,
+        {
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` }
+        });
+      console.log('verificationSession res', JSON.stringify(res.data, null, 2));
+      return res.data;
+
+
+    } catch (error) {
+      console.error('Error validating component:', JSON.stringify(errorMessage(error), null, 2));
+      throw new Error(errorMessage(error));
+    }
+  }
+  // reultat de la verification
+  async getVerificationResult(session_id: string): Promise<VerificationResult> {
+    const token = await authentification();
+    const url = `${this.backendServiceURL}/verification/api/kyc/result/?session_id=${session_id}`;
+    const res = await axios.get<VerificationResult>(url,
+      { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` } });
+    console.log('getVerificationResult res', JSON.stringify(res.data, null, 2));
+    return res.data;
+  }
+}
+
+
+const kycService = new KYCService("", "");
+export default kycService;
+
+
+// Pour éviter d'afficher des champs trop longs, on tronque les valeurs longues dans le log
+export function truncateFields(obj: any, maxLength = 420): any {
+  if (typeof obj !== 'object' || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map(item => truncateFields(item, maxLength));
+  const truncated: any = {};
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const value = obj[key];
+    if (typeof value === 'string' && value.length > maxLength) {
+      truncated[key] = value.slice(0, maxLength) + '... [truncated]';
+    } else if (typeof value === 'object' && value !== null) {
+      truncated[key] = truncateFields(value, maxLength);
+    } else {
+      truncated[key] = value;
+    }
+  }
+  return truncated;
 }
+export const authentification = async () => {
+  try {
+    const params = new URLSearchParams();
+    params.append('client_id', 'kyc_frontend');
+    params.append('client_secret', 'ZCW4mGaJXWR0UuI40lM1pHNQmYLw2xvX');
+    params.append('grant_type', 'client_credentials');
+    const res = await axios.post(`http://16.170.133.50:7080/realms/kyc/protocol/openid-connect/token`,
+      params,
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      }
+    );
+    console.log('authentification res', JSON.stringify(res.data));
+    return res.data.access_token;
+  } catch (error: any) {
+    console.error('Error authentifying:', {
+      message: error.message,
+      status: error.response?.status,
+      statusText: error.response?.statusText,
+      data: error.response?.data,
+      url: error.config?.url,
+      method: error.config?.method
+    });
+
+    // Extract backend error message if available
+    const backendMessage = errorMessage(error);
+
+    if (backendMessage) {
+      console.error('Backend authentication error:', JSON.stringify(backendMessage, null, 2));
+      throw new Error(`Authentication failed: ${JSON.stringify(backendMessage)}`);
+    }
+
+    throw error;
+  }
+}
+
+
 
-export default KYCService; 
+export const errorMessage = (error: any) => {
+  return error.response?.data?.message ||
+    error.response?.data?.detail ||
+    error.response?.data?.error ||
+    error.response?.data;
+}

package/src/modules/api/SelfieVerification.ts

@@ -0,0 +1,11 @@
+import kycService, { authentification } from "./KYCService";
+
+const selfieVerification = async (selfieImage: string) => {
+    const token = await authentification();
+
+    const response = await kycService.processSelfieOrientationPicture(selfieImage, token);
+    console.log("selfieVerification response", JSON.stringify(response, null, 2));
+    return response;
+}
+
+export default selfieVerification;

package/src/modules/api/backendApi.ts

@@ -0,0 +1,8 @@
+// import kycService from "./KYCService"
+
+
+
+// const initializesession = (token: string) => {
+
+//     // const session = await kycService.post("/session", {
+// }

package/src/modules/api/types.ts

@@ -0,0 +1,51 @@
+export interface SessionResponse {
+    id: number;
+    session_id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    metadata: string;
+    user: number;
+    module: number;
+}
+
+
+export interface VerificationSessionRequest {
+    step: number;
+    data: VerificationSessionData;
+    templateId: string | null;
+    session_id: string;
+    token: string;
+    action: string
+}
+
+
+// dynamic type
+export type VerificationSessionData = Record<string, any>;
+
+
+export interface VerificationResult {
+    [key: string]: {
+        data: {
+            verification_id: string;
+            verification_status: string;
+            completion_timestamp: string;
+            user_data: {
+                personal_information: {
+                    full_name: string;
+                    first_name: string | null;
+                    last_name: string | null;
+                    date_of_birth: string | null;
+                    nationality: string | null;
+                    gender: string | null;
+                    place_of_birth: string | null;
+                };
+            };
+            selfie_info: {
+                is_match: boolean;
+                similarity: number;
+                image: string;
+            };
+        };
+    };
+}