react-native-persona 2.2.30 → 2.3.0

package/CHANGELOG.md

@@ -7,53 +7,84 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+## [v2.3.0] - 2023-02-16
+
+### Added
+
+- Added optional support to receive data collected during inquiry flow on completion.
+
+### Changed
+
+- Upgrade to iOS Inquiry SDK 2.6.2
+- Upgrade to Android Inquiry SDK 2.3.6
+
 ## [v2.2.30] - 2023-01-25
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.5.11
 - Upgrade to Android Inquiry SDK 2.3.5
 
 ## [v2.2.29] - 2022-12-15
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.5.4
 - Upgrade to Android Inquiry SDK 2.3.0
 
 ## [v2.2.28] - 2022-11-30
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.5.3
 - Upgrade to Android Inquiry SDK 2.2.45
 
 ## [v2.2.27] - 2022-11-16
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.5.0
 - Upgrade to Android Inquiry SDK 2.2.43
 
 ## [v2.2.26] - 2022-10-20
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.4.3
 - Upgrade to Android Inquiry SDK 2.2.41
 
 ## [v2.2.25] - 2022-10-06
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.4.2
 - Upgrade to Android Inquiry SDK 2.2.40
 
 ## [v2.2.24] - 2022-09-22
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.4.0
 - Upgrade to Android Inquiry SDK 2.2.37
 
 ## [v2.2.23] - 2022-09-07
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.3.9
 - Upgrade to Android Inquiry SDK 2.2.36
 
 ## [v2.2.22] - 2022-08-25
 
+### Changed
+
 - Upgrade to iOS Inquiry SDK 2.3.6
 - Upgrade to Android Inquiry SDK 2.2.31
 
 ## [v2.2.21] - 2022-08-18
 
+### Fixed
+
 - Fixed a bug where the inquiry flow failed to present on iOS
 
 ## [v2.2.20] - 2022-08-15

package/RNPersonaInquiry2.podspec

@@ -22,7 +22,7 @@ Pod::Spec.new do |s|
   s.requires_arc  = true
 
   s.dependency 'React-Core'
-  s.dependency 'PersonaInquirySDK2', '2.5.11'
+  s.dependency 'PersonaInquirySDK2', '2.6.2'
 
   s.static_framework = true
 end

package/android/build.gradle

@@ -66,5 +66,5 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
 
-    implementation 'com.withpersona.sdk2:inquiry:2.3.5'
+    implementation 'com.withpersona.sdk2:inquiry:2.3.6'
 }

package/android/src/main/java/com/withpersona/sdk2/reactnative/PersonaInquiryModule2.java

@@ -2,13 +2,17 @@ package com.withpersona.sdk2.reactnative;
 
 import android.app.Activity;
 import android.content.Intent;
+
 import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.withpersona.sdk2.inquiry.Environment;
@@ -18,10 +22,18 @@ import com.withpersona.sdk2.inquiry.InquiryBuilder;
 import com.withpersona.sdk2.inquiry.InquiryField;
 import com.withpersona.sdk2.inquiry.InquiryResponse;
 import com.withpersona.sdk2.inquiry.InquiryTemplateBuilder;
+import com.withpersona.sdk2.inquiry.types.collected_data.CollectedData;
+import com.withpersona.sdk2.inquiry.types.collected_data.DocumentFile;
+import com.withpersona.sdk2.inquiry.types.collected_data.GovernmentIdCapture;
+import com.withpersona.sdk2.inquiry.types.collected_data.SelfieCapture;
+import com.withpersona.sdk2.inquiry.types.collected_data.StepData;
+
+import org.jetbrains.annotations.NotNull;
+
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import org.jetbrains.annotations.NotNull;
 
 public class PersonaInquiryModule2 extends ReactContextBaseJavaModule
     implements ActivityEventListener {
@@ -35,6 +47,7 @@ public class PersonaInquiryModule2 extends ReactContextBaseJavaModule
   private static final String ENVIRONMENT = "environment";
   private static final String FIELDS = "fields";
   private static final String FIELD_ADDITIONAL_FIELDS = "additionalFields";
+  private static final String RETURN_COLLECTED_DATA = "returnCollectedData";
 
   private final ReactApplicationContext reactContext;
 
@@ -92,6 +105,8 @@ public class PersonaInquiryModule2 extends ReactContextBaseJavaModule
         }
         params.putMap("fields", fields);
 
+        params.putMap("collectedData", collectedDataToMap(complete.getCollectedData()));
+
         jsModule.emit("onComplete", params);
       } else if (response instanceof InquiryResponse.Cancel) {
         InquiryResponse.Cancel cancel = (InquiryResponse.Cancel) response;
@@ -109,6 +124,137 @@ public class PersonaInquiryModule2 extends ReactContextBaseJavaModule
     }
   }
 
+  @Nullable
+  private ReadableMap collectedDataToMap(@Nullable CollectedData collectedData) {
+    if (collectedData == null) {
+      return null;
+    }
+
+    WritableMap collectedDataMap = Arguments.createMap();
+
+    WritableArray stepDataMap = Arguments.createArray();
+    for (StepData stepDatum : collectedData.getStepData()) {
+      WritableMap stepDatumMap = Arguments.createMap();
+      stepDatumMap.putString("stepName", stepDatum.getStepName());
+
+      if (stepDatum instanceof StepData.DocumentStepData) {
+        WritableArray documentsArr = Arguments.createArray();
+
+        for (DocumentFile document : ((StepData.DocumentStepData) stepDatum).getDocuments()) {
+          WritableMap documentMap = Arguments.createMap();
+          documentMap.putString("absoluteFilePath", document.getData().getAbsolutePath());
+          documentsArr.pushMap(documentMap);
+        }
+
+        stepDatumMap.putArray("documents", documentsArr);
+        stepDatumMap.putString("type", "DocumentStepData");
+      } else if (stepDatum instanceof StepData.GovernmentIdStepData) {
+        WritableArray capturesArr = Arguments.createArray();
+
+        for (GovernmentIdCapture capture : ((StepData.GovernmentIdStepData) stepDatum).getCaptures()) {
+          WritableMap captureMap = Arguments.createMap();
+          captureMap.putString("idClass", capture.getIdClass());
+          captureMap.putString("captureMethod", capture.getCaptureMethod().name());
+          captureMap.putString("side", capture.getSide().name());
+
+          WritableArray framesArr = Arguments.createArray();
+          for (GovernmentIdCapture.Frame frame : capture.getFrames()) {
+            WritableMap frameMap = Arguments.createMap();
+            frameMap.putString("absoluteFilePath", frame.getData().getAbsolutePath());
+
+            framesArr.pushMap(frameMap);
+          }
+          captureMap.putArray("frames", framesArr);
+
+          capturesArr.pushMap(captureMap);
+        }
+
+        stepDatumMap.putArray("captures", capturesArr);
+        stepDatumMap.putString("type", "GovernmentIdStepData");
+      } else if (stepDatum instanceof StepData.SelfieStepData) {
+        StepData.SelfieStepData selfieStepData = (StepData.SelfieStepData) stepDatum;
+        ReadableMap centerCaptureMap = selfieCaptureToMap(selfieStepData.getCenterCapture());
+        ReadableMap leftCaptureMap = selfieCaptureToMap(selfieStepData.getLeftCapture());
+        ReadableMap rightCaptureMap = selfieCaptureToMap(selfieStepData.getRightCapture());
+
+        stepDatumMap.putMap("centerCapture", centerCaptureMap);
+        stepDatumMap.putMap("leftCapture", leftCaptureMap);
+        stepDatumMap.putMap("rightCapture", rightCaptureMap);
+        stepDatumMap.putString("type", "SelfieStepData");
+      } else if (stepDatum instanceof StepData.UiStepData) {
+        Map<String, Object> componentParams = ((StepData.UiStepData) stepDatum).getComponentParams();
+
+        stepDatumMap.putMap("componentParams", uiStepParamsMapToMap(componentParams));
+        stepDatumMap.putString("type", "UiStepData");
+      } else {
+        // do nothing
+      }
+
+      stepDataMap.pushMap(stepDatumMap);
+    }
+
+    collectedDataMap.putArray("stepData", stepDataMap);
+
+    return collectedDataMap;
+  }
+
+  private ReadableMap uiStepParamsMapToMap(Map<?, ?> map) {
+    WritableMap resultMap = Arguments.createMap();
+    for (Map.Entry<?, ?> param : map.entrySet()) {
+      Object key = param.getKey();
+      Object value = param.getValue();
+
+      if (!(key instanceof String)) {
+        continue; // All ui step params should have string keys.
+      }
+
+      String keyStr = (String) key;
+
+      if (value instanceof Map<?, ?>) {
+        resultMap.putMap(keyStr, uiStepParamsMapToMap((Map<?, ?>) value));
+      } else if (value instanceof List<?>) {
+        resultMap.putArray(keyStr, uiStepParamsArrToArr((List<?>) value));
+      } else if (value instanceof String) {
+        resultMap.putString(keyStr, (String) value);
+      } else if (value instanceof Boolean) {
+        resultMap.putBoolean(keyStr, (Boolean) value);
+      } else if (value instanceof Number) {
+        resultMap.putDouble(keyStr, (Double) value);
+      }
+    }
+
+    return resultMap;
+  }
+
+  private ReadableArray uiStepParamsArrToArr(List<?> arr) {
+    WritableArray resultArr = Arguments.createArray();
+
+    for (Object element : arr) {
+      if (element instanceof String) {
+        resultArr.pushString((String) element);
+      } else if (element instanceof Boolean) {
+        resultArr.pushBoolean((Boolean) element);
+      } else if (element instanceof Number) {
+        resultArr.pushDouble((Double) element);
+      }
+    }
+
+
+    return resultArr;
+  }
+
+  private ReadableMap selfieCaptureToMap(@Nullable SelfieCapture selfieCapture) {
+    if (selfieCapture == null) {
+      return null;
+    }
+
+    WritableMap captureMap = Arguments.createMap();
+    captureMap.putString("captureMethod", selfieCapture.getCaptureMethod().name());
+    captureMap.putString("absoluteFilePath", selfieCapture.getData().getAbsolutePath());
+    return captureMap;
+  }
+
+
   private static ReadableMap wrapField(String type, String value) {
     WritableMap map = Arguments.createMap();
     map.putString("type", type);
@@ -201,6 +347,11 @@ public class PersonaInquiryModule2 extends ReactContextBaseJavaModule
         builder = builder.fields(fieldsBuilder.build());
       }
 
+      Boolean returnCollectedData = options.hasKey(RETURN_COLLECTED_DATA) ? options.getBoolean(RETURN_COLLECTED_DATA) : null;
+      if (returnCollectedData != null) {
+        builder = builder.returnCollectedData(returnCollectedData);
+      }
+
       if (currentActivity != null) {
         builder.build().start(currentActivity, PERSONA_INQUIRY_REQUEST_CODE);
       }

package/ios/PersonaInquiry2.swift

@@ -11,6 +11,8 @@ import Persona2
 @objc(PersonaInquiry2)
 class PersonaInquiry2: RCTEventEmitter {
 
+    private var collectedData: InquiryData? = nil
+
     override func supportedEvents() -> [String] {
         ["onComplete", "onCanceled", "onError"]
     }
@@ -40,37 +42,39 @@ class PersonaInquiry2: RCTEventEmitter {
         let sessionToken = options["sessionToken"] as? String
         let themeObject = options["iosTheme"] as? [String: String]
         let fieldsObject = options["fields"] as? [String: [String: Any]]
-
-        do {
-            let config = try createConfig(
-                templateId: templateId,
-                templateVersion: templateVersion,
-                inquiryId: inquiryId,
-                sessionToken: sessionToken,
-                referenceId: referenceId,
-                accountId: accountId,
-                environment: Environment.from(rawValue: environment),
-                theme: themeFrom(themeObject),
-                fields: fieldsFrom(fieldsObject)
-            )
-            DispatchQueue.main.async {
-                guard let viewController = self.findTopViewController() else {
-                    self.sendEvent(
-                        withName: "onError",
-                        body: [
-                            "debugMessage": "Couldn't resolve a root view controller"
-                        ]
-                    )
-                    return
-                }
-
-                Inquiry(
-                    config: config,
-                    delegate: self
-                ).start(from: viewController)
+        let returnCollectedData = options["returnCollectedData"] as? Bool ?? false
+
+        guard let config = InquiryConfiguration.build(
+            inquiryId: inquiryId,
+            sessionToken: sessionToken,
+            templateVersion: templateVersion,
+            templateId: templateId,
+            referenceId: referenceId,
+            accountId: accountId,
+            environment: Environment.from(rawValue: environment),
+            fields: fieldsFrom(fieldsObject),
+            theme: themeFrom(themeObject),
+            nfcAdapter: nil,
+            collectionDelegate: returnCollectedData ? self : nil
+        ) else {
+            print("An error occurred while starting the Inquiry, invalid config.")
+            return
+        }
+        DispatchQueue.main.async {
+            guard let viewController = self.findTopViewController() else {
+                self.sendEvent(
+                    withName: "onError",
+                    body: [
+                        "debugMessage": "Couldn't resolve a root view controller"
+                    ]
+                )
+                return
             }
-        } catch {
-            print("An error occurred while starting the Inquiry: \(error.localizedDescription)")
+
+            Inquiry(
+                config: config,
+                delegate: self
+            ).start(from: viewController)
         }
     }
 
@@ -85,7 +89,7 @@ class PersonaInquiry2: RCTEventEmitter {
     }
 }
 
-// MARK: - Inquiry Delegate Methods
+// MARK: - InquiryDelegate
 
 extension PersonaInquiry2: InquiryDelegate {
     func inquiryComplete(inquiryId: String, status: String, fields: [String: InquiryField]) {
@@ -94,7 +98,8 @@ extension PersonaInquiry2: InquiryDelegate {
             body: [
                 "inquiryId": inquiryId,
                 "status": status,
-                "fields": fieldsToDictionary(fields: fields)
+                "fields": fieldsToDictionary(fields: fields),
+                "collectedData": collectedData?.toDictionary()
             ]
         )
     }
@@ -120,100 +125,108 @@ extension PersonaInquiry2: InquiryDelegate {
     }
 }
 
-// MARK: - Helpers
+// MARK: - InquiryCollectionDelegate
 
-extension PersonaInquiry2 {
+extension PersonaInquiry2: InquiryCollectionDelegate {
 
-    enum InvalidConfiguration: Error {
-        case argumentError(String)
+    func collectionComplete(data: InquiryData) {
+        self.collectedData = data
     }
+}
 
-    /// Creates an InquiryConfiguration based on the passed in parameters
-    private func createConfig(templateId: String?,
-                              templateVersion: String?,
-                              inquiryId: String? = nil,
-                              sessionToken: String? = nil,
-                              referenceId: String? = nil,
-                              accountId: String? = nil,
-                              environment: Environment? = .production,
-                              theme: InquiryTheme? = nil,
-                              fields: [String: InquiryField]? = nil) throws -> InquiryConfiguration {
-
-        // If we have an inquiry ID there is only one path to take
-        if let inquiryId = inquiryId {
-            return InquiryConfiguration(
-                inquiryId: inquiryId,
-                sessionToken: sessionToken,
-                theme: theme
-                // fields: fields // TODO: Uncomment this once it's enabled
-            )
-        }
-        // Use the template ID if we have it
-        else if let templateId = templateId {
-
-            // Use the account ID if we have it
-            if let accountId = accountId {
-                return InquiryConfiguration(
-                    templateId: templateId,
-                    accountId: accountId,
-                    environment: environment,
-                    fields: fields,
-                    theme: theme
-                )
-            }
-            // Use the reference ID if we have it
-            else if let referenceId = referenceId {
-                return InquiryConfiguration(
-                    templateId: templateId,
-                    referenceId: referenceId,
-                    environment: environment,
-                    fields: fields,
-                    theme: theme
-                )
-            }
+extension InquiryData {
+
+    func toDictionary() -> [String: Any?] {
+        var inquiryData = [[String: Any?]]()
+        for data in self.stepData {
+            var currentStepData = [String: Any?]()
+
+            switch data {
+            case .ui(let uiData):
+                currentStepData["type"] = "UiStepData"
+                currentStepData["stepName"] = uiData.name
+                currentStepData["componentParams"] = uiData.componentData.reduce(into: [[String: Any?]]()) { partial, element in
+                    switch element {
+                    case .int(let key, let value):
+                        partial.append([key: value])
+                    case .bool(let key, let value):
+                        partial.append([key: value])
+                    case .string(let key, let value):
+                        partial.append([key: value])
+                    case .strings(let key, let value):
+                        partial.append([key: value])
+                    case .double(let key, let value):
+                        partial.append([key: value])
+                    case .address(let key, let value):
+                        partial.append([key: value])
+                    default:
+                        return
+                    }
+                }
+            case .selfie(let selfieData):
+                currentStepData["type"] = "SelfieStepData"
+                currentStepData["stepName"] = selfieData.name
+                if let centerPhoto = selfieData.centerPhoto {
+                    currentStepData["centerCapture"] = [
+                        "captureMethod": centerPhoto.captureMethod,
+                        "absoluteFilePath": centerPhoto.filePath
+                    ]
+                }
 
-            // Otherwise only use the template ID
-            return InquiryConfiguration(
-                templateId: templateId,
-                environment: environment,
-                fields: fields,
-                theme: theme
-            )
-        }
-        // Otherwise use the template version
-        else if let templateVersion = templateVersion {
-
-            // Use the account ID if we have it
-            if let accountId = accountId {
-                return InquiryConfiguration(
-                    templateVersion: templateVersion,
-                    accountId: accountId,
-                    environment: environment,
-                    fields: fields,
-                    theme: theme
-                )
-            }
-            // Use the reference ID if we have it
-            else if let referenceId = referenceId {
-                return InquiryConfiguration(
-                    templateVersion: templateVersion,
-                    referenceId: referenceId,
-                    environment: environment,
-                    fields: fields,
-                    theme: theme
-                )
-            }
+                if let leftPhoto = selfieData.leftPhoto {
+                    currentStepData["leftCapture"] = [
+                        "captureMethod": leftPhoto.captureMethod,
+                        "absoluteFilePath": leftPhoto.filePath
+                    ]
+                }
 
-            // Otherwise only use the template version
-            return InquiryConfiguration(
-                templateVersion: templateVersion,
-                environment: environment,
-                fields: fields,
-                theme: theme
-            )
+                if let rightPhoto = selfieData.rightPhoto {
+                    currentStepData["rightCapture"] = [
+                        "captureMethod": rightPhoto.captureMethod,
+                        "absoluteFilePath": rightPhoto.filePath
+                    ]
+                }
+
+            case .governmentId(let govIdData):
+                currentStepData["type"] = "GovernmentIdStepData"
+                currentStepData["stepName"] = govIdData.name
+
+                var captures = [[String: Any]]()
+                for file in govIdData.files {
+                    captures.append([
+                        "idClass": govIdData.idClass,
+                        "captureMethod": file.captureMethod,
+                        "side": file.page,
+                        "frames": file.frames.map {
+                            ["absoluteFilePath": $0.filePath]
+                        }
+                    ])
+                }
+                currentStepData["captures"] = captures
+            case .document(let docData):
+                currentStepData["type"] = "DocumentStepData"
+                currentStepData["stepName"] = docData.name
+
+                var documents = [[String: String]]()
+                for file in docData.files {
+                    documents.append(["absoluteFilePath": file.filePath])
+                }
+                currentStepData["documents"] = documents
+            default:
+                continue
+            }
+            inquiryData.append(currentStepData)
         }
+        return ["stepData": inquiryData]
+    }
+}
+
+// MARK: - Helpers
+
+extension PersonaInquiry2 {
 
-        throw InvalidConfiguration.argumentError("Invalid arguments. Please refer to documentation or support for assistance.")
+    enum InvalidConfiguration: Error {
+        case argumentError(String)
     }
 
     /// Converts a dictionary into a theme