rn-linkrunner 1.1.2 → 2.0.1

package/android/src/main/java/io/linkrunner/utils/ModelConverter.kt

@@ -0,0 +1,226 @@
+package io.linkrunner.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import io.linkrunner.sdk.models.PaymentStatus
+import io.linkrunner.sdk.models.PaymentType
+import io.linkrunner.sdk.models.request.CapturePaymentRequest
+import io.linkrunner.sdk.models.request.RemovePaymentRequest
+import io.linkrunner.sdk.models.request.UserDataRequest
+import io.linkrunner.sdk.models.IntegrationData
+import io.linkrunner.sdk.models.response.AttributionData
+import io.linkrunner.sdk.models.response.ClientCampaignData
+import io.linkrunner.sdk.models.response.GeneralResponse
+import io.linkrunner.sdk.models.response.IPLocationData
+
+/**
+ * Utility class to convert React Native ReadableMap objects to Kotlin model objects and vice versa
+ */
+object ModelConverter {
+    
+    /**
+     * Convert GeneralResponse to WritableMap
+     */
+    fun fromGeneralResponse(response: GeneralResponse?): WritableMap? {
+        if (response == null) {
+            return null
+        }
+        
+        val map = Arguments.createMap()
+        
+        // Add IP location data if available
+        response.ipLocationData?.let { ipData ->
+            map.putMap("ip_location_data", fromIPLocationData(ipData))
+        }
+        
+        // Add deeplink if available
+        response.deeplink?.let { deeplink ->
+            map.putString("deeplink", deeplink)
+        }
+        
+        // Add root domain if available
+        response.rootDomain?.let { rootDomain ->
+            map.putBoolean("root_domain", rootDomain)
+        }
+        
+        return map
+    }
+    
+    /**
+     * Convert ClientCampaignData to WritableMap
+     */
+    fun fromClientCampaignData(data: ClientCampaignData?): WritableMap? {
+        if (data == null) {
+            return null
+        }
+        
+        val map = Arguments.createMap()
+        
+        // Add required fields
+        map.putString("id", data.id)
+        map.putString("name", data.name)
+        map.putString("type", data.type)
+        
+        // Add optional fields if available
+        data.adNetwork?.let { adNetwork ->
+            map.putString("adNetwork", adNetwork)
+        }
+        
+        data.groupName?.let { groupName ->
+            map.putString("groupName", groupName)
+        }
+        
+        data.assetGroupName?.let { assetGroupName ->
+            map.putString("assetGroupName", assetGroupName)
+        }
+        
+        data.assetName?.let { assetName ->
+            map.putString("assetName", assetName)
+        }
+        
+        return map
+    }
+    
+    /**
+     * Convert IPLocationData to WritableMap
+     */
+    fun fromIPLocationData(data: IPLocationData?): WritableMap? {
+        if (data == null) {
+            return null
+        }
+        
+        val map = Arguments.createMap()
+        
+        // Add all fields if available
+        data.ip?.let { ip ->
+            map.putString("ip", ip)
+        }
+        
+        data.city?.let { city ->
+            map.putString("city", city)
+        }
+        
+        data.countryLong?.let { countryLong ->
+            map.putString("countryLong", countryLong)
+        }
+        
+        data.countryShort?.let { countryShort ->
+            map.putString("countryShort", countryShort)
+        }
+        
+        data.latitude?.let { latitude ->
+            map.putDouble("latitude", latitude)
+        }
+        
+        data.longitude?.let { longitude ->
+            map.putDouble("longitude", longitude)
+        }
+        
+        data.region?.let { region ->
+            map.putString("region", region)
+        }
+        
+        data.timeZone?.let { timeZone ->
+            map.putString("timeZone", timeZone)
+        }
+        
+        data.zipCode?.let { zipCode ->
+            map.putString("zipCode", zipCode)
+        }
+        
+        return map
+    }
+
+    /**
+     * Convert AttributionData to WritableMap
+     */
+    fun fromAttributionData(data: AttributionData?): WritableMap {
+        val map = Arguments.createMap()
+        
+        if (data != null) {
+            // Add the deeplink if it exists
+            data.deeplink?.let { deeplink ->
+                map.putString("deeplink", deeplink)
+            }
+            
+            // Convert campaign data to a WritableMap if it exists
+            data.campaignData?.let { campaignData ->
+                val campaignDataMap = Arguments.createMap()
+                campaignDataMap.putString("id", campaignData.id)
+                campaignDataMap.putString("name", campaignData.name)
+                
+                campaignData.adNetwork?.let { adNetwork ->
+                    campaignDataMap.putString("adNetwork", adNetwork)
+                }
+                
+                campaignDataMap.putString("type", campaignData.type)
+                campaignDataMap.putString("installedAt", campaignData.installedAt)
+                
+                campaignData.storeClickAt?.let { storeClickAt ->
+                    campaignDataMap.putString("storeClickAt", storeClickAt)
+                }
+                
+                campaignDataMap.putString("groupName", campaignData.groupName)
+                campaignDataMap.putString("assetName", campaignData.assetName)
+                campaignDataMap.putString("assetGroupName", campaignData.assetGroupName)
+                
+                map.putMap("campaignData", campaignDataMap)
+            }
+        }
+        
+        return map
+    }
+
+    /**
+     * Convert a ReadableMap to UserDataRequest
+     */
+    fun toUserDataRequest(map: Map<String, Any>): UserDataRequest {
+        return UserDataRequest(
+            id = map["id"] as? String ?: "",
+            name = map["name"] as? String,
+            phone = map["phone"] as? String,
+            email = map["email"] as? String,
+            mixpanelDistinctId = map["mixpanel_distinct_id"] as? String,
+            amplitudeDeviceId = map["amplitude_device_id"] as? String,
+            posthogDistinctId = map["posthog_distinct_id"] as? String,
+            userCreatedAt = map["user_created_at"] as? String,
+            isFirstTimeUser = map["is_first_time_user"] as? Boolean
+        )
+    }
+
+    /**
+     * Convert a Map to IntegrationData
+     */
+    fun toIntegrationData(map: Map<String, Any>): IntegrationData {
+        return IntegrationData(
+            clevertapId = map["clevertapId"] as? String
+        )
+    }
+
+    /**
+     * Convert a ReadableMap to CapturePaymentRequest
+     */
+    fun toCapturePaymentRequest(map: Map<String, Any>): CapturePaymentRequest {
+        val typeString = map["type"] as? String ?: "DEFAULT"
+        val statusString = map["status"] as? String ?: "PAYMENT_COMPLETED"
+        
+        return CapturePaymentRequest(
+            paymentId = map["paymentId"] as? String ?: "",
+            userId = map["userId"] as? String ?: "",
+            amount = (map["amount"] as? Number)?.toDouble() ?: 0.0,
+            type = PaymentType.valueOf(typeString),
+            status = PaymentStatus.valueOf(statusString)
+        )
+    }
+
+    /**
+     * Convert a ReadableMap to RemovePaymentRequest
+     */
+    fun toRemovePaymentRequest(map: Map<String, Any>): RemovePaymentRequest {
+        return RemovePaymentRequest(
+            paymentId = map["paymentId"] as? String ?: "",
+            userId = map["userId"] as? String ?: ""
+        )
+    }
+}

package/ios/LinkrunnerSDK.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface LinkrunnerSDK : NSObject <RCTBridgeModule>
+
+@end

package/ios/LinkrunnerSDK.m

@@ -0,0 +1,31 @@
+#import "React/RCTBridgeModule.h"
+
+// first parameter is the name of the native module
+// second parameter is the name of the native class that implements the module
+@interface RCT_EXTERN_REMAP_MODULE(LinkrunnerSDK, LinkrunnerSDK, NSObject)
+
+RCT_EXTERN_METHOD(initializeSDK:(NSDictionary *)dict)
+
+RCT_EXTERN_METHOD(signup:(NSDictionary *)userData
+                  data:(NSDictionary *)data)
+
+RCT_EXTERN_METHOD(setUserData:(NSDictionary *)userData)
+
+RCT_EXTERN_METHOD(trackEvent:(NSString *)eventName eventData:(NSDictionary *)eventData)
+
+RCT_EXTERN_METHOD(capturePayment:(NSDictionary *)paymentData)
+
+RCT_EXTERN_METHOD(removePayment:(NSDictionary *)paymentData)
+
+RCT_EXTERN_METHOD(enablePIIHashing:(BOOL)enabled)
+
+RCT_EXTERN_METHOD(requestTrackingAuthorization)
+
+RCT_EXTERN_METHOD(getAttributionData:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setAdditionalData:(NSDictionary *)integrationDataDict
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/LinkrunnerSDK.swift

@@ -0,0 +1,218 @@
+import Foundation
+import LinkrunnerKit;
+import React
+
+@objc(LinkrunnerSDK)
+class LinkrunnerSDK: NSObject {
+    
+    private var linkrunnerSDK: LinkrunnerKit.LinkrunnerSDK!
+    
+    override init() {
+        linkrunnerSDK = LinkrunnerKit.LinkrunnerSDK.shared
+    }
+    
+    
+    // MARK: - Native SDK Method Wrappers
+    
+    @objc func initializeSDK(_ dict: NSDictionary) -> Void {
+        guard let token = dict["token"] as? String else {
+            print("Linkrunner: token is required")
+            return
+        }
+
+        let secretKey = dict["secretKey"] as? String
+        let keyId = dict["keyId"] as? String
+        let debug = dict["debug"] as? Bool ?? false
+    
+        
+        Task {
+            do {
+                try await linkrunnerSDK.initialize(token: token, secretKey: secretKey, keyId: keyId, debug: debug)
+                print("Linkrunner: SDK initialized successfully")
+            } catch {
+                print("Linkrunner: Failed to initialize SDK: \(error)")
+            }
+        }
+    }
+
+    @objc func signup(_ userData: NSDictionary, data: NSDictionary? = nil) -> Void {
+        guard let id = userData["id"] as? String else {
+            print("Linkrunner: User ID is required")
+            return
+        }
+        
+        let userDataObj = UserData(
+            id: id,
+            name: userData["name"] as? String,
+            phone: userData["phone"] as? String,
+            email: userData["email"] as? String,
+            isFirstTimeUser: userData["is_first_time_user"] as? Bool,
+            userCreatedAt: userData["user_created_at"] as? String,
+            mixPanelDistinctId: userData["mixpanel_distinct_id"] as? String,
+            amplitudeDeviceId: userData["amplitude_device_id"] as? String,
+            posthogDistinctId: userData["posthog_distinct_id"] as? String
+        )
+        
+        Task {
+            do {
+                if #available(iOS 15.0, *) {
+                    try await linkrunnerSDK.signup(
+                        userData: userDataObj,
+                        additionalData: data as? [String: Any]
+                    )
+                    return
+                } else {
+                    print("UNSUPPORTED_VERSION: iOS 15.0 or later is required")
+                }
+            } catch {
+                print("SIGNUP_ERROR", "Failed to complete signup: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    @objc func setUserData(_ userData: NSDictionary) -> Void {
+        guard let id = userData["id"] as? String else {
+            print("Linkrunner: User ID is required")
+            return
+        }
+        
+        let userDataObj = UserData(
+            id: id,
+            name: userData["name"] as? String,
+            phone: userData["phone"] as? String,
+            email: userData["email"] as? String,
+            isFirstTimeUser: userData["is_first_time_user"] as? Bool,
+            userCreatedAt: userData["user_created_at"] as? String,
+            mixPanelDistinctId: userData["mixpanel_distinct_id"] as? String,
+            amplitudeDeviceId: userData["amplitude_device_id"] as? String,
+            posthogDistinctId: userData["posthog_distinct_id"] as? String
+        )
+        
+        Task {
+            do {
+                try await linkrunnerSDK.setUserData(userDataObj)
+                print("Linkrunner: User data set successfully")
+            } catch {
+                print("Linkrunner: Failed to set user data: \(error)")
+            }
+        }
+    }
+    
+    @objc func trackEvent(_ eventName: NSString, eventData: NSDictionary?) -> Void {
+        Task {
+            do {
+                try await linkrunnerSDK.trackEvent(eventName: eventName as String, eventData: eventData as? [String: Any])
+                print("Linkrunner: Event tracked successfully")
+            } catch {
+                print("Linkrunner: Failed to track event: \(error)")
+            }
+        }
+    }
+    
+    @objc func capturePayment(_ paymentData: NSDictionary) -> Void {
+        guard let userId = paymentData["userId"] as? String,
+              let amount = paymentData["amount"] as? Double else {
+            print("Linkrunner: userId and amount are required for payment capture")
+            return
+        }
+        
+        let paymentId = paymentData["paymentId"] as? String
+        let typeString = paymentData["type"] as? String ?? "DEFAULT"
+        let statusString = paymentData["status"] as? String ?? "PAYMENT_COMPLETED"
+        
+        // Convert strings to enums
+        let paymentType = PaymentType(rawValue: typeString) ?? .default
+        let paymentStatus = PaymentStatus(rawValue: statusString) ?? .completed
+        
+        Task {
+            do {
+                try await linkrunnerSDK.capturePayment(
+                    amount: amount,
+                    userId: userId,
+                    paymentId: paymentId,
+                    type: paymentType,
+                    status: paymentStatus
+                )
+                print("Linkrunner: Payment captured successfully")
+            } catch {
+                print("Linkrunner: Failed to capture payment: \(error)")
+            }
+        }
+    }
+    
+    @objc func removePayment(_ paymentData: NSDictionary) -> Void {
+        guard let userId = paymentData["userId"] as? String else {
+            print("Linkrunner: userId is required for payment removal")
+            return
+        }
+        
+        let paymentId = paymentData["paymentId"] as? String
+        
+        Task {
+            do {
+                try await linkrunnerSDK.removePayment(userId: userId, paymentId: paymentId)
+                print("Linkrunner: Payment removed successfully")
+            } catch {
+                print("Linkrunner: Failed to remove payment: \(error)")
+            }
+        }
+    }
+    
+    @objc func enablePIIHashing(_ enabled: Bool) -> Void {
+        Task {
+            await linkrunnerSDK.enablePIIHashing(enabled)
+            print("Linkrunner: PII hashing \(enabled ? "enabled" : "disabled")")
+        }
+    }
+    
+    @objc func requestTrackingAuthorization() -> Void {
+        linkrunnerSDK.requestTrackingAuthorization { status in
+            print("Linkrunner: Tracking authorization status: \(status.rawValue)")
+        }
+    }
+    
+    @objc func getAttributionData(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
+        Task {
+            do {
+                let attributionData = try await linkrunnerSDK.getAttributionData()
+                resolve(attributionData.toDictionary())
+            } catch {
+                reject("ATTRIBUTION_ERROR", "Failed to get attribution data: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    @objc func setAdditionalData(_ integrationDataDict: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if integrationDataDict.count == 0 {
+            reject("ADDITIONAL_DATA_ERROR", "Integration data is required", NSError(domain: "LinkrunnerSDK", code: 1, userInfo: nil))
+            return
+        }
+        
+        let clevertapId = integrationDataDict["clevertapId"] as? String
+        
+        let integrationData = IntegrationData(clevertapId: clevertapId)
+        
+        Task {
+            do {
+                if #available(iOS 15.0, *) {
+                    try await linkrunnerSDK.setAdditionalData(integrationData)
+                    
+                    let response: [String: Any] = [
+                        "status": "success",
+                        "message": "Additional data set successfully"
+                    ]
+                    resolve(response)
+                } else {
+                    reject("UNSUPPORTED_VERSION", "iOS 15.0 or later is required", NSError(domain: "LinkrunnerSDK", code: 2, userInfo: nil))
+                }
+            } catch {
+                reject("ADDITIONAL_DATA_ERROR", "Failed to set additional data: \(error.localizedDescription)", error)
+            }
+        }
+    }
+
+}
+
+// Type definition needed for RCTPromiseResolveBlock
+typealias RCTPromiseResolveBlock = (Any?) -> Void
+typealias RCTPromiseRejectBlock = (String, String?, Error?) -> Void

package/ios/Podfile

@@ -0,0 +1,19 @@
+# Define the global platform for your project
+platform :ios, '15.0'
+
+# Specify that this is a library, not an application
+install! 'cocoapods', :deterministic_uuids => false
+
+# This is needed since there's no Xcode project yet
+abstract_target 'LinkrunnerSDK' do
+  # Comment the next line if you don't want to use dynamic frameworks
+  use_frameworks!
+
+  # Pods for LinkrunnerSDK
+  
+  # Add the linkrunner-ios-sdk dependency
+    pod 'LinkrunnerKit', '3.0.2'
+
+  
+  # Add any other dependencies your SDK needs here
+end