@test-web/react-native-sdk 1.0.0 → 2.0.0

package/src/apis/index.ts

@@ -1,32 +1,353 @@
 import { IDMConf } from '../types/IDMConf';
+import { getBaseURL } from '../config/apiConfig';
+import { base64Encode } from '../utils/base64';
+import getUserData from '../services/getUserData';
 
-export async function getUserData(): Promise<any> {
-  // Static implementation - replace with actual API call
-  return {
-    permissionGranted: true,
-  };
+/**
+ * Get user data including location, device info, and permissions
+ */
+export async function getUserDataAPI(): Promise<any> {
+  return await getUserData();
 }
 
+/**
+ * Generate access token using client credentials
+ */
 export async function generateAccessToken(conf: IDMConf): Promise<string> {
-  // Static implementation - replace with actual API call
-  return 'static-access-token';
+  const { clientID, clientSecret, environment } = conf;
+
+  if (!clientID || !clientSecret) {
+    throw new Error('clientID and clientSecret are required.');
+  }
+
+  const URL = `${getBaseURL(environment)}/token`;
+  const encodedCredentials = base64Encode(`${clientID}:${clientSecret}`);
+  const params = new URLSearchParams({
+    grant_type: 'client_credentials',
+    scope: 'idmvalidate',
+  });
+
+  try {
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Authorization: `Basic ${encodedCredentials}`,
+      },
+      body: params.toString(),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Failed to generate access token: ${response.status} ${response.statusText} - ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+    return data.access_token;
+  } catch (error: any) {
+    console.error('Error generating access token:', error);
+    throw new Error(`Failed to generate access token: ${error.message}`);
+  }
 }
 
+/**
+ * Generate verification request
+ */
 export async function generateRequest(conf: IDMConf, requestData: any): Promise<any> {
-  // Static implementation - replace with actual API call
-  return {
-    verificationCode: 'static-verification-code',
-  };
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/verify`;
+
+  try {
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+      body: JSON.stringify(requestData),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `API call failed: ${response.status} ${response.statusText} - ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+    const verificationCode = data.verificationLink?.split('/').pop() || null;
+    return {
+      ...data,
+      verificationCode,
+    };
+  } catch (error: any) {
+    console.error('generateRequest error:', error);
+    throw new Error(`generateRequest failed: ${error.message}`);
+  }
 }
 
+/**
+ * Get configuration for verification
+ */
 export async function getConfiguration(conf: IDMConf, verificationCode: string): Promise<any> {
-  // Static implementation - replace with actual API call
-  return {
-    // Your configuration data
-  };
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/verify/configuration/${verificationCode}`;
+
+  try {
+    const response = await fetch(URL, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `API call failed: ${response.status} ${response.statusText} - ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('getConfiguration error:', error);
+    throw new Error(`getConfiguration failed: ${error.message}`);
+  }
 }
 
+/**
+ * Get list of countries with metadata
+ */
 export async function getCountries(conf: IDMConf): Promise<any> {
-  // Static implementation - replace with actual API call
-  return [];
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/metadata/country/list/${conf.verificationCode}`;
+
+  try {
+    const response = await fetch(URL, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Failed to load countries: ${response.status} ${response.statusText} - ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('getCountries error:', error);
+    throw new Error(`getCountries failed: ${error.message}`);
+  }
+}
+
+/**
+ * Capture document front image
+ */
+export async function captureDocumentFront(
+  conf: IDMConf,
+  requestData: {
+    latitude: string;
+    longitude: string;
+    token: string;
+    persistLoc: string;
+    metadataIndex: string;
+    file: string;
+  }
+): Promise<any> {
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/ocr/base64/document`;
+
+  try {
+    const formData = new FormData();
+    formData.append('file', requestData.file);
+    formData.append('token', requestData.token);
+    formData.append('latitude', requestData.latitude);
+    formData.append('longitude', requestData.longitude);
+    formData.append('persistLoc', 'false');
+    formData.append('metadataIndex', requestData.metadataIndex);
+
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+      body: formData,
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('captureDocumentFront error:', error);
+    throw new Error(`captureDocumentFront failed: ${error.message}`);
+  }
+}
+
+/**
+ * Capture document back image
+ */
+export async function captureDocumentBack(
+  conf: IDMConf,
+  requestData: {
+    token: string;
+    file: string;
+  }
+): Promise<any> {
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/ocr/document/text/back`;
+
+  try {
+    const formData = new FormData();
+    formData.append('file', requestData.file);
+    formData.append('token', requestData.token);
+
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+      body: formData,
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('captureDocumentBack error:', error);
+    throw new Error(`captureDocumentBack failed: ${error.message}`);
+  }
+}
+
+/**
+ * Capture barcode data
+ */
+export async function captureBarcode(
+  conf: IDMConf,
+  requestData: {
+    token: string;
+    text: string;
+  }
+): Promise<any> {
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/ocr/base64/barcode/text`;
+
+  try {
+    const formData = new FormData();
+    formData.append('text', requestData.text);
+    formData.append('token', requestData.token);
+
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+      body: formData,
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('captureBarcode error:', error);
+    throw new Error(`captureBarcode failed: ${error.message}`);
+  }
+}
+
+/**
+ * Capture MRZ data
+ */
+export async function captureMRZ(
+  conf: IDMConf,
+  requestData: {
+    token: string;
+    code: string;
+    engine: string;
+  }
+): Promise<any> {
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/ocr/mrz/text`;
+
+  try {
+    const formData = new FormData();
+    formData.append('token', requestData.token);
+    formData.append('code', requestData.code);
+    formData.append('engine', requestData.engine);
+
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+      body: formData,
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('captureMRZ error:', error);
+    throw new Error(`captureMRZ failed: ${error.message}`);
+  }
+}
+
+/**
+ * Complete verification process
+ */
+export async function completeVerification(conf: IDMConf): Promise<any> {
+  if (!conf.accessToken) {
+    throw new Error('Access token is missing');
+  }
+
+  const URL = `${getBaseURL(conf.environment)}/verify/complete/${conf.verificationCode}`;
+
+  try {
+    const response = await fetch(URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${conf.accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `API call failed: ${response.status} ${response.statusText} - ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error('completeVerification error:', error);
+    throw new Error(`completeVerification failed: ${error.message}`);
+  }
 }
+

package/src/components/common/Loader.tsx

@@ -1,13 +1,22 @@
 import React, { memo } from 'react';
-import { View, ActivityIndicator, StyleSheet } from 'react-native';
+import { View, ActivityIndicator, StyleSheet, Text } from 'react-native';
 import { useTheme } from '../../context/ThemeContext';
 
-function Loader() {
+interface LoaderProps {
+  message?: string;
+}
+
+function Loader({ message }: LoaderProps) {
   const { theme } = useTheme();
 
   return (
     <View style={[styles.container, { backgroundColor: theme.colors.background }]}>
       <ActivityIndicator size="large" color={theme.colors.primary} />
+      {message && (
+        <Text style={[styles.message, { color: theme.colors.text }]}>
+          {message}
+        </Text>
+      )}
     </View>
   );
 }
@@ -18,6 +27,11 @@ const styles = StyleSheet.create({
     justifyContent: 'center',
     alignItems: 'center',
   },
+  message: {
+    marginTop: 16,
+    fontSize: 16,
+    textAlign: 'center',
+  },
 });
 
 export default memo(Loader);

package/src/config/apiConfig.ts

@@ -0,0 +1,6 @@
+export const SANDBOX_BASE_URL = 'https://sandbox-api.idmerit.com';
+export const PRODUCTION_BASE_URL = 'https://api.idmerit.com';
+
+export const getBaseURL = (environment: 'sandbox' | 'production'): string => {
+  return environment?.toLowerCase() === 'sandbox' ? SANDBOX_BASE_URL : PRODUCTION_BASE_URL;
+};

package/src/index.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useMemo, useCallback } from 'react';
+import React, { useState, useMemo, useCallback, useEffect } from 'react';
 import { NavigationContainer, useNavigationContainerRef } from '@react-navigation/native';
 import { createNativeStackNavigator } from '@react-navigation/native-stack';
 import BarcodeCapture from './screens/BarcodeCapture';
@@ -21,10 +21,18 @@ import MrzAdvice from './screens/MrzAdvice';
 import { ThemeProvider } from './context/ThemeContext';
 import { themes } from './context/themes';
 import { IDMConf } from './types/IDMConf';
-import { IDMProvider } from './context/IDMConfigurationContext';
+import { IDMProvider, useIDM } from './context/IDMConfigurationContext';
 import { KeyboardProvider, useKeyboard } from './context/KeyboardContext';
 import Footer from './components/common/Footer';
 import Header from './components/common/Header';
+import Loader from './components/common/Loader';
+import {
+  getUserDataAPI,
+  generateAccessToken,
+  generateRequest,
+  getConfiguration,
+  getCountries,
+} from './apis';
 
 const Stack = createNativeStackNavigator();
 
@@ -41,23 +49,26 @@ const HIDE_HEADER_FOOTER_ROUTES = new Set([
 ]);
 
 interface IDMScanProps {
-  idmConf?: IDMConf;
+  idmConf: IDMConf;
 }
 
-export default function IDMScan({ idmConf = {} }: IDMScanProps) {
+export default function IDMScan({ idmConf }: IDMScanProps) {
   return (
     <IDMProvider initialConf={idmConf}>
       <KeyboardProvider>
-        <IDMScanContent idmConf={idmConf} />
+        <IDMScanContent />
       </KeyboardProvider>
     </IDMProvider>
   );
 }
 
-function IDMScanContent({ idmConf }: { idmConf: IDMConf }) {
+function IDMScanContent() {
   const { isKeyboardVisible } = useKeyboard();
+  const { idmConf, setIDMConf } = useIDM();
   const navigationRef = useNavigationContainerRef();
   const [currentRoute, setCurrentRoute] = useState<string | undefined>();
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
 
   // Memoize theme calculation
   const theme = useMemo(
@@ -80,11 +91,116 @@ function IDMScanContent({ idmConf }: { idmConf: IDMConf }) {
     setCurrentRoute(route?.name);
   }, [navigationRef]);
 
+  // Dynamic initialization flow
+  useEffect(() => {
+    const initializeSDK = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+
+        // Step 1: Get user data if not provided
+        if (!idmConf.userDetails) {
+          console.log('Fetching user data...');
+          const userData = await getUserDataAPI();
+          const updatedConf = { ...idmConf, userDetails: userData };
+          setIDMConf(updatedConf);
+
+          // Step 2: Generate access token if not provided
+          if (!idmConf.accessToken) {
+            console.log('Generating access token...');
+            const token = await generateAccessToken(updatedConf);
+            const confWithToken = { ...updatedConf, accessToken: token };
+            setIDMConf(confWithToken);
+
+            // Step 3: Generate verification request
+            console.log('Generating verification request...');
+            const requestResult = await generateRequest(confWithToken, idmConf.requestData);
+            const confWithVerifyCode = {
+              ...confWithToken,
+              verificationCode: requestResult.verificationCode,
+            };
+            setIDMConf(confWithVerifyCode);
+
+            // Step 4: Get configuration
+            console.log('Fetching configuration...');
+            const fetchedConfig = await getConfiguration(
+              confWithVerifyCode,
+              requestResult.verificationCode
+            );
+            setIDMConf({
+              ...confWithVerifyCode,
+              configuration: fetchedConfig,
+            });
+          }
+        }
+      } catch (err: any) {
+        console.error('SDK initialization error:', err);
+        setError(err.message || 'Failed to initialize SDK');
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    initializeSDK();
+  }, []); // Run once on mount
+
+  // Fetch countries when access token and verification code are available
+  useEffect(() => {
+    const fetchCountriesData = async () => {
+      if (idmConf.accessToken && idmConf.verificationCode && !idmConf.countryDetails) {
+        try {
+          console.log('Fetching countries...');
+          const response = await getCountries(idmConf);
+          const countriesArray = Array.isArray(response) ? response : response?.data || [];
+          
+          const mapped = countriesArray.map((singleCountry: any) => ({
+            label: singleCountry.country,
+            value: singleCountry.index,
+            metadata: singleCountry.metadata || [],
+          }));
+
+          setIDMConf({
+            ...idmConf,
+            countryDetails: mapped,
+          });
+        } catch (err: any) {
+          console.error('Error fetching countries:', err);
+        }
+      }
+    };
+
+    fetchCountriesData();
+  }, [idmConf.accessToken, idmConf.verificationCode]);
+
+  // Determine initial route based on permissions
+  const initialRouteName = useMemo(() => {
+    if (idmConf.userDetails?.permissionGranted) {
+      return 'VerifyIdentity';
+    }
+    return 'LocationPermission';
+  }, [idmConf.userDetails?.permissionGranted]);
+
+  if (loading) {
+    return (
+      <ThemeProvider theme={theme}>
+        <Loader />
+      </ThemeProvider>
+    );
+  }
+
+  if (error) {
+    return (
+      <ThemeProvider theme={theme}>
+        <Loader message={`Error: ${error}`} />
+      </ThemeProvider>
+    );
+  }
+
   return (
     <ThemeProvider theme={theme}>
       {shouldShowHeaderFooter && <Header />}
       <NavigationContainer ref={navigationRef} onStateChange={handleStateChange}>
-        <Stack.Navigator initialRouteName="VerifyIdentity" screenOptions={SCREEN_OPTIONS}>
+        <Stack.Navigator initialRouteName={initialRouteName} screenOptions={SCREEN_OPTIONS}>
           <Stack.Screen name="VerifyIdentity" component={VerifyIdentity} />
           <Stack.Screen name="SelfieAdvice" component={SelfieAdvice} />
           <Stack.Screen name="SelfieCapture" component={SelfieCapture} />