assentify-sdk-react-native 0.0.1

package/src/AssentifyProvider.tsx

@@ -0,0 +1,189 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  DeviceEventEmitter,
+  LogBox,
+} from 'react-native';
+import React, {
+  createContext,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+} from 'react';
+import { merge } from 'lodash';
+import {
+  type PassportExtractedModel,
+  type FaceExtractedModel,
+  type IDExtractedModel,
+  type OtherExtractedModel,
+  type TemplatesByCountry,
+  FAILED_RESULT,
+  type IdentificationDocumentCapture,
+} from './types';
+import JsonParserPassport from './helpers/parsers/PassportParser';
+import JsonParserFaceMatch from './helpers/parsers/FaceMatchParser';
+import JsonParserIdCard from './helpers/parsers/IDCardParser';
+import JsonParserOtherID from './helpers/parsers/OtherIDParser';
+
+const { NativeAssentifySdk } = NativeModules;
+
+const AssentifyContext = createContext<undefined>(undefined);
+
+LogBox.ignoreAllLogs();
+const AssentifyProvider = () => {
+
+
+
+  useEffect(() => {
+    const emitter = new NativeEventEmitter(NativeAssentifySdk);
+
+    /// Initialize
+    const assentifySdkInit = emitter.addListener('AppResult', (result) => {
+    if(result?.assentifySdkInitSuccess!=null){
+      if (result?.assentifySdkInitSuccess) {
+            const templates = JSON.parse(result?.AssentifySdkHasTemplates ) as TemplatesByCountry[];
+             DeviceEventEmitter.emit('assentifySdkInit',{"status":true,"templates":templates});
+          }else{
+             DeviceEventEmitter.emit('assentifySdkInit',{"status":false});
+          }
+    }
+   });
+
+    /// onComplete
+    const onComplete = emitter.addListener('onComplete', (result) => {
+      if (result?.PassportDataModel) {
+        const response = JsonParserPassport(result?.PassportDataModel);
+        DeviceEventEmitter.emit('onCompletePassport',{"passportExtractedModel":response});
+      } else if (result?.FaceMatchDataModel) {
+        const response = JsonParserFaceMatch(result?.FaceMatchDataModel);
+       DeviceEventEmitter.emit('onCompleteFaceMatch',{"faceExtractedModel":response});
+      } else if (result?.IdDataModel) {
+        const response = JsonParserIdCard(result?.IdDataModel);
+       DeviceEventEmitter.emit('onCompleteIDCard',{"iDExtractedModel":response});
+      } else if (result?.OtherDataModel) {
+        const response = JsonParserOtherID(result?.OtherDataModel);
+        DeviceEventEmitter.emit('onCompleteOther',{"otherExtractedModel":response});
+      }
+    });
+
+   // General
+   const onSendEvent = emitter.addListener('onSend', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onSend" });
+   });
+
+   const onRetryEvent = emitter.addListener('onRetry', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onRetry" });
+   });
+
+   const onClipPreparationCompleteEvent = emitter.addListener('onClipPreparationComplete', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onClipPreparationComplete" });
+   });
+
+   const onStatusUpdatedEvent = emitter.addListener('onStatusUpdated', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onStatusUpdated" });
+   });
+
+   const onUpdatedEvent = emitter.addListener('onUpdated', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onUpdated" });
+   });
+
+   const onLivenessUpdateEvent = emitter.addListener('onLivenessUpdate', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onLivenessUpdate" });
+   });
+
+   const onCardDetectedEvent = emitter.addListener('onCardDetected', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onCardDetected" });
+   });
+
+   const onMrzExtractedEvent = emitter.addListener('onMrzExtracted', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onMrzExtracted" });
+   });
+
+   const onMrzDetectedEvent = emitter.addListener('onMrzDetected', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onMrzDetected" });
+   });
+
+   const onNoMrzDetectedEvent = emitter.addListener('onNoMrzDetected', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onNoMrzDetected" });
+   });
+
+   const onFaceDetectedEvent = emitter.addListener('onFaceDetected', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onFaceDetected" });
+   });
+
+   const onNoFaceDetectedEvent = emitter.addListener('onNoFaceDetected', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onNoFaceDetected" });
+   });
+
+   const onFaceExtractedEvent = emitter.addListener('onFaceExtracted', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onFaceExtracted" });
+   });
+
+   const onQualityCheckAvailableEvent = emitter.addListener('onQualityCheckAvailable', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onQualityCheckAvailable" });
+   });
+
+   const onDocumentCapturedEvent = emitter.addListener('onDocumentCaptured', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onDocumentCaptured" });
+   });
+
+   const onDocumentCroppedEvent = emitter.addListener('onDocumentCropped', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onDocumentCropped" });
+   });
+
+   const onUploadFailedEvent = emitter.addListener('onUploadFailed', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onUploadFailed" });
+   });
+
+   const onWrongTemplate = emitter.addListener('onWrongTemplate', (_result) => {
+     DeviceEventEmitter.emit('EventResult', { "eventName": "onWrongTemplate" });
+   });
+
+
+   /// SubmitResult
+     const submitResult = emitter.addListener('SubmitResult', (result) => {
+     if(result != null){
+      if (result?.success) {
+         DeviceEventEmitter.emit('SubmitDataEvents',{"Success":true});
+        }else{
+         DeviceEventEmitter.emit('SubmitDataEvents',{"Success":false});
+       }
+     }
+    });
+
+
+    return () => {
+      assentifySdkInit.remove();
+      onComplete.remove();
+      onSendEvent.remove();
+      onRetryEvent.remove();
+      onClipPreparationCompleteEvent.remove();
+      onStatusUpdatedEvent.remove();
+      onUpdatedEvent.remove();
+      onLivenessUpdateEvent.remove();
+      onCardDetectedEvent.remove();
+      onMrzExtractedEvent.remove();
+      onMrzDetectedEvent.remove();
+      onNoMrzDetectedEvent.remove();
+      onFaceDetectedEvent.remove();
+      onNoFaceDetectedEvent.remove();
+      onFaceExtractedEvent.remove();
+      onQualityCheckAvailableEvent.remove();
+      onDocumentCapturedEvent.remove();
+      onDocumentCroppedEvent.remove();
+      onUploadFailedEvent.remove();
+      onWrongTemplate.remove();
+      submitResult.remove();
+    };
+  }, [
+  ]);
+
+  return (
+    <AssentifyContext.Provider value={undefined}>
+    </AssentifyContext.Provider>
+  );
+};
+
+export { AssentifyProvider };
+

package/src/AssentifyWrapper.ts

@@ -0,0 +1,142 @@
+import { NativeModules, Platform, Alert, Linking } from 'react-native';
+import { request, PERMISSIONS, RESULTS } from 'react-native-permissions';
+import { type LanguageCode } from './Language';
+import { type KycDocumentDetails } from './types';
+
+const LINKING_ERROR =
+  `The package 'assentify-sdk-react-native-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const { NativeAssentifySdk } = NativeModules;
+
+const AssentifySdk = NativeModules.NativeAssentifySdk
+  ? NativeModules.NativeAssentifySdk
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+const AssentifyWrapper = {
+ /// Initialize
+  initialize: function (
+    apiKey: string,
+    tenantIdentifier: string,
+    instanceHash: string,
+    processMrz?: boolean,
+    storeCapturedDocument?: boolean,
+    performLivenessDocument?: boolean,
+    performLivenessFace?: boolean,
+    storeImageStream?: boolean,
+    saveCapturedVideoID?: boolean,
+    saveCapturedVideoFace?: boolean,
+    ENV_CustomColor?: string,
+    enableDetect?: boolean,
+    enableGuide?: boolean
+  ) {
+    request(
+      Platform.select({
+        android: PERMISSIONS.ANDROID.CAMERA,
+        ios: PERMISSIONS.IOS.CAMERA,
+        default: PERMISSIONS.ANDROID.CAMERA,
+      })
+    ).then(
+      (result) => {
+        if (result === RESULTS.GRANTED) {
+          AssentifySdk.initialize(
+            apiKey,
+            tenantIdentifier,
+            instanceHash,
+            processMrz ?? true,
+            storeCapturedDocument ?? true,
+            performLivenessDocument ?? false,
+            performLivenessFace ?? false,
+            storeImageStream ?? true,
+            saveCapturedVideoID ?? true,
+            saveCapturedVideoFace ?? true,
+            ENV_CustomColor ?? '#f5a103',
+            enableDetect ?? true,
+            enableGuide ?? true
+          );
+        } else if (
+          result === RESULTS.UNAVAILABLE ||
+          result === RESULTS.DENIED ||
+          result === RESULTS.BLOCKED
+        ) {
+          Alert.alert(
+            'Warning!',
+            'Please allow your camera permission in order to proceed further',
+            [
+              {
+                text: 'Open Settings',
+                onPress: () => {
+                  Linking.openSettings();
+                },
+              },
+              {
+                text: 'Cancel',
+                onPress: () => {},
+              },
+            ]
+          );
+        }
+      },
+      () => {
+        Alert.alert(
+          'Warning!',
+          'Please allow your camera permission in order to proceed further',
+          [
+            {
+              text: 'Open Settings',
+              onPress: () => {
+                Linking.openSettings();
+              },
+            },
+            {
+              text: 'Cancel',
+              onPress: () => {},
+            },
+          ]
+        );
+      }
+    );
+  },
+
+  /// Passport
+   startScanPassport: function (language: LanguageCode,){
+      AssentifySdk.startScanPassport(language);
+    },
+
+    /// Other
+    startScanOther: function (language: LanguageCode,){
+       AssentifySdk.startScanOtherIDPage(language);
+     },
+
+    /// ID
+    startScanIDCard: function (kycDocumentDetailsList: KycDocumentDetails[],language: LanguageCode,flippingCard: boolean){
+       AssentifySdk.startScanIDPage(JSON.stringify(kycDocumentDetailsList),language,flippingCard);
+    },
+
+    /// Face Match
+     startFaceMatch: function (imageUrl: String,showCountDown: boolean){
+           AssentifySdk.startFaceMatch(imageUrl,showCountDown);
+     },
+
+
+     /// Submit Data
+     submitData: function (dataMap:Record<string, string> ){
+          AssentifySdk.submitData(dataMap);
+      }
+
+
+
+
+
+};
+
+export default AssentifyWrapper;

package/src/Language.ts

@@ -0,0 +1,22 @@
+export const Language = {
+  English: "en",
+  Arabic: "ar",
+  Azerbaijani: "az",
+  Belarusian: "be",
+  Georgian: "ka",
+  Korean: "ko",
+  Latvian: "lv",
+  Lithuanian: "lt",
+  Punjabi: "pa",
+  Russian: "ru",
+  Sanskrit: "sa",
+  Sindhi: "sd",
+  Thai: "th",
+  Turkish: "tr",
+  Ukrainian: "uk",
+  Urdu: "ur",
+  Uyghur: "ug",
+  NON: "NON",
+};
+
+export type LanguageCode = typeof Language[keyof typeof Language];

package/src/helpers/index.ts

@@ -0,0 +1 @@
+

package/src/helpers/parsers/FaceMatchParser.ts

@@ -0,0 +1,28 @@
+import type {
+  FaceExtractedModel,
+  IdentificationDocumentCapture,
+} from '../../types';
+
+const JsonParserFaceMatch = (jsonString: string): FaceExtractedModel => {
+  const jsonObject = JSON.parse(jsonString ?? '');
+  const outputProperties = jsonObject?.outputProperties;
+  const extractedData = jsonObject?.extractedData;
+  const baseImageFace = jsonObject?.baseImageFace;
+  const secondImageFace = jsonObject?.secondImageFace;
+  const isLive = !!jsonObject?.isLive;
+  const identificationDocumentCapture =
+    jsonObject?.identificationDocumentCapture as IdentificationDocumentCapture;
+  const percentageMatch = Number(jsonObject?.percentageMatch) ?? 0;
+
+  return {
+    outputProperties,
+    baseImageFace,
+    secondImageFace,
+    percentageMatch,
+    extractedData,
+    identificationDocumentCapture,
+    isLive,
+  };
+};
+
+export default JsonParserFaceMatch;

package/src/helpers/parsers/IDCardParser.ts

@@ -0,0 +1,27 @@
+import type {
+  Faces,
+  IDExtractedModel,
+  IdentificationDocumentCapture,
+} from '../../types';
+
+const JsonParserIdCard = (jsonString: string): IDExtractedModel => {
+  const jsonObject = JSON.parse(jsonString ?? '');
+  const outputProperties = jsonObject?.outputProperties;
+  const transformedProperties = jsonObject?.transformedProperties;
+  const extractedData = jsonObject?.extractedData;
+  const imageUrl = jsonObject?.imageUrl;
+  const faces = jsonObject?.faces as Faces[];
+  const identificationDocumentCapture =
+    jsonObject?.identificationDocumentCapture as IdentificationDocumentCapture;
+
+  return {
+    outputProperties,
+    transformedProperties,
+    extractedData,
+    imageUrl,
+    faces,
+    identificationDocumentCapture,
+  };
+};
+
+export default JsonParserIdCard;

package/src/helpers/parsers/OtherIDParser.ts

@@ -0,0 +1,31 @@
+import type {
+  Faces,
+  IdentificationDocumentCapture,
+  OtherExtractedModel,
+} from '../../types';
+
+const JsonParserOtherID = (jsonString: string): OtherExtractedModel => {
+  const jsonObject = JSON.parse(jsonString ?? '');
+  const outputProperties = jsonObject?.outputProperties;
+  const transformedProperties = jsonObject?.transformedProperties;
+  const extractedData = jsonObject?.extractedData;
+  const additionalDetails = jsonObject?.additionalDetails;
+  const transformedDetails = jsonObject?.transformedDetails;
+  const imageUrl = jsonObject?.imageUrl;
+  const faces = jsonObject?.faces as Faces[];
+  const identificationDocumentCapture =
+    jsonObject?.identificationDocumentCapture as IdentificationDocumentCapture;
+
+  return {
+    outputProperties,
+    transformedProperties,
+    extractedData,
+    additionalDetails,
+    transformedDetails,
+    imageUrl,
+    faces,
+    identificationDocumentCapture,
+  };
+};
+
+export default JsonParserOtherID;

package/src/helpers/parsers/PassportParser.ts

@@ -0,0 +1,27 @@
+import type {
+  Faces,
+  IdentificationDocumentCapture,
+  PassportExtractedModel,
+} from '../../types';
+
+const JsonParserPassport = (jsonString: string): PassportExtractedModel => {
+  const jsonObject = JSON.parse(jsonString ?? '');
+  const outputProperties = jsonObject?.outputProperties;
+  const transformedProperties = jsonObject?.transformedProperties;
+  const extractedData = jsonObject?.extractedData;
+  const imageUrl = jsonObject?.imageUrl;
+  const identificationDocumentCapture =
+    jsonObject?.identificationDocumentCapture as IdentificationDocumentCapture;
+  const faces = jsonObject?.faces as Faces[];
+
+  return {
+    outputProperties,
+    transformedProperties,
+    extractedData,
+    imageUrl,
+    faces,
+    identificationDocumentCapture,
+  };
+};
+
+export default JsonParserPassport;

package/src/index.ts

@@ -0,0 +1,6 @@
+import AssentifyWrapper from './AssentifyWrapper';
+
+export * from './types';
+export * from './Language';
+export const Assentify = AssentifyWrapper;
+export * from './AssentifyProvider';