react-native-netmera 1.11.3 → 2.0.0-alpha02

package/ios/RNNetmera.swift

@@ -0,0 +1,759 @@
+import NetmeraCore
+import NetmeraNotification
+import NetmeraAnalytic
+import NetmeraGeofence
+import NetmeraLocation
+import NetmeraAdvertisingId
+import NetmeraNotificationInbox
+import NetmeraAnalyticAutotracking
+import NetmeraNotificationCore
+
+let ERROR_CODE_INBOX = "2016"
+let ERROR_MESSAGE_INBOX = "There was a problem fetching inbox"
+
+let ERROR_CODE_INBOX_NULL = "2017"
+let ERROR_MESSAGE_INBOX_NULL = "Inbox is null or invalid status"
+
+let ERROR_CODE_NOT_NEXT_PAGE = "2018"
+let ERROR_MESSAGE_NOT_NEXT_PAGE = "Not next page"
+
+let ERROR_CODE_UPDATE_STATUS = "2019"
+let ERROR_MESSAGE_UPDATE_STATUS = "There was a problem updating status"
+
+let ERROR_CODE_NULL_CATEGORY = "2020"
+let ERROR_MESSAGE_NULL_CATEGORY = "Must call fetchCategory method first"
+
+let ERROR_CODE_INVALID_PUSH_OBJECT = "2021"
+let ERROR_MESSAGE_INVALID_PUSH_OBJECT = "Received NetmeraPushObject was not valid."
+
+let ERROR_CODE_NULL_INBOX_STATUS = "2022"
+let ERROR_MESSAGE_NULL_INBOX_STATUS = "Inbox status can't be null."
+
+let ERROR_CODE_INBOX_STATUS = "2023"
+let ERROR_MESSAGE_INBOX_STATUS = "Error occurred while fetching inbox count for status"
+
+let ERROR_CODE_GET_CATEGORY_PREFERENCE = "2024"
+let ERROR_MESSAGE_GET_CATEGORY_PREFERENCE = "Error occurred while fetching user category preference list."
+
+let ERROR_CODE_SET_CATEGORY_PREFERENCE = "2025"
+let ERROR_MESSAGE_SET_CATEGORY_PREFERENCE = "Error occurred while setting user category preference list."
+
+let ERROR_CODE_COUPON_FETCH = "2026"
+let ERROR_MESSAGE_COUPON_FETCH = "Error occurred while fetching coupons."
+
+let ERROR_CODE_UPDATE_USER = "2027"
+let ERROR_MESSAGE_UPDATE_USER = "Error occurred while updating user."
+
+let ERROR_CODE_EMAIL_PERMISSION = "2028"
+let ERROR_MESSAGE_EMAIL_PERMISSION = "Error occurred while fetching email permission"
+
+let ERROR_CODE_SMS_PERMISSION = "2029"
+let ERROR_MESSAGE_SMS_PERMISSION = "Error occurred while fetching sms permission"
+
+let ERROR_CODE_WHATSAPP_PERMISSION = "2030"
+let ERROR_MESSAGE_WHATSAPP_PERMISSION = "Error occurred while getting/setting WhatsApp permission"
+
+let ERROR_CODE_NOTIFICATION_PERMISSION = "2033"
+let ERROR_MESSAGE_NOTIFICATION_PERMISSION = "Error requesting notification permission"
+
+@objc(RNNetmera)
+public class RNNetmera: NSObject {
+  var netmeraInbox: NetmeraInboxManager?
+  var categoryManager: NetmeraInboxCategoryManager?
+
+  /// Tracks whether `Netmera.initialize()` and shared setup have completed at least once.
+  private static var isInitialized = false
+
+  /// Starts Netmera using API key and base URL from your app’s **Netmera-Config.plist**.
+  /// Call once early in `didFinishLaunchingWithOptions` from `AppDelegate`.
+  public static func initNetmera() {
+    guard !isInitialized else { return }
+    Netmera.initialize()
+    applyConfiguration()
+    isInitialized = true
+  }
+
+  /// Starts Netmera using **explicit** API key and base URL (or switches environment at runtime).
+  ///
+  /// - Parameters:
+  ///   - params: Optional configuration parameters for the SDK.
+  public static func initialize(params: NetmeraParams) {
+    guard !isInitialized else { return }
+    Netmera.initialize(params: params)
+    applyConfiguration()
+    isInitialized = true
+  }
+
+  private static func applyConfiguration() {
+    setNetmeraHeaders()
+    Netmera.setPushLifecycleDelegate(RNNetmeraPushLifecycleDelegate.shared)
+    #if DEBUG
+    Netmera.setLogLevel(.debug)
+    #endif
+  }
+
+  private static func setNetmeraHeaders() {
+    Netmera.setAdditionalRequestHeaders([
+      "X-netmera-framework": "react",
+      "X-netmera-frameworkV": "2.0.0"
+    ])
+  }
+  
+  @objc(requestPushNotificationAuthorization:withRejecter:)
+  public func requestPushNotificationAuthorization(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Netmera.requestPushNotificationAuthorization(for: [.alert, .badge, .sound]) { granted, error in
+      if let error = error {
+        reject(
+          ERROR_CODE_NOTIFICATION_PERMISSION,
+          ERROR_MESSAGE_NOTIFICATION_PERMISSION,
+          error
+        )
+      } else {
+        resolve(granted)
+      }
+    }
+  }
+  
+  @objc(currentExternalId:withRejecter:)
+  func currentExternalId(
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    resolve(Netmera.getCurrentExternalId())
+  }
+  
+  @objc(checkNotificationPermission:withRejecter:)
+  func checkNotificationPermission(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Netmera.checkNotificationPermission { permissionType in
+      switch permissionType {
+      case .notDetermined:
+        resolve("NOT_DETERMINED")
+      case .denied:
+        resolve("DENIED")
+      case .blocked:
+        resolve("BLOCKED")
+      case .granted:
+        resolve("GRANTED")
+      @unknown default:
+        resolve("unknown")
+      }
+    }
+  }
+  
+  @objc(requestPermissionsForLocation)
+  func requestPermissionsForLocation() {
+    Netmera.requestLocationAuthorization()
+  }
+  
+  @objc(setNetmeraMaxActiveRegions:)
+  func setNetmeraMaxActiveRegions(_ maxActiveRegions: NSInteger) {
+    Netmera.setNetmeraMaxActiveRegions(count: maxActiveRegions)
+  }
+  
+  @objc(enablePopupPresentation)
+  func enablePopupPresentation() {
+    Netmera.setPopupPresentationEnabled(true)
+  }
+  
+  @objc(disablePopupPresentation)
+  func disablePopupPresentation() {
+    Netmera.setPopupPresentationEnabled(false)
+  }
+
+  @objc(dismissAllPresentations)
+  func dismissAllPresentations() {
+    Netmera.dismissAllPresentations()
+  }
+  
+  @objc(isPushEnabled:withRejecter:)
+  func isPushEnabled(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Netmera.isReceivingPushNotificationsEnabled { isEnabled in
+      resolve(isEnabled)
+    }
+  }
+  
+  @objc(enablePush)
+  func enablePush() {
+    Netmera.setReceivingPushNotificationsEnabled(true)
+  }
+  
+  @objc(disablePush)
+  func disablePush() {
+    Netmera.setReceivingPushNotificationsEnabled(false)
+  }
+  
+  @objc(startDataTransfer)
+  func startDataTransfer() {
+    Netmera.setDataTransferEnabled(true)
+  }
+  
+  @objc(stopDataTransfer)
+  func stopDataTransfer() {
+    Netmera.setDataTransferEnabled(false)
+  }
+  
+  @objc(kill)
+  func kill(){
+    Netmera.kill()
+  }
+  
+  @objc(sendEvent:)
+  func sendEvent(_ eventDictionary: [String: Any]) {
+    var dict = eventDictionary.compactMapValues { $0 is NSNull ? nil : $0 }
+    
+    if let eventKey = dict["code"] as? String,
+       let event = RNNetmeraEvent(eventKey: eventKey) {
+      
+      dict.removeValue(forKey: "code")
+      
+      if let revenue = dict["revenue"] as? Double {
+        event.revenue = revenue
+        dict.removeValue(forKey: "revenue")
+      }
+      
+      let converted: [String: AnyCodable] = dict.reduce(into: [:]) { result, pair in
+        result[pair.key] = AnyCodable(pair.value)
+      }
+      
+      event.eventParameters = converted
+      Netmera.send(event)
+    }
+  }
+  
+  @objc(sendGenericEvent:attributes:)
+  func sendGenericEvent(_ code: String, attributes: [String: Any]) {
+    let filtered = attributes.filter { $0.value is NSNull == false }
+    Netmera.send(eventWithKey: code, attributes: filtered)
+  }
+
+  @objc(identifyUser:hasCallback:withResolver:withRejecter:)
+  func identifyUser(_ userDictionary: [String: Any],
+                    hasCallback: Bool,
+                    resolve: @escaping RCTPromiseResolveBlock,
+                    reject: @escaping RCTPromiseRejectBlock) {
+    let user = NetmeraUserIdentify()
+
+    // Include a key only when present in the bridge map; value may be NSNull → clear on server.
+    if userDictionary["userId"] != nil {
+      user.userId = userDictionary["userId"] as? String
+    }
+    if userDictionary["msisdn"] != nil {
+      user.msisdn = userDictionary["msisdn"] as? String
+    }
+    if userDictionary["email"] != nil {
+      user.email = userDictionary["email"] as? String
+    }
+    if userDictionary["wpNumber"] != nil {
+      user.whatsAppNumber = userDictionary["wpNumber"] as? String
+    }
+    
+    let completionBlock: ((Bool) -> Void)?
+    
+    if (hasCallback) {
+        completionBlock = { success in
+            if success {
+                resolve(nil)
+            } else {
+                reject(ERROR_CODE_UPDATE_USER, ERROR_MESSAGE_UPDATE_USER, nil)
+            }
+        }
+    } else {
+        completionBlock = nil
+    }
+    
+    Netmera.identifyUser(user, completion: completionBlock)
+  }
+  
+  @objc(updateUserProfile:hasCallback:withResolver:withRejecter:)
+  func updateUserProfile(_ userProfileDictionary: [String: Any],
+                         hasCallback: Bool,
+                         resolve: @escaping RCTPromiseResolveBlock,
+                         reject: @escaping RCTPromiseRejectBlock) {
+    let completionBlock: ((Bool) -> Void)?
+    
+    if (hasCallback) {
+        completionBlock = { success in
+            if success {
+                resolve(nil)
+            } else {
+                reject(ERROR_CODE_UPDATE_USER, ERROR_MESSAGE_UPDATE_USER, nil)
+            }
+        }
+    } else {
+        completionBlock = nil
+    }
+    
+    InternalNetmera.updateUserProfile(withDictionary: userProfileDictionary, completion: completionBlock)
+  }
+  
+  @objc(fetchCoupons:max:withResolver:withRejecter:)
+  func fetchCoupons(_ page: Int, max: Int, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    let filter = NetmeraCouponFilter(page: page, max: max)
+    
+    Netmera.fetchCoupons(using: filter) { result in
+      switch result {
+      case .success(let coupons):
+        let array = RNNetmeraUtils.shared.parseCouponObjects(coupons)
+        resolve(array)
+      case .failure(let error):
+        reject(ERROR_CODE_COUPON_FETCH, ERROR_MESSAGE_COUPON_FETCH, error)
+      }
+    }
+  }
+  
+  @objc(getUserCategoryPreferenceList:withRejecter:)
+  func getUserCategoryPreferenceList(resolve: @escaping RCTPromiseResolveBlock,
+                                     reject: @escaping RCTPromiseRejectBlock) {
+    Netmera.getUserCategoryPreferenceList { result in
+      switch result {
+      case .success(let categories):
+        let parsed = RNNetmeraUtils.shared.parseUserCategoryPreferenceListToMap(
+          categories
+        )
+        resolve(parsed)
+      case .failure(_):
+        reject(ERROR_CODE_GET_CATEGORY_PREFERENCE,
+               ERROR_MESSAGE_GET_CATEGORY_PREFERENCE,
+               nil)
+      }
+    }
+  }
+  
+  @objc(setUserCategoryPreference:categoryEnabled:withResolver:withRejecter:)
+  func setUserCategoryPreference(_ categoryId: Int,
+                                 categoryEnabled: Bool,
+                                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+    Netmera.setUserCategoryPreference(categoryId: categoryId,
+                                      categoryEnabled: categoryEnabled) { result in
+      switch result {
+      case .success(_):
+        resolve(true)
+      case .failure(_):
+        reject(ERROR_CODE_SET_CATEGORY_PREFERENCE,
+               ERROR_MESSAGE_SET_CATEGORY_PREFERENCE,
+               nil)
+      }
+    }
+  }
+  
+  @objc(getInitialURL:withRejecter:)
+  func getInitialURL(resolve: RCTPromiseResolveBlock,
+                     reject: RCTPromiseRejectBlock) {
+    if let url = RNNetmeraRCTEventEmitter.getInitialUrl() {
+      resolve(url.absoluteString)
+    } else {
+      resolve(nil)
+    }
+  }
+  
+  @objc(fetchInbox:withResolver:withRejecter:)
+  public func fetchInbox(_ inboxDictionary: [String: Any],
+                         resolver: @escaping RCTPromiseResolveBlock,
+                         rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    let statusRaw = (
+      inboxDictionary["status"] as? Int
+    ) ?? NetmeraNotificationCore.NetmeraInboxStatus.default.rawValue
+    let status = NetmeraNotificationCore.NetmeraInboxStatus(rawValue: statusRaw)
+    
+    let pageSize = inboxDictionary["pageSize"] as? Int ?? 10
+    let includeExpired = inboxDictionary["includeExpiredObjects"] as? Bool ?? false
+    let categories = inboxDictionary["categories"] as? [String]
+    
+    let filter = NetmeraNotificationInbox.NetmeraInboxFilter(
+      status: status,
+      pageSize: pageSize,
+      shouldIncludeExpiredObjects: includeExpired,
+      categories: categories
+    )
+    
+    guard let manager = Netmera.inboxManager(with: filter) else {
+      rejecter(ERROR_CODE_INBOX, ERROR_MESSAGE_INBOX, nil)
+      return
+    }
+    
+    manager.inbox { result in
+      switch result {
+      case .success:
+        let array: [[String: Any]] = manager.objects.map {
+          RNNetmeraUtils.shared.dictionaryFromInboxPush($0)
+        }
+        resolver(array)
+        self.netmeraInbox = manager
+        break
+      case .failure(_):
+        rejecter(ERROR_CODE_INBOX, ERROR_MESSAGE_INBOX, nil)
+        break
+      }
+    }
+  }
+  
+  @objc(fetchNextPage:withRejecter:)
+  func fetchNextPage(
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX, ERROR_MESSAGE_INBOX, nil)
+      return
+    }
+    
+    inbox.nextPage { status in
+      switch status {
+      case .success:
+        let array = RNNetmeraUtils.shared.mapPushObjects(inbox.objects)
+        resolver(array)
+      case .failure(let error):
+        rejecter(ERROR_CODE_NOT_NEXT_PAGE, ERROR_MESSAGE_NOT_NEXT_PAGE, error)
+      }
+    }
+  }
+  
+  @objc(countForStatus:withResolver:withRejecter:)
+  public func countForStatus(_ statusRaw: Int,
+                             resolver: @escaping RCTPromiseResolveBlock,
+                             rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX_NULL,
+               ERROR_MESSAGE_INBOX_NULL,
+               nil)
+      return
+    }
+    
+    let status = NetmeraNotificationCore.NetmeraInboxStatus(rawValue: statusRaw)
+    let count = inbox.count(for: status)
+    resolver(String(count))
+  }
+  
+  @objc(inboxUpdateStatus:toIndex:status:withResolver:withRejecter:)
+  public func inboxUpdateStatus(_ fromIndex: Int,
+                                toIndex: Int,
+                                status: Int,
+                                resolver: @escaping RCTPromiseResolveBlock,
+                                rejecter: @escaping RCTPromiseRejectBlock) {
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_NULL_INBOX_STATUS,
+               ERROR_MESSAGE_NULL_INBOX_STATUS,
+               nil)
+      return
+    }
+
+    let length = toIndex - fromIndex
+    guard length > 0, fromIndex >= 0, toIndex <= inbox.objects.count else {
+      rejecter(ERROR_CODE_UPDATE_STATUS,
+               ERROR_MESSAGE_UPDATE_STATUS,
+               nil)
+      return
+    }
+
+    let range = fromIndex..<toIndex
+    let pushObjects = Array(inbox.objects[range])
+
+    let statusEnum = NetmeraNotificationCore.NetmeraInboxStatus(rawValue: status)
+
+    inbox.updateStatus(statusEnum, for: pushObjects) { result in
+      switch result {
+      case .success:
+        resolver(true)
+      case .failure(let error):
+        rejecter(ERROR_CODE_UPDATE_STATUS,
+                 "\(ERROR_CODE_UPDATE_STATUS): \(error.localizedDescription)",
+                 nil)
+      }
+    }
+  }
+
+  
+  @objc(fetchCategory:withResolver:withRejecter:)
+  public func fetchCategory(_ inboxDictionary: [String: Any],
+                            resolver: @escaping RCTPromiseResolveBlock,
+                            rejecter: @escaping RCTPromiseRejectBlock) {
+    let filter = RNNetmeraCategoryObject.getCategoryFilter(inboxDictionary)
+    
+    guard let manager = Netmera.inboxCategoryManager(with: filter) else {
+      rejecter(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY, nil)
+      return
+    }
+    
+    manager.inboxCategory { result in
+      switch result {
+      case .success(let isSuccess):
+        if isSuccess {
+          self.categoryManager = manager
+          let mappedCategories = RNNetmeraCategoryObject.mapCategoryObjects(
+            manager.categories
+          )
+          resolver(mappedCategories)
+        } else {
+          rejecter(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY, nil)
+        }
+      case .failure(let error):
+        rejecter(
+          ERROR_CODE_NULL_CATEGORY,
+          "\(ERROR_MESSAGE_NULL_CATEGORY): \(error.localizedDescription)",
+          nil
+        )
+      }
+    }
+  }
+  
+  @objc(fetchNextCategoryPage:withRejecter:)
+  public func fetchNextCategoryPage(withResolver resolve: @escaping RCTPromiseResolveBlock,
+                                    withRejecter reject: @escaping RCTPromiseRejectBlock) {
+    guard let category = categoryManager else {
+      reject(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY, nil)
+      return
+    }
+    
+    category.nextPage { status in
+      switch status {
+      case .success(let isSuccess):
+        if isSuccess {
+          let mappedCategories = RNNetmeraCategoryObject.mapCategoryObjects(
+            category.categories
+          )
+          resolve(mappedCategories)
+        } else {
+          reject(ERROR_CODE_NULL_CATEGORY, ERROR_MESSAGE_NULL_CATEGORY, nil)
+        }
+      case .failure(let error):
+        reject(ERROR_CODE_NULL_CATEGORY,
+               "There was a problem fetching next category page: \(error.localizedDescription)",
+               nil)
+      }
+    }
+  }
+  
+  @objc(handlePushObject:withResolver:withRejecter:)
+  public func handlePushObject(_ pushId: String,
+                               resolver: @escaping RCTPromiseResolveBlock,
+                               rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX_NULL, ERROR_MESSAGE_INBOX_NULL, nil)
+      return
+    }
+    
+    if let pushInboxObject = inbox.objects.first(
+      where: { $0.payload?.pushId == pushId
+      }),
+       let pushObject = pushInboxObject.push {
+      Netmera.handlePushObject(pushObject)
+    }
+    
+    resolver(nil)
+  }
+  
+  @objc(handleInteractiveAction:withResolver:withRejecter:)
+  public func handleInteractiveAction(_ interactiveActionId: String,
+                                      resolver: @escaping RCTPromiseResolveBlock,
+                                      rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX_NULL, ERROR_MESSAGE_INBOX_NULL, nil)
+      return
+    }
+    
+    for pushInboxObject in inbox.objects {
+      guard
+        let pushObject = pushInboxObject.push,
+        let actions = pushObject.interactiveAction
+      else {
+        continue
+      }
+      if let interactiveAction = actions.first(where: { $0.id == interactiveActionId }),
+         let action = interactiveAction.action {
+        Netmera.handleInteractiveAction(action, for: pushObject)
+        return
+      }
+    }
+    
+    resolver(false)
+  }
+  
+  @objc(handleLastMessage:withResolver:withRejecter:)
+  public func handleLastMessage(_ pushId: String,
+                                resolver: @escaping RCTPromiseResolveBlock,
+                                rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX_NULL, ERROR_MESSAGE_INBOX_NULL, nil)
+      return
+    }
+    
+    guard !pushId.isEmpty else {
+      rejecter(
+        ERROR_CODE_INVALID_PUSH_OBJECT,
+        ERROR_MESSAGE_INVALID_PUSH_OBJECT,
+        nil
+      )
+      return
+    }
+    
+    if let matched = inbox.objects.last(where: { $0.push?.pushId == pushId }),
+       let pushObject = matched.push {
+      Netmera.handlePushObject(pushObject)
+      resolver(true)
+    } else {
+      rejecter(
+        ERROR_CODE_INVALID_PUSH_OBJECT,
+        ERROR_MESSAGE_INVALID_PUSH_OBJECT,
+        nil
+      )
+    }
+  }
+  
+  @objc(updateStatusByCategories:status:withResolver:withRejecter:)
+  public func updateStatusByCategories(_ categoryList: [String],
+                                       status: Int,
+                                       resolver: @escaping RCTPromiseResolveBlock,
+                                       rejecter: @escaping RCTPromiseRejectBlock) {
+    
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_INBOX_NULL, ERROR_MESSAGE_INBOX_NULL, nil)
+      return
+    }
+    
+    let netmeraStatus = NetmeraInboxStatus(rawValue: status)
+    
+    inbox.updateStatus(netmeraStatus, for: categoryList) { result in
+      switch result {
+      case .success:
+        resolver(true)
+      case .failure(let error):
+        rejecter(
+          ERROR_CODE_UPDATE_STATUS,
+          "\(ERROR_MESSAGE_UPDATE_STATUS): \(error.localizedDescription)",
+          nil
+        )
+      }
+    }
+  }
+  
+  @objc(updateAll:withResolver:withRejecter:)
+  func updateAll(inboxStatus: NSInteger,
+                 resolver: @escaping RCTPromiseResolveBlock,
+                 rejecter: @escaping RCTPromiseRejectBlock) {
+    guard let inbox = netmeraInbox else {
+      rejecter(ERROR_CODE_UPDATE_STATUS, ERROR_MESSAGE_UPDATE_STATUS, nil)
+      return
+    }
+    
+    inbox.updateStatusForAllPushObjects(NetmeraInboxStatus(rawValue: inboxStatus)) { status in
+      switch status {
+      case .success:
+        resolver(true)
+      case .failure(let error):
+        rejecter(ERROR_CODE_UPDATE_STATUS, ERROR_MESSAGE_UPDATE_STATUS, error)
+      }
+    }
+  }
+  
+  @objc(getInboxCountForStatus:withResolver:withRejecter:)
+  func getInboxCountForStatus(filterDictionary: NSDictionary,
+                              resolver: @escaping RCTPromiseResolveBlock,
+                              rejecter: @escaping RCTPromiseRejectBlock) {
+    guard let statusValue = filterDictionary["status"] as? Int else {
+      rejecter(ERROR_CODE_NULL_INBOX_STATUS, ERROR_MESSAGE_NULL_INBOX_STATUS, nil)
+      return
+    }
+    
+    let status = RNNetmeraUtils.shared.getInboxStatus(code: statusValue)
+    let shouldIncludeExpiredObjects = filterDictionary["includeExpiredObjects"] as? Bool ?? false
+    let categories = filterDictionary["categoryList"] as? [String] ?? []
+    
+    let filter = NetmeraInboxCountFilter(
+      status: status,
+      shouldIncludeExpiredObjects: shouldIncludeExpiredObjects,
+      categories: categories
+    )
+    
+    Netmera.fetchInboxCount(with: filter) { resultStatus in
+      switch resultStatus {
+      case .success(let response):
+        let responseMap = RNNetmeraUtils.shared.parseInboxCount(for: response)
+        resolver(responseMap)
+      case .failure(let error):
+        rejecter(ERROR_CODE_INBOX_STATUS, ERROR_MESSAGE_INBOX_STATUS, error)
+      }
+    }
+  }
+  
+  // MARK: - Permission Methods
+
+  @objc(setEmailPermission:withResolver:withRejecter:)
+    func setEmailPermission(isAllowed: Bool,
+                            resolve: RCTPromiseResolveBlock,
+                            reject: RCTPromiseRejectBlock) {
+      Netmera.setEmailPermission(isAllowed: isAllowed)
+      resolve(nil)
+    }
+
+    @objc(getEmailPermission:withRejecter:)
+    func getEmailPermission(resolve: @escaping RCTPromiseResolveBlock,
+                            reject: @escaping RCTPromiseRejectBlock) {
+      Netmera.getEmailPermission { result in
+        switch result {
+        case .success(let isAllowed):
+          resolve(isAllowed)
+        case .failure(let error):
+          reject(ERROR_CODE_EMAIL_PERMISSION, ERROR_MESSAGE_EMAIL_PERMISSION, error)
+        }
+      }
+    }
+
+    @objc(setSmsPermission:withResolver:withRejecter:)
+    func setSmsPermission(isAllowed: Bool,
+                          resolve: RCTPromiseResolveBlock,
+                          reject: RCTPromiseRejectBlock) {
+      Netmera.setSmsPermission(isAllowed: isAllowed)
+      resolve(nil)
+    }
+
+    @objc(getSmsPermission:withRejecter:)
+    func getSmsPermission(resolve: @escaping RCTPromiseResolveBlock,
+                          reject: @escaping RCTPromiseRejectBlock) {
+      Netmera.getSmsPermission { result in
+        switch result {
+        case .success(let isAllowed):
+          resolve(isAllowed)
+        case .failure(let error):
+          reject(ERROR_CODE_SMS_PERMISSION, ERROR_MESSAGE_SMS_PERMISSION, error)
+        }
+      }
+    }
+
+    @objc(setWhatsAppPermission:withResolver:withRejecter:)
+    func setWhatsAppPermission(isAllowed: Bool,
+                               resolve: RCTPromiseResolveBlock,
+                               reject: RCTPromiseRejectBlock) {
+      Netmera.setWhatsAppPermission(isAllowed: isAllowed)
+      resolve(nil)
+    }
+
+    @objc(getWhatsAppPermission:withRejecter:)
+    func getWhatsAppPermission(resolve: @escaping RCTPromiseResolveBlock,
+                               reject: @escaping RCTPromiseRejectBlock) {
+      Netmera.getWhatsAppPermission { result in
+        switch result {
+        case .success(let isAllowed):
+          resolve(isAllowed)
+        case .failure(let error):
+          reject(ERROR_CODE_WHATSAPP_PERMISSION, ERROR_MESSAGE_WHATSAPP_PERMISSION, error)
+        }
+      }
+    }
+  
+}