@inngageregistry/inngage-react 3.3.1 → 4.0.0-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inngageregistry/inngage-react",
-  "version": "3.3.1",
+  "version": "4.0.0-alpha.2",
   "description": "Inngage Plugin for React Native applications for marketing campaign optimization using Push Notification.",
   "main": "src/index.ts",
   "types": "src/index.d.ts",

package/src/Inngage.ts

@@ -3,62 +3,62 @@ import DeviceInfo from "react-native-device-info";
 import * as RNLocalize from "react-native-localize";
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { addUserDataRequest, eventRequest, formatDate, subscriptionRequestAdapter } from "./utils";
-import notificationsListener, { notificationsListenerProps } from "./notificationsListener";
-import { subscriptionApi, eventsApi, addUserDataApi } from "./services/inngage";
+import { formatDate } from "./utils";
+import { InngageNotificationMessage } from "./firebase/notifications_listener";
 import { InngageProperties } from './models/inngage_properties';
 
 import RNPermissions, { NotificationOption, RESULTS } from 'react-native-permissions';
 
+import ApiService from './services/api_service';
+
+import {
+  SUBSCRIBE_REQUEST,
+  EVENT_REQUEST,
+  USER_DATA_REQUEST,
+} from './models/requests';
+
+const API_LEVEL_33 = 33;
+
 // --- Get Firebase Access ------/
-const getFirebaseAccess = async (): Promise<string | null> => {
-  try {
-    return await handleNotificationsPermission();
-  } catch (error) {
-    console.error('Erro no getFirebaseAccess: ', error);
-    throw error;
-  }
+const getFirebaseAccess = async () => {
+  return await handleNotificationsPermission();
 };
 
 const handleNotificationsPermission = async () => {
-  try {
-    const options: NotificationOption[] = ['alert', 'badge', 'sound'];
-    const apiLevel = await DeviceInfo.getApiLevel();
-    const isPermissionGranted =
-      apiLevel >= 33
-        ? ((await RNPermissions.requestNotifications(options)).status) === RESULTS.GRANTED
-        : (await firebase.messaging().requestPermission()) ===
-        firebase.messaging.AuthorizationStatus.AUTHORIZED ||
-        firebase.messaging.AuthorizationStatus.PROVISIONAL;
-
-    return isPermissionGranted ? await getFirebaseToken() : null;
-  } catch (error) {
-    console.error(error);
-    throw error;
+  const options: NotificationOption[] = ['alert', 'badge', 'sound'];
+  const apiLevel = await DeviceInfo.getApiLevel();
+
+  const permissionGranted =
+    apiLevel >= API_LEVEL_33
+      ? (await RNPermissions.requestNotifications(options)).status === RESULTS.GRANTED
+      : (await firebase.messaging().requestPermission()) ===
+      firebase.messaging.AuthorizationStatus.AUTHORIZED ||
+      firebase.messaging.AuthorizationStatus.PROVISIONAL;
+
+  if (permissionGranted) {
+    return await getFirebaseToken();
   }
+
+  throw new Error('Notification permission not granted');
 };
 
-const getFirebaseToken = async (): Promise<string | null> => {
-  try {
-    let fcmToken = await AsyncStorage.getItem('fcmToken');
+const getFirebaseToken = async () => {
+  let fcmToken = await AsyncStorage.getItem('fcmToken');
 
-    if (!fcmToken) {
-      if (!firebase.messaging().isDeviceRegisteredForRemoteMessages) {
-        await firebase.messaging().registerDeviceForRemoteMessages?.();
-      }
+  if (!fcmToken) {
+    if (!firebase.messaging().isDeviceRegisteredForRemoteMessages) {
+      await firebase.messaging().registerDeviceForRemoteMessages?.();
+    }
 
-      const newFcmToken = await firebase.messaging().getToken?.();
+    const newFcmToken = await firebase.messaging().getToken?.();
 
-      if (newFcmToken) {
-        await AsyncStorage.setItem('fcmToken', newFcmToken);
-        return newFcmToken;
-      }
+    if (newFcmToken) {
+      await AsyncStorage.setItem('fcmToken', newFcmToken);
+      return newFcmToken;
     }
-    return fcmToken || null;
-  } catch (error) {
-    console.error(error);
-    throw error;
   }
+
+  return fcmToken || null;
 };
 
 interface SubscriptionProps {
@@ -83,126 +83,121 @@ interface SendEventProps {
   eventValues?: any
 }
 
-const Inngage = {
-  // ------------  Register Notification Listener ------------//
-  RegisterNotificationListener: async (props: notificationsListenerProps) => {
+class Inngage {
+  private static instance: Inngage;
+  private apiService: ApiService;
+
+  constructor() {
+    this.apiService = new ApiService();
+  }
+
+  static getInstance(): Inngage {
+    if (!Inngage.instance) {
+      Inngage.instance = new Inngage();
+    }
+
+    return Inngage.instance;
+  }
+
+  static async notificationListener(firebaseListenCallback?: any) {
     try {
-      await notificationsListener({ ...props });
+      InngageNotificationMessage(firebaseListenCallback)
     } catch (e) {
-      console.error(e);
-      return { subscribed: false };
+      console.log(e)
     }
-  },
+  }
 
-  Subscribe: async ({
+  static async subscribe({
     appToken,
-    dev,
     friendlyIdentifier,
     customFields,
-    customData,
     phoneNumber,
     email,
-  }: SubscriptionProps) => {
+  }: SubscriptionProps) {
+    const inngage = Inngage.getInstance();
+
     InngageProperties.appToken = appToken;
     InngageProperties.identifier = friendlyIdentifier!;
 
-    try {
-      const respToken = await getFirebaseAccess()
-
-      const locales = RNLocalize.getLocales();
-
-      const os_locale = locales ? locales[0].countryCode : ''
-      const os_language = locales && locales.length ? locales[0].languageCode : ''
-      const device_manufacturer = await DeviceInfo.getManufacturer();
-      const installTime = await DeviceInfo.getFirstInstallTime();
-      const lastUpdateTime = await DeviceInfo.getLastUpdateTime();
-      const uuid = await DeviceInfo.getUniqueId();
-      const app_installed_in = formatDate(installTime);
-      const app_updated_in = formatDate(lastUpdateTime);
-
-      const rawRequest = {
-        registerSubscriberRequest: {
-          app_token: appToken,
-          identifier: friendlyIdentifier,
-          registration: respToken,
-          platform: DeviceInfo.getSystemName(),
-          sdk: DeviceInfo.getBuildNumber(),
-          device_model: DeviceInfo.getModel(),
-          device_manufacturer,
-          os_locale,
-          os_language,
-          os_version: DeviceInfo.getReadableVersion(),
-          app_version: DeviceInfo.getBuildNumber(),
-          app_installed_in,
-          app_updated_in,
-          uuid,
-          phone_Number: phoneNumber,
-          email: email,
-        }
-      };
-
-      const request = subscriptionRequestAdapter(rawRequest, customData, customFields)
-      const subscribe = await subscriptionApi(request, dev);
-      return subscribe;
-    } catch (e) {
-      console.error(e);
-      return { subscribed: false };
+    const respToken = await getFirebaseAccess();
+
+    const { countryCode: osLocale, languageCode: osLanguage } = RNLocalize.getLocales()[0] || {};
+    const deviceManufacturer = await DeviceInfo.getManufacturer();
+    const installTime = await DeviceInfo.getFirstInstallTime();
+    const lastUpdateTime = await DeviceInfo.getLastUpdateTime();
+    const uuid = await DeviceInfo.getUniqueId();
+    const appInstalledIn = formatDate(installTime);
+    const appUpdatedIn = formatDate(lastUpdateTime);
+
+    const subscription = {
+      registerSubscriberRequest: {
+        app_token: appToken,
+        identifier: friendlyIdentifier,
+        registration: respToken,
+        platform: DeviceInfo.getSystemName(),
+        sdk: DeviceInfo.getBuildNumber(),
+        deviceModel: DeviceInfo.getModel(),
+        deviceManufacturer,
+        osLocale,
+        osLanguage,
+        os_version: DeviceInfo.getReadableVersion(),
+        app_version: DeviceInfo.getBuildNumber(),
+        appInstalledIn,
+        appUpdatedIn,
+        uuid,
+        phone_Number: phoneNumber,
+        email: email,
+        customFields: customFields,
+      }
     }
-  },
 
-  SendEvent: async ({
-    appToken,
+    return inngage.apiService.subscribe(subscription);
+  }
+
+  static async sendEvent({
     eventName,
-    identifier,
-    registration,
     conversionEvent,
     conversionValue,
     conversionNotId,
     eventValues,
-  }: SendEventProps) => {
+  }: SendEventProps) {
+    const inngage = Inngage.getInstance();
+
+    const registration = await getFirebaseAccess();
 
-    const rawRequest = {
+    const request = {
       newEventRequest: {
-        app_token: appToken,
-        identifier: identifier,
-        registration: registration,
-        event_name: eventName,
-        conversion_event: conversionEvent ?? false,
-        conversion_value: conversionValue ?? 0,
-        conversion_notid: conversionNotId ?? '',
-        event_values: eventValues ?? {}
-      }
+        appToken: InngageProperties.appToken,
+        identifier: InngageProperties.identifier,
+        registration,
+        eventName,
+        conversionEvent: !!conversionEvent,
+        conversionValue,
+        conversionNotId,
+        eventValues,
+      },
     };
 
-    const request = eventRequest(rawRequest)
-    try {
-      return await eventsApi(request);
-    } catch (e) {
-      console.error(e)
-      return { subscribed: false };
-    }
-  },
+    return inngage.apiService.sendEvent(request);
+  }
+
+  static async addUserData(customFields: any): Promise<any> {
+    const inngage = Inngage.getInstance();
 
-  async addUserData(customFields: any): Promise<any> {
-    const rawRequest = {
+    const request = {
       fieldsRequest: {
-        app_token: InngageProperties.appToken,
+        appToken: InngageProperties.appToken,
         identifier: InngageProperties.identifier,
-        custom_field: customFields ?? {}
-      }
+        customField: customFields,
+      },
     };
 
-    const request = addUserDataRequest(rawRequest);
-    try {
-      return await addUserDataApi(request);
-    } catch (e) {
-      console.error(e);
-    }
-  },
+    return inngage.apiService.addUserData(request);
+  }
 
-  setDebugMode(value: boolean) {
-    InngageProperties.debugMode = value
+  static setDebugMode(value: boolean) {
+    InngageProperties.debugMode = value;
   }
 }
 
-export default Inngage;
+export default Inngage;

package/src/api/api.ts

@@ -0,0 +1,28 @@
+import { fetchClient } from './handler'
+
+const apiEndpoints = {
+    subscription: '/subscription/',
+    notification: '/notification/',
+    events: '/events/newEvent/',
+    addUserData: '/subscription/addCustomField',
+};
+
+const makeApiCall = (method: string, request: any, endpoint: string) => {
+    return fetchClient(method, request, endpoint);
+};
+
+export const subscriptionApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.subscription);
+};
+
+export const notificationApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.notification);
+};
+
+export const eventsApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.events);
+};
+
+export const addUserDataApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.addUserData);
+};

package/src/{services → api}/handler.ts

@@ -30,12 +30,24 @@ const requestConfigFactory = (method, request) => {
   return objToSend
 }
 
-export const fetchClient = (method, requestBody, path, isDev = false): Promise<Response> => {
-  return new Promise((resolve) => {
-    const url = String(baseUrlHook[isDev as any]).concat(path)
-    const request = requestConfigFactory(method, requestBody)
-    fetch(url, request)
-      .then(resolve)
-      .catch(err => console.error('Fetch Error', err))
-  })
-}
+export const fetchClient = async (
+  method: string,
+  requestBody: any,
+  path: string,
+  isDev = false
+): Promise<Response> => {
+  try {
+    const url: URL = new URL(`${baseUrlHook[isDev as any]}${path}`);
+    const request: RequestInit = requestConfigFactory(method, requestBody);
+    const response: Response = await fetch(url, request);
+
+    if (!response.ok) {
+      throw new Error(`Network response was not ok (${response.status})`);
+    }
+
+    return response;
+  } catch (error: any) {
+    console.error('Fetch Error:', error.message);
+    throw error;
+  }
+};

package/src/components/in_app.tsx

@@ -0,0 +1,102 @@
+import * as React from "react";
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  ImageBackground,
+} from "react-native";
+
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+import { buildStyles } from "./styles";
+import { Modal } from "../components/modal";
+
+interface InAppData {
+  inapp_message: boolean
+  title: string
+  body: string
+  title_font_color: string
+  body_font_color: string
+  background_color: string
+  btn_left_txt_color: string
+  btn_left_bg_color: string
+  btn_right_txt_color: string
+  btn_right_bg_color: string
+  background_image: string
+  btn_left_text: string
+  btn_left_action_type: string
+  btn_left_action_link: string
+  btn_right_text: string
+  btn_right_action_type: string
+  btn_right_action_link: string
+  rick_content: string
+  inpression: string
+  bg_img_action_type: string
+  bg_img_action_link: string
+  dot_color: string
+}
+
+export function InAppContainer(): JSX.Element {
+  const [data, setData] = React.useState<InAppData>();
+  const [visible, setVisible] = React.useState(false);
+
+  React.useEffect(() => {
+    const fetchAdditionalData = async () => {
+      try {
+        const data = await AsyncStorage.getItem('inapp');
+        if (data) {
+          const parsedData = JSON.parse(data);
+
+          setVisible(true);
+          setData(parsedData);
+        }
+      } catch (error) {
+        console.error('Error retrieving additionalData from AsyncStorage:', error);
+      }
+    };
+
+    fetchAdditionalData();
+  }, []);
+
+  const styles = buildStyles(data);
+
+  const handleDismissInApp = async () => {
+    await AsyncStorage.removeItem('inapp');
+    setVisible(false);
+  }
+
+  if (data != null)
+    console.log('data in app', data)
+
+  return (
+    <Modal
+      renderToHardwareTextureAndroid={true}
+      transparent={true}
+      visible={visible}>
+      <ImageBackground style={styles.content} source={{ uri: data?.background_image }}>
+        <TouchableOpacity style={styles.closeButton} onPress={handleDismissInApp}>
+          <Text>X</Text>
+        </TouchableOpacity>
+        <View style={styles.messageData}>
+          <Text style={styles.title}>{data?.title}</Text>
+          <Text style={styles.body}>{data?.body}</Text>
+        </View>
+        <View style={styles.footer}>
+          <TouchableOpacity
+            style={styles.buttonLeft}>
+            <Text style={styles.textButton}>{data?.btn_left_text}</Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.buttonRight}>
+            <Text style={styles.textButton}>{data?.btn_right_text}</Text>
+          </TouchableOpacity>
+        </View>
+      </ImageBackground>
+    </Modal>
+  )
+}
+
+
+
+
+