@transfergratis/react-native-sdk 0.1.24 → 0.1.25

package/src/hooks/useTemplateKYCFlow.tsx

@@ -1,5 +1,6 @@
 import React, { useState, useCallback, useMemo, createContext, useContext, ReactNode, useEffect } from 'react';
 import { KYCTemplate, TemplateState, TemplateActions, UseTemplateReturn, TemplateComponent, GovernmentDocumentType, VerificationState } from '../types/KYC.types';
+import { KycEnvironment } from '../types/env.types';
 import kycService, { authentification, truncateFields } from '../modules/api/KYCService';
 import useI18n from './useI18n';
 import { logger } from '../utils/logger';
@@ -15,6 +16,7 @@ interface TemplateKYCFlowContextType {
   isComplete: boolean;
   getLocalizedText: (text: { en: string; fr: string;[key: string]: string }) => string;
   initializeSession: () => Promise<void>;
+  env: KycEnvironment;
 }
 
 const TemplateKYCFlowContext = createContext<TemplateKYCFlowContextType | undefined>(undefined);
@@ -28,6 +30,9 @@ interface TemplateKYCFlowProviderProps {
   onCancel?: () => void;
   initialLanguage?: string;
   apiKey?: string;
+  env?: KycEnvironment;
+  existingSessionId?: string;
+  initialStep?: number;
 }
 
 export const TemplateKYCFlowProvider: React.FC<TemplateKYCFlowProviderProps> = ({
@@ -38,8 +43,10 @@ export const TemplateKYCFlowProvider: React.FC<TemplateKYCFlowProviderProps> = (
   onCancel,
   initialLanguage = 'en',
   apiKey,
+  env = 'PRODUCTION',
+  existingSessionId,
 }) => {
-  const hookResult = useTemplateKYCFlow(template, onComplete, onError, onCancel, initialLanguage, apiKey);
+  const hookResult = useTemplateKYCFlow(template, onComplete, onError, onCancel, initialLanguage, apiKey, env, existingSessionId);
 
   return (
     <TemplateKYCFlowContext.Provider value={hookResult}>
@@ -64,6 +71,9 @@ export const useTemplateKYCFlow = (
   onCancel?: () => void,
   initialLanguage: string = 'en',
   apiKey?: string,
+  env: KycEnvironment = 'PRODUCTION',
+  existingSessionId?: string,
+  initialStep?: number,
 ): UseTemplateReturn => {
 
   const { setLocale } = useI18n();
@@ -131,29 +141,286 @@ export const useTemplateKYCFlow = (
   const templateWithReviewAndVerification = useMemo(() => ensureVerificationProgressStep(templateWithReview), [templateWithReview, ensureVerificationProgressStep, apiKey]);
 
   // État initial du flux
-  const buildInitialState = (): TemplateState => ({
-    template: templateWithReviewAndVerification,
-    currentComponentIndex: 0,
-    completedComponents: [],
-    componentData: {},
-    errors: {},
-    isProcessing: false,
-    currentLanguage: initialLanguage,
-    showCustomStepper: true,
-    session: {
-      session_id: '',
-      token: '',
-      isInitialized: false,
+  const buildInitialState = (): TemplateState => {
+    // Valider initialStep pour s'assurer qu'il est dans les limites du template
+    let validInitialStep = 0;
+    let completedComponents: number[] = [];
+    
+    logger.log('buildInitialState called', { initialStep, existingSessionId });
+    
+    if (initialStep !== undefined && initialStep >= 0) {
+      const maxIndex = templateWithReviewAndVerification.components.length - 1;
+      const requestedStep = Math.min(initialStep, maxIndex);
+      const requestedComponent = templateWithReviewAndVerification.components[requestedStep];
+      
+      logger.log('Processing initialStep', {
+        initialStep,
+        requestedStep,
+        maxIndex,
+        componentType: requestedComponent?.type,
+        componentId: requestedComponent?.id
+      });
+      
+      // Si on reprend à l'étape id_card, on peut rester à id_card si on a une session existante
+      // car les données de country_selection peuvent être chargées depuis la session
+      if (requestedComponent?.type === 'id_card') {
+        // Si on a une session existante, on peut rester à id_card et charger les données
+        if (existingSessionId) {
+          logger.log('id_card with existing session - staying at id_card');
+          validInitialStep = requestedStep;
+          // Marquer les composants précédents comme complétés
+          if (validInitialStep > 0) {
+            completedComponents = templateWithReviewAndVerification.components
+              .slice(0, validInitialStep)
+              .map(component => component.id);
+          }
+        } else {
+          // Si pas de session, revenir à country_selection pour refaire le choix
+          const countrySelectionIndex = templateWithReviewAndVerification.components.findIndex(
+            c => c.type === 'country_selection'
+          );
+          
+          logger.log('id_card without session - going back to country_selection', { countrySelectionIndex });
+          
+          if (countrySelectionIndex >= 0) {
+            validInitialStep = countrySelectionIndex;
+            // Marquer les composants avant country_selection comme complétés
+            if (countrySelectionIndex > 0) {
+              completedComponents = templateWithReviewAndVerification.components
+                .slice(0, countrySelectionIndex)
+                .map(component => component.id);
+            }
+          } else {
+            // Si pas de country_selection, commencer au début
+            validInitialStep = 0;
+          }
+        }
+      } else if (requestedComponent?.type === 'review_submit') {
+        // Si on reprend au review_submit, on ne marque pas les composants précédents
+        // pour permettre à l'utilisateur de revenir en arrière et vérifier/modifier les données
+        validInitialStep = requestedStep;
+        // Ne pas marquer les composants précédents comme complétés
+        completedComponents = [];
+      } else {
+        // Pour les autres composants (selfie, etc.), commencer directement à l'étape demandée
+        validInitialStep = requestedStep;
+        
+        // Marquer tous les composants précédents comme complétés
+        // Cela permet à l'utilisateur de continuer sans refaire les étapes précédentes
+        if (validInitialStep > 0) {
+          completedComponents = templateWithReviewAndVerification.components
+            .slice(0, validInitialStep)
+            .map(component => component.id);
+        }
+      }
+      
+      logger.log('Final initial state', {
+        validInitialStep,
+        completedComponentsCount: completedComponents.length,
+        componentAtStep: templateWithReviewAndVerification.components[validInitialStep]?.type
+      });
+    }
+    
+    return {
+      template: templateWithReviewAndVerification,
+      currentComponentIndex: validInitialStep,
+      completedComponents: completedComponents,
+      componentData: {},
+      errors: {},
       isProcessing: false,
-      error: null,
-    },
-    verification: {
-      status: 'idle',
-    },
-  });
+      currentLanguage: initialLanguage,
+      showCustomStepper: true,
+      session: {
+        session_id: existingSessionId || '',
+        token: '',
+        isInitialized: false,
+        isProcessing: false,
+        error: null,
+      },
+      verification: {
+        status: 'idle',
+      },
+    };
+  };
 
   // État du flux
   const [state, setState] = useState<TemplateState>(() => buildInitialState());
+  
+  // Fonction utilitaire pour convertir base64 en data URI pour l'affichage
+  const base64ToDataUri = useCallback((base64: string, mimeType: string = 'image/jpeg'): string => {
+    // Si c'est déjà une data URI, retourner tel quel
+    if (base64.startsWith('data:')) {
+      return base64;
+    }
+    // Sinon, créer une data URI
+    return `data:${mimeType};base64,${base64}`;
+  }, []);
+
+  // Charger les données de session si on reprend une session existante
+  useEffect(() => {
+    const loadSessionData = async () => {
+      // Ne charger que si on a une session existante
+      if (!existingSessionId) {
+        logger.log('No existingSessionId, skipping data load');
+        return;
+      }
+
+      // Si initialStep n'est pas défini ou est 0, on ne charge pas (début de session)
+      if (initialStep === undefined || initialStep === 0) {
+        logger.log('initialStep is 0 or undefined, skipping data load');
+        return;
+      }
+
+      // Attendre que la session soit initialisée
+      if (!state.session.isInitialized || !state.session.session_id) {
+        logger.log('Session not initialized yet, waiting...', {
+          isInitialized: state.session.isInitialized,
+          sessionId: state.session.session_id
+        });
+        return;
+      }
+
+      try {
+        logger.log('Loading session data for resume:', { sessionId: existingSessionId, step: initialStep });
+        const result = await kycService.getVerificationResult(state.session.session_id);
+        const sessionData = result[state.session.session_id]?.data;
+
+        if (sessionData) {
+          // Restaurer les données des composants depuis la session
+          // Utiliser 'as any' car VerificationResult peut avoir des propriétés dynamiques
+          const data: any = sessionData;
+          const restoredComponentData: Record<number, any> = {};
+
+          // Parcourir les composants jusqu'à l'étape initiale (incluse) pour restaurer leurs données
+          // Utiliser initialStep + 1 pour inclure le composant à l'étape initialStep
+          templateWithReviewAndVerification.components
+            .slice(0, initialStep + 1)
+            .forEach((component) => {
+              // Essayer de restaurer les données selon le type de composant
+              if (component.type === 'id_card' || component.type === 'file_upload') {
+                // Les documents peuvent être dans différentes structures
+                let documents: any = null;
+                
+                // Chercher dans différentes structures possibles
+                if (data.documents) {
+                  documents = data.documents;
+                } else if (data.user_data?.documents) {
+                  documents = data.user_data.documents;
+                } else if (data.document_images) {
+                  documents = data.document_images;
+                }
+
+                if (documents) {
+                  // Convertir les images base64 en format utilisable
+                  const restoredDocuments: Record<string, any> = {};
+                  
+                  Object.keys(documents).forEach((key) => {
+                    const doc = documents[key];
+                    if (typeof doc === 'object' && doc !== null) {
+                      // Si on a un fichier base64, créer une structure avec dir et file
+                      if (doc.file || doc.base64) {
+                        const base64Data = doc.file || doc.base64;
+                        restoredDocuments[key] = {
+                          dir: base64ToDataUri(base64Data), // Utiliser data URI pour l'affichage
+                          file: base64Data, // Garder le base64 pour l'envoi
+                          mrz: doc.mrz || '',
+                          templatePath: doc.templatePath || '',
+                        };
+                      } else {
+                        // Sinon, garder la structure originale
+                        restoredDocuments[key] = doc;
+                      }
+                    } else if (typeof doc === 'string') {
+                      // Si c'est directement une string base64
+                      restoredDocuments[key] = {
+                        dir: base64ToDataUri(doc),
+                        file: doc,
+                        mrz: '',
+                        templatePath: '',
+                      };
+                    }
+                  });
+
+                  if (Object.keys(restoredDocuments).length > 0) {
+                    restoredComponentData[component.id] = restoredDocuments;
+                  }
+                }
+              } else if (component.type === 'selfie') {
+                // Les selfies peuvent être dans sessionData.selfie_info
+                if (data.selfie_info) {
+                  const selfieData: Record<string, any> = {};
+                  const selfieInfo: any = data.selfie_info;
+                  
+                  // Si selfie_info contient une image
+                  if (selfieInfo.image) {
+                    const base64Image = selfieInfo.image;
+                    selfieData['front'] = {
+                      dir: base64ToDataUri(base64Image),
+                      file: base64Image,
+                    };
+                  }
+                  
+                  // Si on a plusieurs orientations
+                  if (selfieInfo.orientations) {
+                    Object.keys(selfieInfo.orientations).forEach((orientation) => {
+                      const img = selfieInfo.orientations[orientation];
+                      if (img) {
+                        selfieData[orientation] = {
+                          dir: base64ToDataUri(img),
+                          file: img,
+                        };
+                      }
+                    });
+                  }
+
+                  if (Object.keys(selfieData).length > 0) {
+                    restoredComponentData[component.id] = selfieData;
+                  }
+                }
+              } else if (component.type === 'country_selection') {
+                // Les données de sélection de pays peuvent être dans metadata
+                if (data.metadata || data.user_data) {
+                  restoredComponentData[component.id] = {
+                    ...(data.metadata || {}),
+                    ...(data.user_data || {}),
+                  };
+                }
+              } else if (component.type === 'location') {
+                // Les données de localisation peuvent être dans metadata
+                if (data.metadata?.location || data.user_data?.location) {
+                  restoredComponentData[component.id] = {
+                    ...(data.metadata?.location || {}),
+                    ...(data.user_data?.location || {}),
+                  };
+                }
+              }
+            });
+
+          // Mettre à jour l'état avec les données restaurées
+          if (Object.keys(restoredComponentData).length > 0) {
+            logger.log('Session data restored - components:', Object.keys(restoredComponentData));
+            logger.log('Session data restored - sample data:', truncateFields(restoredComponentData));
+            setState(prev => ({
+              ...prev,
+              componentData: {
+                ...prev.componentData,
+                ...restoredComponentData,
+              },
+            }));
+            logger.log('Component data updated in state');
+          } else {
+            logger.log('No component data to restore from session');
+          }
+        }
+      } catch (error) {
+        logger.error('Error loading session data:', truncateFields(error));
+        // Ne pas bloquer le flux si le chargement échoue
+      }
+    };
+
+    loadSessionData();
+  }, [existingSessionId, initialStep, state.session.isInitialized, state.session.session_id, templateWithReviewAndVerification.components, base64ToDataUri]);
+
   const mapComponentTypeToAction = useCallback((type: TemplateComponent['type']): string | null => {
     switch (type) {
       case 'id_card':
@@ -301,7 +568,18 @@ export const useTemplateKYCFlow = (
 
       const token = apiKey ? undefined : await authentification();
       console.log('token in initializeSession', { token, apiKey },);
-      const session = await kycService.newSession({token,apiKey});
+
+      // Check if we already have a session ID from URL params (passed via state or prop)
+      let session;
+      const existingSessionId = state.session.session_id; // This might be set from initial props if we add logic for it
+
+      if (existingSessionId && existingSessionId.length > 0) {
+        logger.log('Resuming existing session:', existingSessionId);
+        // Verify existence/validity if needed, for now trust the ID and just fetch/use it
+        session = { session_id: existingSessionId };
+      } else {
+        session = await kycService.newSession({ token, apiKey });
+      }
 
       // Align backend flow from step 0 with initialize_session
       try {
@@ -381,6 +659,20 @@ export const useTemplateKYCFlow = (
         // Welcome is valid once user has given consent (componentData is set when they click Get Started)
         return componentData && componentData.consentGiven !== false;
 
+      case 'email_verification':
+        return componentData && componentData.verified === true;
+
+      case 'phone_verification':
+        return componentData && componentData.verified === true;
+
+      case 'personal_information':
+        return componentData && Object.keys(componentData).length > 0;
+
+      case 'additional_documents':
+        // Optional by default in template config, but if required we should check based on config
+        // For now, return true or check length if present
+        return true;
+
       case 'review_submit':
         return true;
       default:
@@ -660,5 +952,6 @@ export const useTemplateKYCFlow = (
     isComplete,
     getLocalizedText,
     initializeSession,
+    env,
   };
 }; 

package/src/i18n/en/index.ts

@@ -15,6 +15,19 @@ export const en = {
     success: 'Success',
     warning: 'Warning',
     info: 'Information',
+    invalidCode: 'Invalid code',
+    resendCode: 'Resend code',
+    verify: 'Verify',
+    sendCode: 'Send code',
+    resend: 'Resend',
+    email: 'Email',
+    otp: 'OTP',
+    verificationCode: 'Verification code',
+    changeEmail: 'Change Email',
+    processing: "Processing",
+    codeResent: 'Code Resent',
+    codeResentMessage: 'Code resent to %{email}',
+    phone: 'Phone number with country code',
   },
 
   // KYC Flow
@@ -22,7 +35,22 @@ export const en = {
     title: 'Identity Verification',
     subtitle: 'Complete your identity verification to continue',
     step: 'Step %{current} of %{total}',
-    
+    enterCodeSent: "Enter code sent",
+
+    additionalDocs: {
+      title: 'Additional Documents',
+      add: "Press to select file",
+      subtitle: 'Upload additional documents to complete your identity verification',
+      uploadButton: 'Upload',
+      uploadButtonText: 'Upload',
+      uploadSubtext: 'Upload a clear photo of your document',
+      supportedFormats: 'Supported formats: JPG, PNG, PDF',
+      maxSize: 'Max file size: 10MB',
+      processing: 'Processing file...',
+      success: 'File uploaded successfully',
+      error: 'Failed to upload file. Please try again.'
+    },
+
     // Initialization
     initialization: {
       title: 'Welcome to Identity Verification',
@@ -98,6 +126,9 @@ export const en = {
       success: 'ID captured successfully',
       error: 'Failed to capture ID. Please try again.',
       captureTitle: '%{side} side of your government document',
+      continueOnPhone: 'Continue on Phone',
+      continueOnMobile: 'Continue on Mobile',
+      scanQrCode: 'Scan this QR code with your phone to continue the verification process.',
     },
 
     // Selfie Capture
@@ -214,7 +245,17 @@ export const en = {
     cameraError: 'Camera error. Please try again.',
     fileError: 'File error. Please try again.',
     timeoutError: 'Request timeout. Please try again.',
-    unknownError: 'An unknown error occurred. Please try again.'
+    unknownError: 'An unknown error occurred. Please try again.',
+    wrongCode: "Wrong code",
+    invalidCode: "Invalid code",
+    invalidEmail: "Invalid email",
+    invalidPhone: "Invalid phone",
+    invalidDate: "Invalid date",
+    minLength: "Min length",
+    maxLength: "Max length",
+    invalidFormat: "Invalid format",
+    fileTooLarge: "File too large",
+    fileTypeNotSupported: "File type not supported",
   },
 
   // Validation messages

package/src/i18n/fr/index.ts

@@ -15,6 +15,20 @@ export const fr = {
     success: 'Succès',
     warning: 'Avertissement',
     info: 'Information',
+    invalidCode: 'Code invalide',
+    resendCode: 'Renvoyer le code',
+    verify: 'Vérifier',
+    sendCode: 'Envoyer le code',
+    resend: 'Renvoyer',
+    email: 'Email',
+    otp: 'OTP',
+    verificationCode: 'Code de vérification',
+    changeEmail: 'Changer d\'email',
+    processing: "Traitement",
+    codeResent: 'Code Renvoyé',
+    codeResentMessage: 'Code renvoyé à %{email}',
+    phone: 'Numéro de téléphone avec code pays',
+
   },
 
   // KYC Flow
@@ -97,6 +111,9 @@ export const fr = {
       success: 'Document d\'identité capturé avec succès',
       error: 'Échec de la capture du document. Veuillez réessayer.',
       captureTitle: '%{side} de votre document d\'identité',
+      continueOnPhone: 'Continuer sur mobile',
+      continueOnMobile: 'Continuer sur mobile',
+      scanQrCode: 'Scannez ce code QR avec votre téléphone pour continuer la vérification.',
     },
 
     // Selfie Capture
@@ -213,7 +230,17 @@ export const fr = {
     cameraError: 'Erreur caméra. Veuillez réessayer.',
     fileError: 'Erreur fichier. Veuillez réessayer.',
     timeoutError: 'Délai d\'attente dépassé. Veuillez réessayer.',
-    unknownError: 'Une erreur inconnue s\'est produite. Veuillez réessayer.'
+    unknownError: 'Une erreur inconnue s\'est produite. Veuillez réessayer.',
+    wrongCode: "Wrong code",
+    invalidCode: "Invalid code",
+    invalidEmail: "Invalid email",
+    invalidPhone: "Invalid phone",
+    invalidDate: "Invalid date",
+    minLength: "Min length",
+    maxLength: "Max length",
+    invalidFormat: "Invalid format",
+    fileTooLarge: "File too large",
+    fileTypeNotSupported: "File type not supported",
   },
 
   validation: {

package/src/index.ts

@@ -4,6 +4,9 @@ export * from './TransfergratisSdk.types';
 // Export KYC types
 export * from './types/KYC.types';
 
+// Export Environment types
+export * from './types/env.types';
+
 
 export { TemplateKYCExample as LauchTransferGratisKYC } from './components/TemplateKYCExample';
 

package/src/modules/api/CardAuthentification.ts

@@ -1,14 +1,40 @@
 import kycService, { authentification, errorMessage, truncateFields } from "./KYCService";
 import { cropByObb } from "../../utils/cropByObb";
 import { GovernmentDocumentType, IBbox } from "../../types/KYC.types";
+import { KycEnvironment } from "../../types/env.types";
 import { logger } from "../../utils/logger";
 
-export async function frontVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }) {
+export async function frontVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
         console.log("Front verification START", JSON.stringify({ result }, null, 2));
         logger.log("Front verification", JSON.stringify({ result }, null, 2));
+        
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI verification for front document");
+            logger.log("SANDBOX mode: Returning mock front verification response");
+            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
+            const mockResponse = {
+                result: true,
+                detail: [{ confidence: 0.95 }],
+                card_obb: { x: 50, y: 50, width: 200, height: 200 },
+                bbox: mockBbox,
+                ...(result.regionMapping.authMethod.includes('MRZ') ? {
+                    mrz: {
+                        success: true,
+                        parsed_data: {
+                            status: 'success',
+                            document_type: result.selectedDocumentType,
+                            mrz_type: result.mrzType || 'TD1'
+                        }
+                    }
+                } : {})
+            };
+            return mockResponse;
+        }
+        
         const token = await authentification();
-        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '')
+        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '', env)
 
         if (!detected.result) {
             throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
@@ -36,7 +62,8 @@ export async function frontVerification(result: { path?: string, regionMapping:
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                })
+                },
+                env)
 
         }
 
@@ -47,10 +74,38 @@ export async function frontVerification(result: { path?: string, regionMapping:
     }
 }
 
-export async function backVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }) {
+export async function backVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
         if (!result.path) throw new Error('No path provided');
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
+        
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI verification for back document");
+            logger.log("SANDBOX mode: Returning mock back verification response");
+            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
+            
+            if (result.regionMapping.authMethod.includes('MRZ')) {
+                return {
+                    success: true,
+                    parsed_data: {
+                        status: 'success',
+                        document_type: result.selectedDocumentType,
+                        mrz_type: result.mrzType || 'TD1'
+                    },
+                    bbox: mockBbox,
+                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                };
+            } else if (result.regionMapping.authMethod.includes('2D_barcode')) {
+                return {
+                    barcode_data: 'SANDBOX_MOCK_BARCODE',
+                    bbox: mockBbox,
+                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                };
+            }
+            return { bbox: mockBbox };
+        }
+        
         const token = await authentification();
 
 
@@ -68,7 +123,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
                 let bbox: IBbox | undefined;
                 let croppedBase64: string | undefined;
 
@@ -82,7 +137,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
             } catch (mrzError: any) {
                 logger.log("MRZ échoué, tentative d'extraction barcode");
                 try {
-                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
                     return barcode;
                 } catch (barcodeError: any) {
                     throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
@@ -108,7 +163,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
@@ -123,7 +178,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
         if (result.regionMapping.authMethod.length > 0 && result.regionMapping.authMethod.includes('2D_barcode')) {
             try {
                 logger.log("Tentative d'extraction barcode");
-                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (barcode as any).card_obb);
@@ -145,10 +200,20 @@ export async function backVerification(result: { path?: string, regionMapping: {
  * @param result 
  * @returns 
  */
-export async function checkTemplateType(result: { path?: string, docType: string, docRegion: string, postfix: string }) {
+export async function checkTemplateType(result: { path?: string, docType: string, docRegion: string, postfix: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI template type check");
+            logger.log("SANDBOX mode: Returning mock template type response");
+            return {
+                template_path: `templates/${result.docType}_${result.docRegion}_${result.postfix}.jpg`,
+                card_obb: { x: 50, y: 50, width: 200, height: 200 }
+            };
+        }
+        
         const token = await authentification();
-        const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token });
+        const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token }, env);
 
         logger.log("templateType result", JSON.stringify(truncateFields(templateType), null, 2));
         return templateType;