react-native-hyperkyc-sdk 0.1.3-alpha → 0.1.6-alpha2

package/android/build.gradle

@@ -57,7 +57,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"  // From node_modules
         
-    implementation('co.hyperverge:hyperkyc:0.0.1-alpha01@aar', {
+    implementation('co.hyperverge:hyperkyc:0.0.1-alpha02@aar', {
         transitive = true
     })
 }

package/android/src/main/java/com/reactnativehyperkycsdk/HyperkycConstants.java

@@ -0,0 +1,8 @@
+package com.reactnativehyperkycsdk;
+public class HyperkycConstants {
+
+    public final static  String COUNTRY_ID = "countryId";
+    public final static  String DOCUMENT_ID = "documentId";
+    public final static  String USE_FOR_FACE_MATCH = "useForFaceMatch";
+
+}

package/android/src/main/java/com/reactnativehyperkycsdk/HyperkycSdkModule.java

@@ -25,7 +25,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 
-import co.hyperverge.hyperkyc.HyperKYC;
+import co.hyperverge.hyperkyc.HyperKyc;
+import co.hyperverge.hyperkyc.data.models.DocFlowConfig;
 import co.hyperverge.hyperkyc.data.models.HyperKycConfig;
 import co.hyperverge.hyperkyc.data.models.HyperKycData;
 import co.hyperverge.hyperkyc.data.models.HyperKycFlow;
@@ -34,7 +35,7 @@ import co.hyperverge.hyperkyc.data.models.HyperKycResult;
 
 
 public class HyperkycSdkModule extends ReactContextBaseJavaModule implements ActivityEventListener {
-  public static final String NAME = "HyperkycSdk";
+  public static final String NAME = "Hyperkyc";
 
   private final ReactApplicationContext reactContext;
 
@@ -58,95 +59,106 @@ public class HyperkycSdkModule extends ReactContextBaseJavaModule implements Act
   }
 
 
-  @ReactMethod
-  public void launch(ReadableMap kycConfig, Callback resultCallback) {
-    callback = resultCallback;
-    ReadableArray array = kycConfig.getArray("workflow");
+    @ReactMethod
+    public void launch(ReadableMap kycConfig, Callback resultCallback ){
+        callback = resultCallback;
 
-    List<HyperKycFlow> workflow = processWorkFlow((array.toArrayList()));
+        ReactActivity currentActivity = (ReactActivity)getCurrentActivity();
+        List<HyperKycFlow> workflow = processWorkFlow(kycConfig.getString("workflow"));
+        String appId = kycConfig.hasKey("appId") ? kycConfig.getString("appId") : null;
+        String appKey = kycConfig.hasKey("appKey") ? kycConfig.getString("appKey") : null;
+        String transactionId = kycConfig.hasKey("transactionId") ? kycConfig.getString("transactionId") : null;
+        String defaultCountryId = kycConfig.hasKey("defaultCountryId") ? kycConfig.getString("defaultCountryId"): null;
+        String accessToken = kycConfig.hasKey("accessToken")? kycConfig.getString("accessToken") : null;
 
-    ReactActivity currentActivity = (ReactActivity) getCurrentActivity();
-    HyperKycConfig config = new HyperKycConfig(kycConfig.getString("appId"), kycConfig.getString("accessToken"), workflow, kycConfig.getString("transactionId"));
+        HyperKycConfig config = null;
+        if(accessToken != null){
+            config = new HyperKycConfig(accessToken, workflow, transactionId, defaultCountryId );
+        }else if(appId != null && appKey != null) {
 
-    contract = new HyperKYC.Contract();
-    Intent newIntent = contract.createIntent(currentActivity, config);
-    if (currentActivity != null)
-      currentActivity.startActivityIfNeeded(newIntent, HYPERKYC_REQUEST_CODE);
+            config = new HyperKycConfig(appId, appKey, workflow, transactionId, defaultCountryId);
+        }
+        contract = new HyperKyc.Contract();
+        Intent newIntent = contract.createIntent(currentActivity, config);
+        if(currentActivity != null)
+            currentActivity.startActivityIfNeeded(newIntent, HYPERKYC_REQUEST_CODE);
 
-  }
+    }
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+        if(requestCode == HYPERKYC_REQUEST_CODE){
+
+            HyperKycResult hyperKycResult = contract.parseResult(resultCode, data);
+            result = new WritableNativeMap();
+            parseKYCResult(hyperKycResult);
+        }
 
-  @Override
-  public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
-    if (requestCode == HYPERKYC_REQUEST_CODE) {
 
-      HyperKycResult hyperKycResult = contract.parseResult(resultCode, data);
-      result = new WritableNativeMap();
-      parseKYCResult(hyperKycResult);
     }
 
+    private void parseKYCResult(HyperKycResult hyperKycResult){
 
-  }
+        String errorMessage="";
+        HyperKycData hyperKycData = hyperKycResult.getData();
+        WritableMap resultMap = new WritableNativeMap();
+        resultMap.putString("result", hyperKycResult.getStatus().toString());
+        resultMap.putString("errorMessage", errorMessage);
+        try {
+            if (hyperKycData != null) {
 
-  private void parseKYCResult(HyperKycResult hyperKycResult) {
-
-    HyperKycData hyperKycData = hyperKycResult.getData();
-    WritableMap resultMap = new WritableNativeMap();
-    try {
-      if (hyperKycData != null) {
-
-        gson = new Gson();
-        String resultJSON = gson.toJson(hyperKycData);
-        JSONObject result = new JSONObject(resultJSON);
-        result.remove("config");
-        resultMap = HyperkycSdkUtils.convertJsonToMap(result);
-      }
-
-      String type = "";
-      String errorMessage = "";
-      if (hyperKycResult instanceof HyperKycResult.Success) {
-        type = "success";
-      }
-      if (hyperKycResult instanceof HyperKycResult.Failure) {
-        type = "failure";
-        errorMessage = ((HyperKycResult.Failure) hyperKycResult).getReason();
-      }
-      if (hyperKycResult instanceof HyperKycResult.Cancelled) {
-        type = "cancelled";
-      }
-
-      resultMap.putString("result", type);
-      resultMap.putString("errorMessage", errorMessage);
-      callback.invoke(resultMap);
-    } catch (Exception e) {
+                gson = new Gson();
+                String resultJSON = gson.toJson(hyperKycData);
+                JSONObject result = new JSONObject(resultJSON);
+                result.remove("config");
+                WritableMap hyperKycDataMap  = RNHyperKYCUtils.convertJsonToMap(result);
+                resultMap.putMap("hyperKycData", hyperKycDataMap);
+            }
 
-    }
 
-  }
 
 
-  private List<HyperKycFlow> processWorkFlow(ArrayList<Object> kycFlows) {
-    List<HyperKycFlow> workflows = new ArrayList<HyperKycFlow>();
 
-    for (Object flow : kycFlows) {
-      if (flow instanceof String) {
-        String flowStr = (String) flow;
-        switch (flowStr) {
-          case "document":
-            workflows.add(HyperKycFlow.DOCUMENT);
 
-          case "face":
-            workflows.add(HyperKycFlow.FACE);
+            callback.invoke(resultMap);
+        }catch (Exception e){
 
         }
-      }
+
     }
-    return workflows;
-  }
 
-  @Override
-  public void onNewIntent(Intent intent) {
-
-  }
 
+    private List<HyperKycFlow> processWorkFlow(String workflowArray){
+        List<HyperKycFlow> workflows = new ArrayList<>();
+        try {
+            JSONArray kycFlows = null;
+
+            kycFlows = new JSONArray(workflowArray);
+
+            for(int i = 0; i < kycFlows.length(); i++){
+                JSONObject kycFlow = kycFlows.getJSONObject(i);
+                if(kycFlow.has("type")){
+                    String flowStr = kycFlow.getString("type");
+                    switch (flowStr) {
+                        case "document":
+                            String countryId = kycFlow.has(RNHyperKYCConstants.COUNTRY_ID) ? kycFlow.getString(RNHyperKYCConstants.COUNTRY_ID): null;
+                            String documentId = kycFlow.has(RNHyperKYCConstants.DOCUMENT_ID) ? kycFlow.getString(RNHyperKYCConstants.DOCUMENT_ID): null;
+                            boolean useForFaceMatch = kycFlow.has(RNHyperKYCConstants.USE_FOR_FACE_MATCH)?  kycFlow.getBoolean(RNHyperKYCConstants.USE_FOR_FACE_MATCH): false;
+
+                            workflows.add(new HyperKycFlow.Document(new DocFlowConfig(useForFaceMatch, countryId, documentId )));
+                        case "face":
+                            workflows.add(new HyperKycFlow.Face());
+
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return workflows;
+    }
+    @Override
+    public void onNewIntent(Intent intent) {
 
-}
+    }
+}

package/ios/HyperkycSdk.m

@@ -2,7 +2,7 @@
 #import <Foundation/Foundation.h>
 #import <React/RCTUtils.h>
 
-@interface RCT_EXTERN_MODULE(HyperkycSdk, NSObject)
+@interface RCT_EXTERN_MODULE(Hyperkyc, NSObject)
 RCT_EXTERN_METHOD(launch: (NSDictionary*)config callback:(RCTResponseSenderBlock)callback)
 
 + (BOOL) requiresMainQueueSetup {

package/ios/HyperkycSdk.swift

@@ -3,171 +3,220 @@
 import Foundation
 import HyperKYC
 
-@objc(HyperkycSdk)
-class HyperkycSdk: NSObject  {
-  @objc  static func requiresMainQueueSetup() -> Bool {return true}
+@objc(Hyperkyc)
+class Hyperkyc: NSObject  {
+   @objc  static func requiresMainQueueSetup() -> Bool {return true}
   
-  @objc
-  func launchKYC(_config: NSDictionary, callback: @escaping RCTResponseSenderBlock) {
+  @objc(launch:callback:)
+  func launch(_config: NSDictionary, callback: @escaping RCTResponseSenderBlock) {
     let appId = _config["appId"] as? String
     let transactionId = _config["transactionId"] as? String
+    let appKey = _config["appKey"] as? String
     let accessToken = _config["accessToken"] as? String
-    let kycFlow = _config["workflow"] as? [String]
+    let kycFlow = _config["workflow"] as? String
+    let defaultCountryId = _config["defaultCountryId"] as? String ?? nil
     
-    let workFlow = processKYCFlowStates(flows: kycFlow!)
+    let hyperKycWorkflows = processKYCFlowStates(flows: kycFlow!)
     DispatchQueue.main.async {
-    let controller = RCTPresentedViewController()
-    
-    let hyperKYCConfig = HyperKycConfig(appId: appId!, accessToken: accessToken!, workFlow: workFlow,transactionId: transactionId!)
-    HyperKyc.launch(controller!, hyperKycConfig: hyperKYCConfig) { hyperKycResult in
-      // process the result hereDand send it back to JS
+      let controller = RCTPresentedViewController()
       
-      callback([processHyperKycResult(hyperKycResult: hyperKycResult)])
-    
+      if let accessTokenConfig = accessToken{
+        let hyperKYCConfig = HyperKycConfig(accessToken: accessTokenConfig, workFlow: hyperKycWorkflows, transactionId: transactionId!, defaultCountryId: defaultCountryId)
+        HyperKyc.launch(controller!, hyperKycConfig: hyperKYCConfig) { hyperKycResult in
+        
+        }
+      }
+      
+      if(appKey != nil && appId != nil){
+        let hyperKYCConfig = HyperKycConfig(appId: appId!, appKey: appKey!, workFlow: hyperKycWorkflows, transactionId: transactionId!, defaultCountryId: defaultCountryId)
+        
+        HyperKyc.launch(controller!, hyperKycConfig: hyperKYCConfig) { hyperKycResult in
+        
+         let result =  self.processHyperKycResult(hyperKycResult: hyperKycResult)
+          callback( [result])
+        }
+      }
       
     }
-    }
+  }
+  
+  
+  
+  
+  func processHyperKycResult(hyperKycResult: HyperKycResult) -> [String : Any]  {
     
-    func processHyperKycResult(hyperKycResult: HyperKycResult) -> [String: Any] {
-      let encoder = JSONEncoder()
-      encoder.outputFormatting = .prettyPrinted
-      // MARK: Add result, kycData, errorMessage
-      let resultEnum = hyperKycResult.result! as KYCResult
-      var resultEnumString = ""
-      var kycData = [
-        "selectedCountry" : "",
-        "selectedDocument" : "",
-
-      ] as [String: Any]
-      var errorMessage = ""
-      // MARK: Add resultEnum
-      resultEnumString = String(describing: resultEnum)
-      // MARK: Add kycData
-      if let hyperKycData = hyperKycResult.hyperKYCData {
-        if let country = hyperKycData.selectedCountry {
-          kycData["selectedCountry"] = country
-        }
-        if let document = hyperKycData.selectedDocument {
-          kycData["selectedDocument"] = document
-        }
-        // MARK: Add docData to kycData
+    let resultEnum = hyperKycResult.result! as KYCResult
+    var resultEnumString = ""
+    var kycData = [
+      "selectedCountryId" : "",
+      
+    ] as [String: Any]
+    var errorMessage = ""
+    
+    resultEnumString = String(describing: resultEnum)
+    
+    if let hyperKycData = hyperKycResult.hyperKYCData {
+      if let country = hyperKycData.selectedCountry {
+        kycData["selectedCountryId"] = country
+      }
+      
+      
+      var docResultList : [[String: Any]] = []
+      for docResult in hyperKycData.docResultList{
+        
         var docDataList: [[String: Any]] = []
-        for docData in hyperKycData.docDataList {
+        
+        for docData in docResult.docDataList {
           var docDataDictionary = [
             "side" : docData.side,
             "docImagePath" : docData.docImagePath,
             "action" : docData.action,
-          ]
-          if let responseHeaders = docData.responseHeaders {
-            do {
-              let headersData = try JSONSerialization.data(withJSONObject: responseHeaders , options: JSONSerialization.WritingOptions.prettyPrinted)
-              docDataDictionary["responseHeaders"] = String(data: headersData, encoding: String.Encoding.utf8)
-            }catch let parseError{
-              print("JSON Error DocData ResponseHeaders : \(parseError.localizedDescription)")
-            }
-          } else {
-            docDataDictionary["responseHeaders"] = "{}"
+          
+          ] as [String: Any]
+          if let responseHeaders = docData.responseHeaders  {
+            docDataDictionary["responseHeaders"] = responseHeaders
           }
           if let responseResult = docData.responseResult {
-            do {
-              let docDataResponseResult = try encoder.encode(responseResult)
-              docDataDictionary["responseResult"] = String(data: docDataResponseResult, encoding: .utf8)!
-            } catch let parseError {
-              print("JSON Error DocData ResponseResult : \(parseError.localizedDescription)")
-            }
-          } else {
-            docDataDictionary["responseResult"] = "{}"
+            docDataDictionary["responseResult"] = getResponseResultJsonString(docDataResponseResult: responseResult, faceDataResponseResult: nil, faceMatchDataResponseResult: nil )
           }
           docDataList.append(docDataDictionary as [String : Any])
         }
-        kycData["docDataList"] = docDataList
-        // MARK: Add faceData to kycData
-        if let faceData = hyperKycData.faceData {
-          var faceDataDictionary = [
-            "croppedFaceImagePath" : faceData.croppedFaceImagePath,
-            "fullFaceImagePath" : faceData.fullFaceImagePath,
-            "videoPath" : faceData.videoPath,
-            "action" : faceData.action,
-          ]
-          if let responseHeaders = faceData.responseHeaders {
-            do {
-              let headersData = try JSONSerialization.data(withJSONObject: responseHeaders , options: JSONSerialization.WritingOptions.prettyPrinted)
-              faceDataDictionary["responseHeaders"] = String(data: headersData, encoding: String.Encoding.utf8)
-            }catch let parseError{
-              print("JSON Error FaceData ResponseHeaders : \(parseError.localizedDescription)")
-            }
-          } else {
-            faceDataDictionary["responseHeaders"] = "{}"
-          }
-          if let responseResult = faceData.responseResult {
-            do {
-              let faceDataResponseResult = try encoder.encode(responseResult)
-              faceDataDictionary["responseResult"] = String(data: faceDataResponseResult, encoding: .utf8)!
-            } catch let parseError {
-              print("JSON Error FaceData ResponseResult : \(parseError.localizedDescription)")
-            }
-          } else {
-            faceDataDictionary["responseResult"] = "{}"
-          }
-          kycData["faceData"] = faceDataDictionary
+        var docResultDictionary = [
+          "tag" : docResult.tag,
+          "documentId": docResult.documentId,
+          "docDataList": docDataList
+        ] as [String : Any]
+        
+        docResultList.append(docResultDictionary as [String: Any])
+      }
+      
+      kycData["docResultList"] = docResultList
+      
+      // Process face data
+      if let faceData = hyperKycData.faceData {
+        var faceDataDictionary = [
+          "croppedFaceImagePath" : faceData.croppedFaceImagePath,
+          "fullFaceImagePath" : faceData.fullFaceImagePath,
+          "videoPath" : faceData.videoPath,
+          "action" : faceData.action,
+        ] as [String:Any]
+        if let responseHeaders = faceData.responseHeaders  {
+          faceDataDictionary["responseHeaders"] = responseHeaders
+        }
+        if let responseResult = faceData.responseResult {
+          faceDataDictionary["responseResult"] = getResponseResultJsonString(docDataResponseResult: nil, faceDataResponseResult: responseResult, faceMatchDataResponseResult: nil )
         }
-        // MARK: Add faceMatchData to kycData
-        if let faceMatchData = hyperKycData.faceMatchData {
+        
+        
+        kycData["faceData"] = faceDataDictionary
+        
+      }
+        
+      //Process face match data
+        var faceMatchDataResultList : [[String: Any]] = []
+        for faceMatchDataResult in hyperKycData.faceMatchDataResultList{
+    
           var faceMatchDataDictionary = [
-            "action" : faceMatchData.action,
-          ]
-          if let responseHeaders = faceMatchData.responseHeaders {
-            do {
-              let headersData = try JSONSerialization.data(withJSONObject: responseHeaders , options: JSONSerialization.WritingOptions.prettyPrinted)
-              faceMatchDataDictionary["responseHeaders"] = String(data: headersData, encoding: String.Encoding.utf8)
-            }catch let parseError{
-              print("JSON Error FaceMatchData ResponseHeaders : \(parseError.localizedDescription)")
-            }
-          } else {
-            faceMatchDataDictionary["responseHeaders"] = "{}"
+            "action" : faceMatchDataResult.facematchData.action,
+          ] as [String:Any]
+          if let responseHeaders = faceMatchDataResult.facematchData.responseHeaders  {
+            faceMatchDataDictionary["responseHeaders"] = responseHeaders
           }
-          if let responseResult = faceMatchData.responseResult {
-            do {
-              let faceMatchDataResponseResult = try encoder.encode(responseResult)
-              faceMatchDataDictionary["responseResult"] = String(data: faceMatchDataResponseResult, encoding: .utf8)!
-            } catch let parseError {
-              print("JSON Error FaceMatchData ResponseResult : \(parseError.localizedDescription)")
-            }
-          } else {
-            faceMatchDataDictionary["responseResult"] = "{}"
+          if let responseResult = faceMatchDataResult.facematchData.responseResult {
+            faceMatchDataDictionary["responseResult"] = getResponseResultJsonString(docDataResponseResult: nil, faceDataResponseResult: nil, faceMatchDataResponseResult: responseResult)
           }
-          kycData["faceMatchData"] = faceMatchDataDictionary
+          var faceMatchResultDictionary = [
+            "tag": faceMatchDataResult.tag,
+            "documentId":faceMatchDataResult.documentId,
+            "faceMatchData":faceMatchDataDictionary
+          ] as [String: Any]
+          faceMatchDataResultList.append(faceMatchResultDictionary)
         }
-      }
-      // MARK: Add errorMessage
-      if let errorMsg = hyperKycResult.errorMessage {
-        errorMessage = errorMsg
-      }
-      // MARK: Create the final result map which will include resultEnum, kycData and errorMessage
-      let resultMap = [
-        "result" : resultEnumString,
-        "hyperKYCData" : kycData,
-        "errorMessage" : errorMessage,
-      ] as [String : Any]
-      return resultMap
-    }
+       
+      kycData["faceMatchDataResultList"] = faceMatchDataResultList
+        
+                  if let errorMsg = hyperKycResult.errorMessage {
+                    errorMessage = errorMsg
+                  }
+        
+                  let resultMap = [
+                    "result" : resultEnumString,
+                    "hyperKycData" : kycData,
+                    "errorMessage" : errorMessage,
+                  ] as [String : Any]
+                  return resultMap
+        
+    
     
-    func processKYCFlowStates(flows : [String])  -> [HyperKycFlow]{
-      var workflows =  [HyperKycFlow]()
-      flows.forEach { flow in
-        switch (flow){
-        case "document":
-          workflows.append(.document)
-        case "face":
-          workflows.append(.face)
-        default:
-          break
-     
-          
-      }
     }
-    return workflows
+    return [:]
+  }
+      
+
+//
+  func getResponseResultJsonString(docDataResponseResult: DocCaptureApiDetail?, faceDataResponseResult: FaceCaptureApiDetail?, faceMatchDataResponseResult: FaceMatchApiDetail?) -> [String:Any] {
+  let encoder = JSONEncoder()
+  
+  do {
+    if let responseResult = docDataResponseResult {
+      let responseResultData = try encoder.encode(responseResult)
+      return try JSONSerialization.jsonObject(with: responseResultData, options: []) as? [String:Any] ?? [:]
+    } else if let responseResult = faceDataResponseResult {
+      let responseResultData = try encoder.encode(responseResult)
+      return try JSONSerialization.jsonObject(with: responseResultData, options: []) as? [String:Any] ?? [:]
+    } else if let responseResult = faceMatchDataResponseResult {
+      let responseResultData = try encoder.encode(responseResult)
+      return try JSONSerialization.jsonObject(with: responseResultData, options: []) as? [String:Any] ?? [:]
+    } else {
+      return [:]
     }
+  } catch let parseError {
+    print("JSON Error DocData ResponseResult : \(parseError.localizedDescription)")
+    return [:]
   }
+    return [:]
+}
+
+
+
+func processKYCFlowStates(flows : String) -> [HyperKycFlow] {
+  var hyperKycFlows = [HyperKycFlow]()
+  let workflows = convertToDictionary(json: flows)
   
+  workflows?.forEach({ (value: Any) in
+    let valueObj = (value as! [String:Any])
+    switch(valueObj["type"] as! String){
+    case "document":
+      let useForFaceMatch = valueObj["useForFaceMatch"] as? Bool ?? false
+      let countryId = valueObj["countryId"] as? String ?? nil
+      let documentId = valueObj["documentId"] as? String ?? nil
+      hyperKycFlows.append(HyperKycFlow.document(config: DocFlowConfig(useForFaceMatch: useForFaceMatch, countryId: countryId, documentId: documentId)))
+    case "face":
+      hyperKycFlows.append(HyperKycFlow.face())
+    default:
+      print("Case not handled")
+    }
+  })
+  
+  return hyperKycFlows
+  
+}
+
+func convertToDictionary(json: String) -> [Any]? {
+  if let data = json.data(using: .utf8) {
+    do {
+      return try JSONSerialization.jsonObject(with: data, options: []) as? [Any]
+    } catch {
+      print(error.localizedDescription)
+    }
+  }
+  return nil
 }
+    
+  }
+      
+
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-hyperkyc-sdk",
-  "version": "0.1.3-alpha",
+  "version": "0.1.6-alpha2",
   "description": "React Native wrapper for HyperKYC SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",