react-native-netmera 1.4.8 → 1.5.0-alpha01

package/android/build.gradle

@@ -16,8 +16,8 @@ android {
 }
 
 dependencies {
-    implementation 'com.netmera:nmcore:3.9.10'
-    implementation 'com.netmera:nmfcm:3.9.3'
+    implementation 'com.netmera:nmcore:3.9.12'
+    implementation 'com.netmera:nmfcm:3.9.4'
     implementation 'com.netmera:nmhms:3.9.5'
     implementation 'com.facebook.react:react-native:+'
 }

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmera.java

@@ -3,12 +3,19 @@ package com.netmera.reactnativesdk;
 import android.content.ContentValues;
 import android.content.Context;
 
+import androidx.startup.AppInitializer;
+
 import com.netmera.Netmera;
 import com.netmera.NetmeraConfiguration;
+import com.netmera.NMInitializer;
+import com.netmera.NMMainModule;
+import com.netmera.nmfcm.NMFCMProviderInitializer;
+import com.netmera.nmhms.NMHMSProviderInitializer;
 
 public class RNNetmera {
 
     public static void initNetmera(RNNetmeraConfiguration netmeraConfiguration) {
+        checkNetmeraComponent(netmeraConfiguration.context);
         Netmera.init(netmeraConfiguration.getNetmeraConfiguration());
         setNetmeraHeaders();
     }
@@ -16,7 +23,15 @@ public class RNNetmera {
     static void setNetmeraHeaders() {
         ContentValues headerValues = new ContentValues();
         headerValues.put("X-netmera-framework", "react");
-        headerValues.put("X-netmera-frameworkV", "1.4.8");
+        headerValues.put("X-netmera-frameworkV", "1.5.0-alpha");
         Netmera.setNetmeraHeaders(headerValues);
     }
+
+    private static void checkNetmeraComponent(Context context) {
+        if (NMMainModule.context == null) {
+            NMInitializer.initializeComponents(context);
+            AppInitializer.getInstance(context).initializeComponent(NMFCMProviderInitializer.class);
+            AppInitializer.getInstance(context).initializeComponent(NMHMSProviderInitializer.class);
+        }
+    }
 }

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraModule.java

@@ -92,6 +92,16 @@ public class RNNetmeraModule extends ReactContextBaseJavaModule {
         Netmera.setBaseUrl(baseUrl);
     }
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public Boolean areNotificationsEnabled() {
+        return Netmera.areNotificationsEnabled();
+    }
+
+    @ReactMethod
+    public void requestPushNotificationAuthorization() {
+        Netmera.requestNotificationPermissions(reactContext.getCurrentActivity());
+    }
+
     @ReactMethod
     public void requestPermissionsForLocation() {
         Netmera.requestPermissionsForLocation();

package/index.ts

@@ -0,0 +1,28 @@
+import Netmera from "./src/Netmera";
+import NetmeraEvent from "./src/models/NetmeraEvent";
+import NetmeraUser, {
+  NMUserGender,
+  NMUserMaritalStatus,
+} from "./src/models/NetmeraUser";
+import NetmeraCategory from "./src/models/NetmeraCategory";
+import NetmeraCategoryFilter from "./src/models/NetmeraCategoryFilter";
+import NetmeraPushInbox from "./src/models/NetmeraInbox";
+import NetmeraInboxFilter from "./src/models/NetmeraInboxFilter";
+import NMInboxStatusCountFilter from "./src/models/NMInboxStatusCountFilter";
+import NMCategoryPreference from "./src/models/NMCategoryPreference";
+import { NMInboxStatus } from "./src/models/NMInboxStatus";
+
+export {
+  Netmera,
+  NetmeraEvent,
+  NetmeraUser,
+  NMUserGender,
+  NMUserMaritalStatus,
+  NetmeraPushInbox,
+  NetmeraInboxFilter,
+  NMInboxStatus,
+  NMInboxStatusCountFilter,
+  NetmeraCategory,
+  NetmeraCategoryFilter,
+  NMCategoryPreference,
+};

package/ios/RNNetmera.m

@@ -46,7 +46,7 @@ NSString *const ERROR_MESSAGE_SET_CATEGORY_PREFERENCE = @"Error occurred while s
 
 + (void)setNetmeraHeaders {
     [Netmera setFramework:@"react"];
-    [Netmera setFrameworkVersion:@"1.4.8"];
+    [Netmera setFrameworkVersion:@"1.5.0-alpha"];
 }
 
 + (void)setPushDelegate:(NSObject<NetmeraPushDelegate> *)delegate {
@@ -91,6 +91,10 @@ RCT_EXPORT_METHOD(requestPushNotificationAuthorization) {
     [Netmera requestPushNotificationAuthorizationForTypes:UIUserNotificationTypeAlert | UIUserNotificationTypeBadge | UIUserNotificationTypeSound];
 }
 
+RCT_EXPORT_METHOD(areNotificationsEnabled:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    resolve(@([Netmera isEnabledReceivingPushNotifications]));
+}
+
 RCT_EXPORT_METHOD(requestPermissionsForLocation) {
     [Netmera requestLocationAuthorization];
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "react-native-netmera",
-  "version": "1.4.8",
+  "version": "1.5.0-alpha01",
   "description": "Netmera React Native SDK",
-  "main": "index.js",
+  "main": "index.ts",
   "author": "netmera",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -13,5 +13,15 @@
     "android",
     "netmera"
   ],
-  "license": ""
+  "license": "",
+  "devDependencies": {
+    "@tsconfig/react-native": "^2.0.3",
+    "@types/jest": "^29.5.0",
+    "@types/react": "^18.0.30",
+    "@types/react-native": "^0.71.5",
+    "@types/react-test-renderer": "^18.0.0",
+    "eslint": "^8.39.0",
+    "prettier": "^2.8.7",
+    "typescript": "^5.0.2"
+  }
 }

package/src/Netmera.ts

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+import {
+  AppRegistry,
+  NativeEventEmitter,
+  NativeModules,
+  NativeModulesStatic,
+  Platform,
+} from "react-native";
+import NetmeraUser from "./models/NetmeraUser";
+import NetmeraEvent from "./models/NetmeraEvent";
+import NetmeraInboxFilter from "./models/NetmeraInboxFilter";
+import NetmeraPushInbox from "./models/NetmeraInbox";
+import NetmeraCategoryFilter from "./models/NetmeraCategoryFilter";
+import NetmeraCategory from "./models/NetmeraCategory";
+import NMInboxStatusCountFilter from "./models/NMInboxStatusCountFilter";
+import NMCategoryPreference from "./models/NMCategoryPreference";
+import { NMInboxStatus } from "./models/NMInboxStatus";
+
+const { RNNetmera, RNNetmeraRCTEventEmitter }: NativeModulesStatic =
+  NativeModules;
+const netmeraRCTEventEmitter: NativeEventEmitter = new NativeEventEmitter(
+  RNNetmeraRCTEventEmitter
+);
+
+export default class Netmera {
+  static initBroadcastReceiver = (
+    onPushRegister?: (message: string) => Promise<void>,
+    onPushReceive?: (message: string) => Promise<void>,
+    onPushOpen?: (message: string) => Promise<void>,
+    onPushDismiss?: (message: string) => Promise<void>,
+    onPushButtonClicked?: (message: string) => Promise<void>,
+    onCarouselObjectSelected?: (message: string) => Promise<void>
+  ) => {
+    if (onPushRegister) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask(
+          "onPushRegister",
+          () => onPushRegister
+        );
+      } else {
+        netmeraRCTEventEmitter.addListener("onPushRegister", onPushRegister);
+      }
+    }
+    if (onPushReceive) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask("onPushReceive", () => onPushReceive);
+      } else {
+        netmeraRCTEventEmitter.addListener("onPushReceive", onPushReceive);
+      }
+    }
+    if (onPushOpen) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask("onPushOpen", () => onPushOpen);
+      } else {
+        netmeraRCTEventEmitter.addListener("onPushOpen", onPushOpen);
+      }
+    }
+    if (onPushDismiss) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask("onPushDismiss", () => onPushDismiss);
+      } else {
+        netmeraRCTEventEmitter.addListener("onPushDismiss", onPushDismiss);
+      }
+    }
+    if (onPushButtonClicked) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask(
+          "onPushButtonClicked",
+          () => onPushButtonClicked
+        );
+      }
+    }
+    if (onCarouselObjectSelected) {
+      if (Platform.OS === "android") {
+        AppRegistry.registerHeadlessTask(
+          "onCarouselObjectSelected",
+          () => onCarouselObjectSelected
+        );
+      }
+    }
+  };
+
+  static currentExternalId = async (): Promise<string> => {
+    return RNNetmera.currentExternalId();
+  };
+
+  static setBaseUrl = (baseUrl: string) => {
+    RNNetmera.setBaseUrl(baseUrl);
+  };
+
+  static areNotificationsEnabled = async (): Promise<boolean> => {
+    return RNNetmera.areNotificationsEnabled();
+  };
+
+  static requestPushNotificationAuthorization = () => {
+    RNNetmera.requestPushNotificationAuthorization();
+  };
+
+  static requestPermissionsForLocation = () => {
+    RNNetmera.requestPermissionsForLocation();
+  };
+
+  static setNetmeraMaxActiveRegions = (maxActiveRegions: number) => {
+    RNNetmera.setNetmeraMaxActiveRegions(maxActiveRegions);
+  };
+
+  static enablePopupPresentation = () => {
+    RNNetmera.enablePopupPresentation();
+  };
+
+  static disablePopupPresentation = () => {
+    RNNetmera.disablePopupPresentation();
+  };
+
+  static isPushEnabled = async (): Promise<boolean> => {
+    return RNNetmera.isPushEnabled();
+  };
+
+  static enablePush = () => {
+    RNNetmera.enablePush();
+  };
+
+  static disablePush = () => {
+    RNNetmera.disablePush();
+  };
+
+  static turnOffSendingEventAndUserUpdate = (turnOff: boolean) => {
+    if (Platform.OS === "android") {
+      RNNetmera.turnOffSendingEventAndUserUpdate(turnOff);
+    }
+  };
+
+  static fetchInbox = (
+    netmeraInboxFilter: NetmeraInboxFilter
+  ): Promise<Array<NetmeraPushInbox>> => {
+    return RNNetmera.fetchInbox(netmeraInboxFilter);
+  };
+
+  static fetchNextPage = (): Promise<Array<NetmeraPushInbox>> => {
+    return RNNetmera.fetchNextPage();
+  };
+
+  static countForStatus = (status: number = NMInboxStatus.STATUS_UNREAD) => {
+    return RNNetmera.countForStatus(status);
+  };
+
+  static inboxUpdateStatus = (
+    fromIndex: number,
+    toIndex: number,
+    status: number = NMInboxStatus.STATUS_UNREAD
+  ) => {
+    return RNNetmera.inboxUpdateStatus(fromIndex, toIndex, status);
+  };
+
+  static fetchCategory = (
+    categoryFilter: NetmeraCategoryFilter
+  ): Promise<Array<NetmeraCategory>> => {
+    return RNNetmera.fetchCategory(categoryFilter);
+  };
+
+  static fetchNextCategoryPage = (): Promise<Array<NetmeraCategory>> => {
+    return RNNetmera.fetchNextCategoryPage();
+  };
+
+  static sendEvent = (event: NetmeraEvent) => {
+    RNNetmera.sendEvent(event);
+  };
+
+  static updateUser = (user: NetmeraUser) => {
+    RNNetmera.updateUser(user);
+  };
+
+  static updateAll = (inboxStatus: number) => {
+    return RNNetmera.updateAll(inboxStatus);
+  };
+
+  static handlePushObject = (pushId: string) => {
+    RNNetmera.handlePushObject(pushId);
+  };
+
+  static handleInteractiveAction = (pushId: string) => {
+    RNNetmera.handleInteractiveAction(pushId);
+  };
+
+  static setApiKey = (apiKey: string) => {
+    RNNetmera.setApiKey(apiKey);
+  };
+
+  static handleLastMessage = (categoryName: string) => {
+    RNNetmera.handleLastMessage(categoryName);
+  };
+
+  static updateStatusByCategories = (
+    fromIndex: number,
+    toIndex: number,
+    status: number = NMInboxStatus.STATUS_UNREAD
+  ) => {
+    return RNNetmera.updateStatusByCategories(fromIndex, toIndex, status);
+  };
+
+  static getInboxCountForStatus = (
+    nmInboxStatusCountFilter: NMInboxStatusCountFilter
+  ) => {
+    return RNNetmera.getInboxCountForStatus(nmInboxStatusCountFilter);
+  };
+
+  static getUserCategoryPreferenceList = (): Promise<
+    Array<NMCategoryPreference>
+  > => {
+    return RNNetmera.getUserCategoryPreferenceList();
+  };
+
+  static setUserCategoryPreference = (
+    categoryId: number,
+    categoryEnabled: boolean
+  ) => {
+    return RNNetmera.setUserCategoryPreference(categoryId, categoryEnabled);
+  };
+
+  static onNetmeraFirebasePushMessageReceived = (
+    from?: string,
+    data?: { [key: string]: string }
+  ) => {
+    if (Platform.OS === "android" && data) {
+      data["google.c.sender.id"] = from ?? "";
+      RNNetmera.onNetmeraPushMessageReceived(data);
+    }
+  };
+
+  static onNetmeraHuaweiPushMessageReceived = (
+    from?: string,
+    data?: { [key: string]: string }
+  ) => {
+    if (Platform.OS === "android" && data) {
+      data["_nm"] = JSON.stringify(data["_nm"]);
+      data["from"] = from ?? "";
+      RNNetmera.onNetmeraPushMessageReceived(data);
+    }
+  };
+
+  static onNetmeraNewToken = (pushToken: string) => {
+    if (Platform.OS === "android") {
+      RNNetmera.onNetmeraNewToken(pushToken);
+    }
+  };
+
+  static isNetmeraRemoteMessage(data?: { [key: string]: string }): boolean {
+    return (
+      Platform.OS === "android" &&
+      data != undefined &&
+      data.hasOwnProperty("_nm")
+    );
+  }
+}

package/src/models/NMCategoryPreference.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NMCategoryPreference {
+  categoryId?: number;
+  categoryName?: string;
+  optInStatus?: boolean;
+}

package/src/models/NMInboxStatus.ts

@@ -0,0 +1,7 @@
+export enum NMInboxStatus {
+  STATUS_READ = 1,
+  STATUS_UNREAD = 2,
+  STATUS_READ_OR_UNREAD = 3,
+  STATUS_DELETED = 4,
+  STATUS_ALL = 7,
+}

package/src/models/NMInboxStatusCountFilter.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NMInboxStatusCountFilter {
+  status?: number;
+  categoryList?: number[];
+  includeExpired?: boolean;
+
+  set nmInboxStatus(nmInboxStatus: number) {
+    this.status = nmInboxStatus;
+  }
+}

package/src/models/NetmeraCategory.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+import NetmeraPushInbox from "./NetmeraInbox";
+
+export default class NetmeraCategory {
+  categoryName?: string;
+  categoryStatus?: string;
+  lastMessage?: NetmeraPushInbox;
+  readCount?: number;
+  deletedCount?: number;
+  unreadCount?: number;
+}

package/src/models/NetmeraCategoryFilter.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NetmeraCategoryFilter {
+  pageSize?: number;
+  status?: number;
+  includeExpiredObjects?: boolean;
+}

package/src/models/NetmeraEvent.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default abstract class NetmeraEvent {
+  abstract code: string;
+}

package/src/models/NetmeraInbox.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NetmeraPushInbox {
+  title?: string;
+  subtitle?: string;
+  body?: string;
+  pushType?: number;
+  pushId?: string;
+  pushInstanceId?: string;
+  sendDate?: string;
+  inboxStatus?: number;
+  deepLink?: string;
+  webPage?: string;
+  externalId?: string;
+  customJson?: Map<any, any>;
+  pushAction?: Map<any, any>;
+  carousel?: any[];
+  mediaAttachmentURL?: string;
+  category?: string;
+  categories?: any[];
+  interactiveActions?: any[];
+  expireTime?: string;
+}

package/src/models/NetmeraInboxFilter.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NetmeraInboxFilter {
+  pageSize?: number;
+  status?: number;
+  categories?: string[];
+  includeExpiredObjects?: boolean;
+}

package/src/models/NetmeraUser.ts

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2023 Netmera Research.
+ */
+
+export default class NetmeraUser {
+  private pa?: string;
+  private pb?: string;
+  private pc?: string[];
+  private pd?: number;
+  private pe?: number;
+  private pf?: number;
+  private pg?: number;
+  private ph?: string;
+  private pi?: string;
+  private pj?: string;
+  private pk?: string;
+  private pl?: string;
+  private pm?: string;
+  private pn?: string;
+  private po?: string;
+  userId?: string;
+  msisdn?: string;
+  email?: string;
+
+  set name(value: string) {
+    this.pa = value;
+  }
+
+  set surname(value: string) {
+    this.pb = value;
+  }
+
+  set externalSegments(value: string[]) {
+    this.pc = value;
+  }
+
+  set gender(value: number) {
+    this.pd = value;
+  }
+
+  set dateOfBirth(value: number) {
+    this.pe = value;
+  }
+
+  set maritalStatus(value: number) {
+    this.pf = value;
+  }
+
+  set childCount(value: number) {
+    this.pg = value;
+  }
+
+  set country(value: string) {
+    this.ph = value;
+  }
+
+  set state(value: string) {
+    this.pi = value;
+  }
+
+  set city(value: string) {
+    this.pj = value;
+  }
+
+  set district(value: string) {
+    this.pk = value;
+  }
+
+  set occupation(value: string) {
+    this.pl = value;
+  }
+
+  set industry(value: string) {
+    this.pm = value;
+  }
+
+  set favoriteTeam(value: string) {
+    this.pn = value;
+  }
+
+  set language(value: string) {
+    this.po = value;
+  }
+}
+
+export enum NMUserGender {
+  MALE = 0,
+  FEMALE = 1,
+  NOT_SPECIFIED = 2,
+}
+
+export enum NMUserMaritalStatus {
+  SINGLE = 0,
+  MARRIED = 1,
+  NOT_SPECIFIED = 2,
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@tsconfig/react-native/tsconfig.json"
+}

package/index.js

@@ -1,19 +0,0 @@
-import Netmera from "./src/Netmera";
-import NetmeraUser from "./src/NetmeraUser";
-import {
-    NetmeraCategory,
-    NetmeraCategoryFilter,
-    NetmeraInboxFilter,
-    NetmeraPushInbox,
-    NMInboxStatus
-} from "./src/NetmeraInbox";
-
-module.exports = {
-    Netmera,
-    NetmeraUser,
-    NetmeraInboxFilter,
-    NetmeraCategoryFilter,
-    NetmeraPushInbox,
-    NetmeraCategory,
-    NMInboxStatus,
-};