react-native-netmera 1.11.3 → 2.0.0-alpha01

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraEvent.kt

@@ -0,0 +1,24 @@
+package com.netmera.reactnativesdk
+
+import com.google.gson.annotations.SerializedName
+import com.netmera.NetmeraEvent
+
+class RNNetmeraEvent : NetmeraEvent() {
+  @SerializedName("prms")
+  private var eventParameters: MutableMap<String?, Any?>? = null
+
+  @SerializedName("code")
+  private var code: String? = null
+
+  fun setEventParameters(eventParameters: MutableMap<String?, Any?>?) {
+    this.eventParameters = eventParameters
+  }
+
+  fun setCode(code: String) {
+    this.code = code
+  }
+
+  override fun eventCode(): String {
+    return code!!
+  }
+}

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

@@ -0,0 +1,694 @@
+package com.netmera.reactnativesdk
+
+import android.app.Activity
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.firebase.messaging.RemoteMessage
+import com.netmera.InternalNetmera
+import com.netmera.NMUser
+import com.netmera.Netmera
+import com.netmera.NetmeraError
+import com.netmera.NetmeraInbox
+import com.netmera.NetmeraInboxCategory
+import com.netmera.NetmeraInboxFilter
+import com.netmera.callbacks.NMCategoryPreferenceFetchCallback
+import com.netmera.callbacks.NMCategoryPreferenceSetCallback
+import com.netmera.callbacks.NMFetchCouponsResultListener
+import com.netmera.callbacks.NMInboxCountResultListener
+import com.netmera.callbacks.NMPermissionResultListener
+import com.netmera.callbacks.NMUpdateUserListener
+import com.netmera.callbacks.NMUpdateUserProfileListener
+import com.netmera.data.NMCategoryPreference
+import com.netmera.data.NMInboxStatusCount
+import com.netmera.data.NMInboxStatusCountFilter
+import com.netmera.reactnativesdk.RNNetmeraUtil.getInboxStatus
+import com.netmera.reactnativesdk.RNNetmeraUtil.mapPushObjects
+import com.netmera.reactnativesdk.RNNetmeraUtil.parseInboxCountForStatusToMap
+import com.netmera.reactnativesdk.RNNetmeraUtil.toMap
+
+class RNNetmeraModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  init {
+    Companion.reactContext = reactContext
+  }
+
+  private var netmeraInbox: NetmeraInbox? = null
+  private var netmeraInboxCategory: NetmeraInboxCategory? = null
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun currentExternalId(promise: Promise) {
+    promise.resolve(Netmera.getCurrentExternalId())
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun checkNotificationPermission(): String {
+    val activity: Activity? = reactContext.currentActivity
+    return if (activity != null) {
+      Netmera.checkNotificationPermission(activity).toString()
+    } else {
+      Log.e(NAME, "Cannot call checkNotificationPermission because current ReactActivity is null")
+      "null"
+    }
+  }
+
+  @ReactMethod
+  fun requestPushNotificationAuthorization(promise: Promise) {
+    val activity: Activity? = reactContext.currentActivity
+    if (activity == null) {
+      promise.reject(
+        ERROR_CODE_INVALID_ACTIVITY,
+        ERROR_MESSAGE_INVALID_ACTIVITY,
+        null
+      )
+      return
+    }
+    Netmera.requestNotificationPermissions(
+      activity,
+      object : NMPermissionResultListener {
+        override fun onSuccess(isAllowed: Boolean) {
+          promise.resolve(isAllowed)
+        }
+
+        override fun onFailure(error: String?) {
+          promise.reject(
+            ERROR_CODE_NOTIFICATION_PERMISSION,
+            ERROR_MESSAGE_NOTIFICATION_PERMISSION + error.let { "Reason: $it" },
+          )
+        }
+      }
+    )
+  }
+
+  @ReactMethod
+  fun requestPermissionsForLocation() {
+    Netmera.requestPermissionsForLocation()
+  }
+
+  @ReactMethod
+  fun setNetmeraMaxActiveRegions(maxActiveRegions: Int) {
+    Netmera.setNetmeraMaxActiveRegions(maxActiveRegions)
+  }
+
+  @ReactMethod
+  fun enablePopupPresentation() {
+    Netmera.enablePopupPresentation()
+  }
+
+  @ReactMethod
+  fun disablePopupPresentation() {
+    Netmera.disablePopupPresentation()
+  }
+
+  @ReactMethod
+  fun dismissAllPresentations() {
+    Netmera.dismissAllPresentations()
+  }
+
+  @ReactMethod
+  fun enablePush() {
+    Netmera.enablePush()
+  }
+
+  @ReactMethod
+  fun disablePush() {
+    Netmera.disablePush()
+  }
+
+  @ReactMethod
+  fun isPushEnabled(promise: Promise) {
+    promise.resolve(Netmera.isPushEnabled())
+  }
+
+  @ReactMethod
+  fun kill() {
+    Netmera.kill()
+  }
+
+  @ReactMethod
+  fun fetchCoupons(page: Int, max: Int, promise: Promise) {
+    Netmera.fetchCoupons(page, max, object : NMFetchCouponsResultListener {
+      override fun onSuccess(coupons: List<com.netmera.data.NMCouponDetail>?) {
+        promise.resolve(RNNetmeraUtil.mapCouponObjects(coupons ?: emptyList()))
+      }
+
+      override fun onFailure(error: String?) {
+        promise.reject(ERROR_CODE_COUPON_FETCH, ERROR_MESSAGE_COUPON_FETCH)
+      }
+    })
+  }
+
+  @ReactMethod
+  fun fetchInbox(readableMap: ReadableMap, promise: Promise) {
+    val builder = NetmeraInboxFilter.Builder()
+
+    if (hasKey(readableMap, CATEGORIES)) {
+      val categories = readableMap.toHashMap()[CATEGORIES]
+      when (categories) {
+        is String -> builder.categories(listOf(categories))
+        is List<*> -> builder.categories(categories.filterIsInstance<String>())
+      }
+    }
+
+    if (hasKey(readableMap, STATUS)) {
+      builder.status(readableMap.getInt(STATUS))
+    }
+
+    if (hasKey(readableMap, PAGE_SIZE)) {
+      builder.pageSize(readableMap.getInt(PAGE_SIZE))
+    }
+
+    if (hasKey(readableMap, INCLUDE_EXPIRED_OBJECTS)) {
+      builder.includeExpiredObjects(readableMap.getBoolean(INCLUDE_EXPIRED_OBJECTS))
+    }
+
+    val filter = builder.build()
+
+    Netmera.fetchInbox(
+      filter
+    ) { inbox, netmeraError -> setInbox(inbox, netmeraError, promise) }
+  }
+
+  @ReactMethod
+  fun fetchNextPage(promise: Promise) {
+    if (netmeraInbox == null) {
+      promise.reject(ERROR_CODE_NULL_INBOX, ERROR_MESSAGE_NULL_INBOX)
+      return
+    }
+
+    if (netmeraInbox!!.hasNextPage()) {
+      netmeraInbox!!.fetchNextPage { netmeraInbox, error -> setInbox(netmeraInbox, error, promise) }
+    } else {
+      promise.reject(ERROR_CODE_NOT_NEXT_PAGE, ERROR_MESSAGE_NOT_NEXT_PAGE)
+    }
+  }
+
+  @ReactMethod
+  fun countForStatus(status: Int, promise: Promise) {
+    if (netmeraInbox == null) {
+      promise.reject(ERROR_CODE_NULL_INBOX, ERROR_MESSAGE_NULL_INBOX)
+      return
+    }
+
+    promise.resolve(netmeraInbox!!.countForStatus(status))
+  }
+
+  @ReactMethod
+  fun inboxUpdateStatus(fromIndex: Int, toIndex: Int, status: Int, promise: Promise) {
+    if (netmeraInbox == null) {
+      promise.reject(ERROR_CODE_NULL_INBOX, ERROR_MESSAGE_NULL_INBOX)
+      return
+    }
+
+    try {
+      val pushObjects = netmeraInbox!!.pushObjects().subList(fromIndex, toIndex)
+      netmeraInbox!!.updateStatus(
+        pushObjects, status
+      ) { netmeraError ->
+        if (netmeraError == null) {
+          promise.resolve(null)
+        } else {
+          promise.reject(ERROR_CODE_UPDATE_STATUS, ERROR_MESSAGE_UPDATE_STATUS)
+        }
+      }
+    } catch (e: IndexOutOfBoundsException) {
+      promise.reject("", e.message)
+    }
+  }
+
+  @ReactMethod
+  fun fetchCategory(readableMap: ReadableMap, promise: Promise) {
+    Netmera.fetchCategory(
+      RNNetmeraCategoryObject.getInboxObject(readableMap)
+    ) { netmeraInboxCategory, netmeraError ->
+      setCategory(
+        netmeraInboxCategory,
+        netmeraError,
+        promise
+      )
+    }
+  }
+
+  @ReactMethod
+  fun fetchNextCategoryPage(promise: Promise) {
+    if (netmeraInboxCategory == null) {
+      promise.reject(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY)
+      return
+    }
+
+    if (netmeraInboxCategory!!.hasNextPage()) {
+      netmeraInboxCategory!!.fetchNextPage { netmeraInboxCategory, netmeraError ->
+        setCategory(
+          netmeraInboxCategory,
+          netmeraError,
+          promise
+        )
+      }
+    } else {
+      promise.reject(ERROR_CODE_NOT_NEXT_PAGE, ERROR_MESSAGE_NOT_NEXT_PAGE)
+    }
+  }
+
+  @ReactMethod
+  fun handleLastMessage(categoryName: String?, promise: Promise) {
+    if (netmeraInboxCategory == null) {
+      promise.reject(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY)
+      return
+    }
+
+    if (categoryName == null || categoryName.isEmpty()) {
+      promise.reject(ERROR_CODE_INVALID_PUSH_OBJECT, ERROR_MESSAGE_INVALID_PUSH_OBJECT)
+      return
+    }
+
+    for (category in netmeraInboxCategory!!.categories()) {
+      if (categoryName == category.categoryName) {
+        Netmera.handlePushObject(reactApplicationContext.currentActivity!!, category.lastMessage)
+        break
+      }
+    }
+  }
+
+  @ReactMethod
+  fun updateStatusByCategories(fromIndex: Int, toIndex: Int, status: Int, promise: Promise) {
+    if (netmeraInboxCategory == null) {
+      promise.reject(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY)
+      return
+    }
+
+    try {
+      val categoryNames: MutableList<String?> = ArrayList()
+
+      for (category in netmeraInboxCategory!!.categories().subList(fromIndex, toIndex)) {
+        categoryNames.add(category.categoryName)
+      }
+
+      Netmera.updateStatusByCategories(
+        status, categoryNames
+      ) { netmeraError ->
+        if (netmeraError == null) {
+          promise.resolve(null)
+        } else {
+          promise.reject(ERROR_CODE_UPDATE_STATUS, ERROR_MESSAGE_UPDATE_STATUS)
+        }
+      }
+    } catch (e: java.lang.IndexOutOfBoundsException) {
+      promise.reject("", e.message)
+    }
+  }
+
+  @ReactMethod
+  fun updateAll(inboxStatus: Int, promise: Promise) {
+    Netmera.updateAll(inboxStatus) { netmeraError ->
+      if (netmeraError != null) {
+        promise.reject(ERROR_CODE_UPDATE_STATUS, ERROR_MESSAGE_UPDATE_STATUS)
+      } else {
+        promise.resolve(true)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun identifyUser(readableMap: ReadableMap, hasCallback: Boolean, promise: Promise) {
+    val userMap = toMap(readableMap)
+    val netmeraUser = NMUser()
+
+    if (userMap.containsKey(USER_ID)) {
+      netmeraUser.setUserId(userMap[USER_ID] as? String)
+    }
+    if (userMap.containsKey(EMAIL)) {
+      netmeraUser.setEmail(userMap[EMAIL] as? String)
+    }
+    if (userMap.containsKey(MSISDN)) {
+      netmeraUser.setMsisdn(userMap[MSISDN] as? String)
+    }
+    if (userMap.containsKey(WP_NUMBER)) {
+      netmeraUser.setWhatsAppNumber(userMap[WP_NUMBER] as? String)
+    }
+
+    if (hasCallback) {
+      Netmera.identifyUser(netmeraUser, object : NMUpdateUserListener {
+        override fun onSuccess() {
+          promise.resolve(null)
+        }
+
+        override fun onFailure(error: String?) {
+          promise.reject(ERROR_CODE_UPDATE_USER, ERROR_MESSAGE_UPDATE_USER + (error ?: ""))
+        }
+      })
+    } else {
+      Netmera.identifyUser(netmeraUser)
+    }
+  }
+
+  @ReactMethod
+  fun updateUserProfile(readableMap: ReadableMap, hasCallback: Boolean, promise: Promise) {
+    val userProfileMap = toMap(readableMap)
+
+    if (hasCallback) {
+      InternalNetmera.updateUserProfile(userProfileMap, object : NMUpdateUserProfileListener {
+        override fun onSuccess() {
+          promise.resolve(null)
+        }
+
+        override fun onFailure(error: String?) {
+          promise.reject(ERROR_CODE_UPDATE_PROFILE, ERROR_MESSAGE_UPDATE_PROFILE + (error ?: ""))
+        }
+      })
+    } else {
+      InternalNetmera.updateUserProfile(userProfileMap)
+    }
+  }
+
+  @ReactMethod
+  fun handlePushObject(pushId: String?) {
+    if (netmeraInbox == null) {
+      return
+    }
+
+    for (pushObject in netmeraInbox!!.pushObjects()) {
+      if (pushObject.pushId == pushId) {
+        Netmera.handlePushObject(reactApplicationContext.currentActivity!!, pushObject)
+        break
+      }
+    }
+  }
+
+  @ReactMethod
+  fun handleInteractiveAction(interactiveActionId: String?) {
+    if (netmeraInbox == null) {
+      return
+    }
+
+    for (pushObject in netmeraInbox!!.pushObjects()) {
+      if (pushObject.interactiveActions != null) {
+        for (action in pushObject.interactiveActions) {
+          if (action.id == interactiveActionId) {
+            Netmera.handleInteractiveAction(reactApplicationContext, action)
+            return
+          }
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun sendEvent(readableMap: ReadableMap?) {
+    val eventMap = toMap(readableMap).toMutableMap()
+    val event = RNNetmeraEvent()
+
+    if (eventMap.containsKey(CODE)) {
+      event.setCode(readableMap?.getString(CODE)!!)
+      eventMap.remove(CODE)
+    }
+
+    if (eventMap.containsKey(REVENUE)) {
+      event.setRevenue(readableMap?.getDouble(REVENUE) ?: 0.0)
+      eventMap.remove(REVENUE)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    event.setEventParameters(eventMap as MutableMap<String?, Any?>)
+    Netmera.sendEvent(event)
+  }
+
+  @ReactMethod
+  fun sendGenericEvent(code: String, attributes: ReadableMap?) {
+    val attrs = toMap(attributes)
+      .filterValues { it != null }
+      .mapValues { it.value!! }
+    Netmera.sendEvent(code, attrs)
+  }
+
+  @ReactMethod
+  fun getInboxCountForStatus(readableMap: ReadableMap, promise: Promise) {
+    val builder = NMInboxStatusCountFilter.Builder()
+
+    if (readableMap.hasKey(CATEGORY_LIST)) {
+      val categoryList = readableMap.toHashMap()[CATEGORY_LIST] as? ArrayList<Double>
+      categoryList?.let {
+        val categoryArray = Array(it.size) { i -> it[i].toInt() }
+        builder.setCategoryList(categoryArray)
+      }
+    }
+
+    if (readableMap.hasKey(STATUS)) {
+      builder.setInboxStatus(getInboxStatus(readableMap.getInt(STATUS)))
+    } else {
+      promise.reject(ERROR_CODE_NULL_INBOX_STATUS, ERROR_MESSAGE_NULL_INBOX_STATUS)
+      return
+    }
+
+    if (readableMap.hasKey(INCLUDE_EXPIRED_OBJECTS)) {
+      builder.setIncludeExpired(readableMap.getBoolean(INCLUDE_EXPIRED_OBJECTS))
+    }
+
+    val filter = builder.build()
+
+    Netmera.getInboxCountForStatus(filter, object : NMInboxCountResultListener {
+      override fun onSuccess(inboxStatusCount: NMInboxStatusCount) {
+        promise.resolve(parseInboxCountForStatusToMap(inboxStatusCount))
+      }
+
+      override fun onFailure(s: String?) {
+        promise.reject(ERROR_CODE_INBOX_STATUS, ERROR_MESSAGE_INBOX_STATUS)
+      }
+    })
+  }
+
+  @ReactMethod
+  fun getUserCategoryPreferenceList(promise: Promise) {
+    Netmera.getUserCategoryPreferenceList(object : NMCategoryPreferenceFetchCallback {
+      override fun onSuccess(list: MutableList<NMCategoryPreference>) {
+        promise.resolve(RNNetmeraUtil.parseUserCategoryPreferenceListToMap(list))
+      }
+
+      override fun onFailure(s: String?) {
+        promise.reject(ERROR_CODE_CATEGORY_PREFERENCE, ERROR_MESSAGE_CATEGORY_PREFERENCE)
+      }
+    })
+  }
+
+  @ReactMethod
+  fun setUserCategoryPreference(categoryId: Int, categoryEnabled: Boolean, promise: Promise) {
+    Netmera.setUserCategoryPreference(
+      categoryId,
+      categoryEnabled,
+      object : NMCategoryPreferenceSetCallback {
+        override fun onSuccess() {
+          promise.resolve(true)
+        }
+
+        override fun onFailure(s: String?) {
+          promise.reject(ERROR_CODE_SET_CATEGORY_PREFERENCE, ERROR_MESSAGE_SET_CATEGORY_PREFERENCE)
+        }
+      })
+  }
+
+  @ReactMethod
+  fun onNetmeraPushMessageReceived(map: ReadableMap) {
+    val data: MutableMap<String?, String?> = HashMap<String?, String?>()
+
+    val bundle = Bundle()
+    for (key in map.toHashMap().keys) {
+      data.put(key, map.getString(key))
+      bundle.putString(key, map.getString(key))
+    }
+
+    if (data.containsKey("google.c.sender.id")) {
+      Netmera.onNetmeraPushMessageReceived(RemoteMessage(bundle))
+    } else {
+      val builder = com.huawei.hms.push.RemoteMessage.Builder("to")
+      builder.setData(data)
+      Netmera.onNetmeraPushMessageReceived(builder.build())
+    }
+  }
+
+  @ReactMethod
+  fun onNetmeraNewToken(pushToken: String?) {
+    Netmera.onNetmeraNewToken(pushToken)
+  }
+
+  @ReactMethod
+  fun startDataTransfer() {
+    Netmera.startDataTransfer()
+  }
+
+  @ReactMethod
+  fun stopDataTransfer() {
+    Netmera.stopDataTransfer()
+  }
+
+  @ReactMethod
+  fun setEmailPermission(isAllowed: Boolean, promise: Promise) {
+    try {
+      Netmera.setEmailPermission(isAllowed)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ERROR_CODE_EMAIL_PERMISSION, ERROR_MESSAGE_EMAIL_PERMISSION)
+    }
+  }
+
+  @ReactMethod
+  fun getEmailPermission(promise: Promise) {
+    Netmera.getEmailPermission(object : NMPermissionResultListener {
+      override fun onSuccess(isAllowed: Boolean) {
+        promise.resolve(isAllowed)
+      }
+
+      override fun onFailure(error: String?) {
+        promise.reject(ERROR_CODE_EMAIL_PERMISSION, ERROR_MESSAGE_EMAIL_PERMISSION)
+      }
+    })
+  }
+
+  @ReactMethod
+  fun setSmsPermission(isAllowed: Boolean, promise: Promise) {
+    try {
+      Netmera.setSmsPermission(isAllowed)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ERROR_CODE_SMS_PERMISSION,  ERROR_MESSAGE_SMS_PERMISSION)
+    }
+  }
+
+  @ReactMethod
+  fun getSmsPermission(promise: Promise) {
+    Netmera.getSmsPermission(object : NMPermissionResultListener {
+      override fun onSuccess(isAllowed: Boolean) {
+        promise.resolve(isAllowed)
+      }
+
+      override fun onFailure(error: String?) {
+        promise.reject(ERROR_CODE_SMS_PERMISSION, ERROR_MESSAGE_SMS_PERMISSION)
+      }
+    })
+  }
+
+  @ReactMethod
+  fun setWhatsAppPermission(isAllowed: Boolean, promise: Promise) {
+    try {
+      Netmera.setWhatsAppPermission(isAllowed)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ERROR_CODE_WHATSAPP_PERMISSION, ERROR_MESSAGE_WHATSAPP_PERMISSION)
+    }
+  }
+
+  @ReactMethod
+  fun getWhatsAppPermission(promise: Promise) {
+    Netmera.getWhatsAppPermission(object : NMPermissionResultListener {
+      override fun onSuccess(isAllowed: Boolean) {
+        promise.resolve(isAllowed)
+      }
+
+      override fun onFailure(error: String?) {
+        promise.reject(ERROR_CODE_WHATSAPP_PERMISSION, ERROR_MESSAGE_WHATSAPP_PERMISSION)
+      }
+    })
+  }
+
+  private fun setInbox(inbox: NetmeraInbox, netmeraError: NetmeraError?, promise: Promise) {
+    netmeraInbox = inbox
+    if (netmeraError != null) {
+      promise.reject(ERROR_CODE_NULL_INBOX, ERROR_MESSAGE_NULL_INBOX)
+      return
+    }
+    promise.resolve(mapPushObjects(inbox.pushObjects()))
+  }
+
+  private fun setCategory(
+    nmInboxCategory: NetmeraInboxCategory?,
+    netmeraError: NetmeraError?,
+    promise: Promise
+  ) {
+    if (netmeraError != null) {
+      promise.reject(ERROR_CODE_NULL_INBOX, ERROR_MESSAGE_NULL_INBOX)
+      return
+    }
+    netmeraInboxCategory = nmInboxCategory
+    promise.resolve(RNNetmeraCategoryObject.mapCategoryObjects(netmeraInboxCategory!!.categories()))
+  }
+
+  companion object {
+    const val NAME = "RNNetmera"
+
+    const val USER_ID: String = "userId"
+    const val EMAIL: String = "email"
+    const val MSISDN: String = "msisdn"
+    const val WP_NUMBER: String = "wpNumber"
+    const val CODE: String = "code"
+    const val CATEGORIES: String = "categories"
+    const val CATEGORY_LIST: String = "categoryList"
+    const val PAGE_SIZE: String = "pageSize"
+    const val REVENUE: String = "revenue"
+    const val INCLUDE_EXPIRED_OBJECTS: String = "includeExpiredObjects"
+    const val STATUS: String = "status"
+
+    const val ERROR_CODE_NULL_INBOX = "2017"
+    const val ERROR_MESSAGE_NULL_INBOX = "Must call fetchInbox method first"
+    const val ERROR_CODE_NOT_NEXT_PAGE = "2018"
+    const val ERROR_MESSAGE_NOT_NEXT_PAGE = "Not next page"
+    const val ERROR_CODE_UPDATE_STATUS = "2019"
+    const val ERROR_MESSAGE_UPDATE_STATUS = "There was a problem updating status"
+    const val ERROR_CODE_NULL_CATEGORY = "2020"
+    const val ERROR_MESSAGE_NULL_CATEGORY = "Must call fetchCategory method first"
+    const val ERROR_CODE_INVALID_PUSH_OBJECT = "2021"
+    const val ERROR_MESSAGE_INVALID_PUSH_OBJECT = "Received NetmeraPushObject was not valid."
+    const val ERROR_CODE_NULL_INBOX_STATUS = "2022"
+    const val ERROR_MESSAGE_NULL_INBOX_STATUS = "Inbox status can't be null."
+    const val ERROR_CODE_INBOX_STATUS = "2023"
+    const val ERROR_MESSAGE_INBOX_STATUS = "Error occurred while fetching inbox count for status."
+    const val ERROR_CODE_CATEGORY_PREFERENCE = "2024"
+    const val ERROR_MESSAGE_CATEGORY_PREFERENCE =
+      "Error occurred while fetching user category preference list."
+    const val ERROR_CODE_SET_CATEGORY_PREFERENCE = "2025"
+    const val ERROR_MESSAGE_SET_CATEGORY_PREFERENCE =
+      "Error occurred while setting user category preference list."
+    const val ERROR_CODE_COUPON_FETCH = "2026"
+    const val ERROR_MESSAGE_COUPON_FETCH = "Error occurred while fetching coupons."
+    const val ERROR_CODE_UPDATE_USER = "2027"
+    const val ERROR_MESSAGE_UPDATE_USER = "Error occurred while updating user. Reason: "
+    const val ERROR_CODE_UPDATE_PROFILE = "2028"
+    const val ERROR_MESSAGE_UPDATE_PROFILE = "Error occurred while updating user profile attributes. Reason: "
+    const val ERROR_CODE_EMAIL_PERMISSION = "2030"
+    const val ERROR_MESSAGE_EMAIL_PERMISSION = "Error occurred while getting/setting email permission."
+
+    const val ERROR_CODE_SMS_PERMISSION = "2031"
+    const val ERROR_MESSAGE_SMS_PERMISSION = "Error occurred while getting/setting SMS permission."
+
+    const val ERROR_CODE_WHATSAPP_PERMISSION = "2032"
+    const val ERROR_MESSAGE_WHATSAPP_PERMISSION = "Error occurred while getting/setting WhatsApp permission."
+
+    const val ERROR_CODE_INVALID_ACTIVITY = "2029"
+    const val ERROR_MESSAGE_INVALID_ACTIVITY = "Invalid argument: activity is null"
+
+    const val ERROR_CODE_NOTIFICATION_PERMISSION = "2033"
+    const val ERROR_MESSAGE_NOTIFICATION_PERMISSION =
+      "Error occurred while requesting notification permission. "
+
+    private lateinit var reactContext: ReactApplicationContext
+
+    fun emitEvent(eventName: String, eventData: String) {
+      reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(eventName, eventData)
+    }
+
+    private fun hasKey(map: MutableMap<*, *>, key: String?): Boolean {
+      return map.containsKey(key) && map[key] != null
+    }
+
+    private fun hasKey(map: ReadableMap, key: String): Boolean {
+      return map.hasKey(key) && !map.isNull(key)
+    }
+  }
+}