partner_react_native_sdk 0.1.0

package/src/helpers/network/APICall.tsx

@@ -0,0 +1,65 @@
+import NetworkManager from './network_manager';
+import { HeaderManager } from '../utils/headerManager';
+
+
+export class APICall {
+
+    private networkManager: NetworkManager = new NetworkManager;
+    private headerManager: HeaderManager = new HeaderManager;
+
+
+    async callAPI(
+        method: string,
+        apiUrl: string,
+        options?: {
+            body?: Record<string, any>;
+            headers?: Record<string, any>;
+            encrypted?: boolean;
+
+        }
+    ): Promise<any> {
+        const { body, headers, encrypted = false } = options || {};
+
+        try {
+            const response = encrypted
+                ? await this._callAPIEncrypt(method, apiUrl, body, headers)
+                : await this._callAPIRaw(method, apiUrl, body, headers);
+
+            return response;
+        } catch (error) {
+            console.log("Error in callAPI:", error);
+            throw error;
+        }
+    }
+
+
+    private async _callAPIRaw(
+        method: string,
+        apiUrl: string,
+        body?: Record<string, any>,
+        headers?: Record<string, any>
+    ): Promise<any> {
+        const mergedHeaders = {
+            ...(await this.headerManager.generateHeaders()),
+            ...(headers || {}),
+        };
+
+        return this.networkManager.request({
+            url: apiUrl,
+            method: method,
+            body: body,
+            headers: mergedHeaders
+        });
+    }
+
+    // TODO: Implement encryption logic
+    private async _callAPIEncrypt(
+        method: string,
+        apiUrl: string,
+        body?: Record<string, any>,
+        headers?: Record<string, any>
+    ): Promise<any> {
+        // Encryption logic not implemented, fallback to raw
+        return this._callAPIRaw(method, apiUrl, body, headers);
+    }
+}

package/src/helpers/network/network_manager.tsx

@@ -0,0 +1,122 @@
+import axios, { type AxiosInstance, type AxiosResponse, type AxiosRequestConfig } from 'axios';
+
+class NetworkManager {
+  private static _instance: NetworkManager = new NetworkManager();
+  private _axios: AxiosInstance;
+
+  constructor() {
+    this._axios = axios.create();
+  }
+
+  static getInstance(): NetworkManager {
+    return NetworkManager._instance;
+  }
+
+  async request({
+    url,
+    method,
+    body,
+    headers,
+    options,
+  }: {
+    url: string;
+    method: string;
+    body?: Record<string, any>;
+    headers?: Record<string, any>;
+    options?: AxiosRequestConfig;
+  }): Promise<AxiosResponse | null> {
+    try {
+      headers = headers || {};
+      options = options || { headers };
+
+      let response: AxiosResponse;
+      const config: AxiosRequestConfig = {
+        ...options,
+        headers,
+      };
+
+      switch (method.toUpperCase()) {
+        case 'POST':
+          response = await this._axios.post(url, body, config);
+          break;
+        case 'GET':
+          response = await this._axios.get(url, config);
+          break;
+        case 'PUT':
+          response = await this._axios.put(url, body, config);
+          break;
+        case 'PATCH':
+          response = await this._axios.patch(url, body, config);
+          break;
+        case 'DELETE':
+          response = await this._axios.delete(url, {
+            ...config,
+            data: body,
+          });
+          break;
+        default:
+          throw new Error(`Method not supported: ${method}`);
+      }
+
+      return response;
+    } catch (error) {
+      if (__DEV__) {
+        if (axios.isAxiosError(error)) {
+          if (!error.response) {
+            console.log("Network error:", error.message);
+          }
+          return error.response || null;
+        } else {
+          console.log("Unexpected error during network request:", error);
+        }
+      }
+      throw error;
+    }
+  }
+
+  async get(
+    url: string,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'GET', headers, options });
+  }
+
+  async post(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'POST', body, headers, options });
+  }
+
+  async put(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'PUT', body, headers, options });
+  }
+
+  async patch(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'PATCH', body, headers, options });
+  }
+
+  async delete(
+    url: string,
+    headers?: Record<string, any>,
+    body?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'DELETE', body, headers, options });
+  }
+}
+
+export default NetworkManager;

package/src/helpers/partner_library_react_native.tsx

@@ -0,0 +1,279 @@
+import { APICall } from './network/APICall';
+import { DeviceInfoManager } from './utils/deviceInfoManager';
+import { LibraryConstants } from './utils/LibraryConstants';
+import { type WebViewCallbackFunction } from './utils/webviewCallback';
+import { ServiceNames } from './ServiceNames';
+import { Constants } from './utils/Constants';
+import { WebView } from '../helpers/webview';
+import { SafeAreaView } from 'react-native-safe-area-context';
+import { StatusBar } from 'react-native';
+export type { WebViewCallbackFunction } from './utils/webviewCallback';
+type InitOptions = {
+    whitelistedDomains: string[];
+    deviceBindingEnabled: boolean;
+};
+
+
+export class PartnerLibrary {
+
+    private static instance: PartnerLibrary | null = null;
+    private static intialized = false;
+
+    private _apiCall = new APICall();
+    static webViewCallback: WebViewCallbackFunction;
+
+    private constructor() { }
+
+    static getInstance(): PartnerLibrary {
+        if (!PartnerLibrary.instance) {
+            PartnerLibrary.instance = new PartnerLibrary();
+        }
+        return PartnerLibrary.instance;
+    }
+
+    static async init(hostName: string, options: InitOptions = {
+        whitelistedDomains: [],
+        deviceBindingEnabled: false
+    }): Promise<void> {
+        //   console.log("PartnerLibrary.init - initialized:", PartnerLibrary.intialized);
+        if (PartnerLibrary.intialized) return;
+
+        try {
+            // Ensure instance exists before setup
+            if (!PartnerLibrary.instance) {
+                //     console.log("PartnerLibrary.init - creating new instance");
+                PartnerLibrary.instance = new PartnerLibrary();
+            }
+            await PartnerLibrary.instance._setup(hostName, options.whitelistedDomains, options.deviceBindingEnabled);
+            PartnerLibrary.intialized = true;
+        }
+        catch (error) {
+            console.error("Initialization failed: ", error);
+            throw new Error("Initialization failed");
+        }
+    }
+
+    private async _setup(
+        hostName: string,
+        whitelistedDomains: string[],
+        deviceBindingEnabled: boolean
+    ): Promise<void> {
+
+
+        LibraryConstants.init({
+            host: hostName,
+            whitelistedDomains: whitelistedDomains,
+            deviceBinding: deviceBindingEnabled
+        });
+
+    }
+
+    async open(
+        module: string,
+        token: string,
+        WebViewCallbackFunction: WebViewCallbackFunction,
+
+    ): Promise<React.ReactElement> {
+        if (!PartnerLibrary.intialized) {
+            throw new Error('PartnerLibrary not initialized. Call init() first.');
+        }
+        try {
+            let bank = "";
+
+            if (module.includes("banking/")) {
+                const startIndex = module.indexOf("banking/") + "banking/".length;
+                const temp = module.substring(startIndex);
+                const endIndex = temp.indexOf("/");
+                bank = endIndex === -1 ? temp : temp.substring(0, endIndex);
+            }
+
+            return this._loginAndNavigateToWebView(module, bank, token, WebViewCallbackFunction);
+        } catch (e) {
+            console.error('Error opening webview:', e);
+            throw e;
+        }
+    }
+
+
+    private async _checkDeviceBinding(
+        bank: string,
+        url: string,
+        WebViewCallbackFunction: WebViewCallbackFunction,
+
+    ): Promise<React.ReactElement> {
+
+        console.log("entered in check device binding")
+        if (LibraryConstants.deviceBindingEnabled) {
+            // TODO: Build the device binding flow
+            return Promise.resolve(<></>);
+
+        } else {
+            console.log("calling setup device session")
+
+            return this._setupDeviceSession(bank, url, WebViewCallbackFunction);
+        }
+    }
+
+    private async _loginAndNavigateToWebView(
+        module: string,
+        bank: string,
+        token: string,
+        WebViewCallbackFunction: WebViewCallbackFunction,
+
+    ): Promise<React.ReactElement> {
+        // console.log("PartnerLibrary._loginAndNavigateToWebView - LibraryConstants.hostName:", LibraryConstants.hostName);
+        try {
+            let tokenResponse: any;
+            const url = ServiceNames.LOGIN_URL;
+            console.log("url is : ", url)
+            tokenResponse = await this._apiCall.callAPI(
+                'POST',
+                ServiceNames.LOGIN_URL, {
+                body: {
+                    'token': token
+                }
+            }
+            );
+
+            if (tokenResponse?.data?.code === "USER_TOKEN_EXPIRED") {
+                console.log("Token expired");
+                return Promise.resolve(<></>);
+            }
+
+            if (tokenResponse?.data && 'RATE_LIMIT_USER' in tokenResponse.data) {
+                console.log("rate limit user");
+            }
+
+            // console.log("Checking login success condition:", {
+            //     statusCode: tokenResponse?.statusCode,
+            //     code: tokenResponse?.data?.code
+            // });
+
+            if (tokenResponse?.data?.code === "USER_LOGIN_SUCCESS") {
+                console.log("User login success");
+                this.fetchAndSetTheme();
+                return this._checkDeviceBinding(bank, module, WebViewCallbackFunction);
+            } else {
+                console.log("Login not successful. Token Response:", tokenResponse);
+                return Promise.resolve(<></>);
+            }
+
+        } catch (e) {
+            console.error('Error during login:', e);
+            throw e;
+        }
+
+
+    }
+
+    private async _setupDeviceSession(
+        bank: string,
+        url: string,
+        WebViewCallbackFunction: WebViewCallbackFunction,
+
+    ): Promise<React.ReactElement> {
+        try {
+            console.log("in setup device session")
+
+            const deviceInfo = await DeviceInfoManager.getDeviceInfo();
+            const appVersion = deviceInfo['app_version'] || 'unknown';
+
+            if (__DEV__) {
+                console.log("Device Info:", deviceInfo);
+                console.log("App Version:", appVersion);
+            }
+            console.log("device uuid is : ", deviceInfo[Constants.DEVICE_UUID]);
+
+            const response = await this._apiCall.callAPI(
+                'POST',
+                ServiceNames.DEVICE_SESSION.params({ "partner": bank }),
+                {
+                    body: {
+                        [Constants.MANUFACTURER]: deviceInfo[Constants.MANUFACTURER],
+                        [Constants.MODEL]: deviceInfo[Constants.MODEL],
+                        [Constants.DEVICE_UUID]: deviceInfo[Constants.DEVICE_UUID],
+                        [Constants.OS]: deviceInfo[Constants.OS],
+                        [Constants.OS_VERSION]: deviceInfo[Constants.OS_VERSION],
+                        [Constants.APP_VERSION]: appVersion,
+                    }
+                }
+            );
+            //console.log("response from setup device session is : ", response)
+            if (response?.data && 'RATE_LIMIT_USER' in response.data) {
+                console.log("rate limit user");
+            }
+
+            if (response?.status === 200) {
+
+                return this._openWebView(url, WebViewCallbackFunction);
+            } else {
+                console.warn('Error setting up device session:', response);
+                return this._openWebView(url, WebViewCallbackFunction);
+            }
+        } catch (e) {
+            console.error('Error setting up device session:', e);
+            throw e;
+        }
+    }
+
+
+
+    async _openWebView(
+        url: string,
+        WebViewCallbackFunction: WebViewCallbackFunction,
+    ): Promise<React.ReactElement> {
+        console.log("entered in open web view");
+        console.log("url is : ", LibraryConstants.hostName + url);
+
+
+        return (
+            <SafeAreaView style={{ flex: 1 }}>
+                <WebView
+                    url={LibraryConstants.hostName + url}
+                    onCallback={WebViewCallbackFunction}
+                    whitelistedUrls={LibraryConstants.whitelistedDomains}
+                    hostName={LibraryConstants.hostName}
+                    onPageFinished={() => console.log('WebView page finished loading')}
+                />
+            </SafeAreaView>
+        );
+    }
+
+    async fetchAndSetTheme(): Promise<void> {
+        try {
+            console.log("Fetching theme from API");
+
+            const themeResponse: any = await this._apiCall.callAPI(
+                'GET',
+                ServiceNames.THEME_URL
+            );
+            const theme = themeResponse?.data;
+
+            if (theme && theme["--color-primary-500"]) {
+                const rgbValues = theme["--color-primary-500"].split(" ").map(Number);
+                if (rgbValues.length === 3) {
+                    const [r, g, b] = rgbValues;
+
+                    // Update LibraryConstants color
+                    LibraryConstants.setPrimaryColorFromRGB(r, g, b);
+
+                    // Set status bar color
+
+                    StatusBar.setBackgroundColor(LibraryConstants.primaryColor);
+                    StatusBar.setBarStyle('light-content');
+
+
+                    console.log("Theme color set successfully:", LibraryConstants.primaryColor);
+                } else {
+                    console.warn("Invalid RGB values in theme response");
+                }
+            } else {
+                console.warn("--color-primary-500 not found in theme response");
+            }
+        } catch (e) {
+            console.error("Error Fetching theme: ", e);
+            throw e;
+        }
+    }
+
+}

package/src/helpers/utils/Constants.tsx

@@ -0,0 +1,10 @@
+export const Constants = {
+
+    MANUFACTURER: "manufacturer",
+    MODEL: "model",
+    OS: "os",
+    OS_VERSION: "os_version",
+    APP_VERSION: "app_version",
+    DEVICE_UUID: "device_uuid",
+    PRIMARY_COLOR: "#3F51B5"
+} as const;

package/src/helpers/utils/LibraryConstants.tsx

@@ -0,0 +1,133 @@
+import { Platform } from 'react-native';
+
+interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+
+// interface ColorWithValues extends Color {
+//     withValues(params: { red: number; green: number; blue: number; alpha: number }): string;
+// }
+
+// Helper function for color handling
+const hexToRgba = (hex: string): Color => {
+    const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+
+    if (match && match[1] && match[2] && match[3]) {
+        return {
+            r: parseInt(match[1], 16),
+            g: parseInt(match[2], 16),
+            b: parseInt(match[3], 16),
+            a: 1,
+        };
+    }
+
+    return { r: 0, g: 0, b: 0, a: 1 };
+};
+
+
+
+// const rgbaToHex = (color: Color): string => {
+//     return `#${color.r.toString(16).padStart(2, '0')}${color.g.toString(16).padStart(2, '0')}${color.b.toString(16).padStart(2, '0')}`;
+// };
+
+const rgbaToString = (color: Color): string => {
+    return `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a})`;
+};
+
+export class LibraryConstants {
+
+
+    static deviceBindingEnabled: boolean = true;
+
+    // Primary color definition
+    private static _primaryColorHex: string = '#037EAB';
+    private static _primaryColorObj: Color = hexToRgba('#037EAB');
+
+    // static get primaryColor(): string {
+    //     return this._primaryColorHex;
+    // }
+
+    static set primaryColor(value: string) {
+        this._primaryColorHex = value;
+        this._primaryColorObj = hexToRgba(value);
+    }
+    private static rgbToHex(r: number, g: number, b: number): string {
+        return `#${[r, g, b]
+            .map(x => {
+                const hex = x.toString(16);
+                return hex.length === 1 ? '0' + hex : hex;
+            })
+            .join('')}`;
+    }
+
+    static setPrimaryColorFromRGB(r: number, g: number, b: number): void {
+        this._primaryColorObj = { r, g, b, a: 1 };
+        this._primaryColorHex = LibraryConstants.rgbToHex(r, g, b);
+    }
+
+
+
+
+    static secondaryColor: string = '#FFFFFF';
+
+    // Calculate disabled primary color (with 50% opacity)
+    static get primaryColorDisabled(): string {
+        return rgbaToString({
+            r: this._primaryColorObj.r,
+            g: this._primaryColorObj.g,
+            b: this._primaryColorObj.b,
+            a: 0.5
+        });
+    }
+
+    static openExternally: string[] = [""];
+    static whitelistedUrlsAndroid: string[] = [];
+    static whitelistedUrlsIos: string[] = [];
+    static hostName: string = "";
+    static whitelistedDomains: string[] = [];
+
+    static init({
+        host,
+        // whitelistedAndroid,
+        // whitelistedIos,
+        whitelistedDomains,
+        deviceBinding,
+    }: {
+        host: string;
+        whitelistedDomains: string[]
+        // whitelistedAndroid?: string[];
+        // whitelistedIos?: string[];
+        deviceBinding?: boolean;
+    }): void {
+        this.hostName = host;
+        // if (whitelistedAndroid) this.whitelistedUrlsAndroid = whitelistedAndroid;
+        // if (whitelistedIos) this.whitelistedUrlsIos = whitelistedIos;
+        this.whitelistedDomains = whitelistedDomains;
+        if (deviceBinding !== undefined) this.deviceBindingEnabled = deviceBinding;
+    }
+
+    // Helper method to get whitelisted URLs based on platform
+    // static getWhitelistedUrls(): string[] {
+    //     return Platform.OS === 'ios' ? this.whitelistedUrlsIos : this.whitelistedUrlsAndroid;
+    // }
+
+    static getWhitelistedDomains(): string[] {
+        return this.whitelistedDomains;
+    }
+
+    static get primaryColor(): string {
+        if (Platform.OS === 'android') {
+            return rgbaToString(this._primaryColorObj);
+        }
+        return this._primaryColorHex;
+    }
+    static getPrimaryColorWithOpacity(opacity: number): string {
+        return rgbaToString({
+            ...this._primaryColorObj,
+            a: opacity
+        });
+    }
+}

package/src/helpers/utils/deviceInfoManager.tsx

@@ -0,0 +1,37 @@
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+import { Constants } from './Constants';
+
+export class DeviceInfoManager {
+    static async getDeviceInfo(): Promise<Record<string, string>> {
+        if (Platform.OS === 'android') {
+            let androidId = 'unknown';
+            try {
+                androidId = await DeviceInfo.getAndroidId();
+            } catch (e) {
+                if (__DEV__) {
+                    console.log('Error getting android id:', e);
+                }
+            }
+            return {
+                [Constants.MANUFACTURER]: (await DeviceInfo.getManufacturer()) || 'unknown',
+                [Constants.MODEL]: DeviceInfo.getModel() || 'unknown',
+                [Constants.OS]: 'android',
+                [Constants.OS_VERSION]: DeviceInfo.getSystemVersion() || 'unknown',
+                [Constants.APP_VERSION]: DeviceInfo.getVersion() || 'unknown',
+                [Constants.DEVICE_UUID]: androidId,
+            };
+        } else if (Platform.OS === 'ios') {
+            return {
+                [Constants.MANUFACTURER]: 'Apple',
+                [Constants.MODEL]: DeviceInfo.getModel() || 'unknown',
+                [Constants.OS]: 'ios',
+                [Constants.OS_VERSION]: DeviceInfo.getSystemVersion() || 'unknown',
+                [Constants.APP_VERSION]: DeviceInfo.getVersion() || 'unknown',
+                [Constants.DEVICE_UUID]: (await DeviceInfo.getUniqueId()) || 'unknown',
+            };
+        } else {
+            throw new Error('Unsupported platform');
+        }
+    }
+}

package/src/helpers/utils/headerManager.tsx

@@ -0,0 +1,22 @@
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+import { DeviceInfoManager } from './deviceInfoManager';
+
+export class HeaderManager {
+
+    private deviceInfoManager = DeviceInfoManager;
+
+    async generateHeaders(isEncrypted: boolean = true): Promise<Record<string, string>> {
+
+        const deviceInfo = await this.deviceInfoManager.getDeviceInfo();
+
+        return {
+            ...deviceInfo,
+            app_version: DeviceInfo.getVersion() || 'unknown',
+            os: Platform.OS === 'android' ? 'Android' : 'iOS',
+            os_version: DeviceInfo.getSystemVersion() || 'unknown',
+            ...(isEncrypted && { 'Content-Type': 'application/json;charset=utf-8' })
+        };
+
+    }
+}