otpless-headless-rn 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 Digvijay Singh
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+<p align="center">
+  <img src="https://github.com/otpless-tech/Otpless-iOS-SDK/blob/main/otpless.svg" height="80"/>
+</p>
+
+# OTPLESS react native SDK
+[![npm version](https://badge.fury.io/js/otpless-headless-rn.svg)](https://badge.fury.io/js/otpless-headless-rn)
+[![npm downloads](https://img.shields.io/npm/dm/otpless-headless-rn.svg)](https://www.npmjs.com/package/otpless-headless-rn)
+
+
+## Installation
+
+You can checkout the complete [installation guide here](https://otpless.com/platforms/react-native)
+
+## Author
+
+[OTPLESS](https://otpless.com), developer@otpless.com

package/android/build.gradle

@@ -0,0 +1,86 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["OtplessHeadlessRN_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.3.0"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["OtplessHeadlessRN_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["OtplessHeadlessRN_" + name]).toInteger()
+}
+
+android {
+  compileSdk 35
+  namespace "com.otplessheadlessrn"
+  defaultConfig {
+    minSdkVersion 21
+    targetSdkVersion 35
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation ("io.github.otpless-tech:otpless-headless-sdk:0.1.1")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "OtplessHeadlessRN"
+    codegenJavaPackageName = "com.otplessheadlessrn"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+OtplessHeadlessRN_kotlinVersion=1.8.22
+OtplessHeadlessRN_minSdkVersion=24
+OtplessHeadlessRN_targetSdkVersion=35
+OtplessHeadlessRN_compileSdkVersion=35
+OtplessHeadlessRN_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.otplessheadlessrn">
+</manifest>

package/android/src/main/java/com/otplessheadlessrn/OtplessReactNativeManager.kt

@@ -0,0 +1,12 @@
+package com.otplessheadlessrn
+
+import java.lang.ref.WeakReference
+
+object OtplessHeadlessRNManager {
+
+  private var wModule: WeakReference<OtplessHeadlessRNModule>? = null
+
+  internal fun registerOtplessModule(otplessModule: OtplessHeadlessRNModule) {
+    wModule = WeakReference(otplessModule)
+  }
+}

package/android/src/main/java/com/otplessheadlessrn/OtplessReactNativeModule.kt

@@ -0,0 +1,170 @@
+package com.otplessheadlessrn
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Callback
+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.otpless.v2.android.sdk.dto.OtplessChannelType
+import com.otpless.v2.android.sdk.dto.OtplessRequest
+import com.otpless.v2.android.sdk.dto.OtplessResponse
+import com.otpless.v2.android.sdk.dto.ResponseTypes
+import com.otpless.v2.android.sdk.main.OtplessPhoneHint
+import com.otpless.v2.android.sdk.main.OtplessSDK
+import com.otpless.v2.android.sdk.utils.OtplessUtils
+import org.json.JSONException
+import org.json.JSONObject
+
+class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+  init {
+    OtplessHeadlessRNManager.registerOtplessModule(this)
+    reactContext.addActivityEventListener(this)
+  }
+
+  private val phoneHintApi by lazy { OtplessPhoneHint() }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  private fun sendHeadlessEventCallback(result: OtplessResponse) {
+    fun sendResultEvent(result: JSONObject) {
+      try {
+        val map = convertJsonToMap(result)
+        this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit("OTPlessEventResult", map)
+      } catch (_: JSONException) {
+
+      }
+    }
+
+    val jsonObject = JSONObject()
+    try {
+      jsonObject.put("responseType", result.responseType)
+      jsonObject.put("response", result.response)
+      jsonObject.put("statusCode", result.statusCode)
+    } catch (_: JSONException) {
+
+    }
+    sendResultEvent(jsonObject)
+  }
+
+  @ReactMethod
+  fun isWhatsappInstalled(callback: Callback) {
+    val hasWhatsapp = OtplessUtils.isWhatsAppInstalled(reactContext)
+    val json = JSONObject().also {
+      it.put("hasWhatsapp", hasWhatsapp)
+    }
+    callback.invoke(convertJsonToMap(json))
+  }
+
+  @ReactMethod
+  fun initialize(appId: String, loginUri: String? = null) {
+    currentActivity?.let {
+      OtplessSDK.initialize(
+        appId = appId,
+        activity = it,
+        loginUri = loginUri
+      )
+    }
+  }
+
+  @ReactMethod
+  fun start(data: ReadableMap) {
+    val otplessRequest = OtplessRequest()
+    val phone = data.getString("phone") ?: ""
+    // phone number authentication
+    if (phone.isNotEmpty()) {
+      val countryCode = data.getString("countryCode") ?: ""
+      otplessRequest.setPhoneNumber(number = phone, countryCode = countryCode)
+      data.getString("otp")?.let {
+        otplessRequest.setOtp(it)
+      }
+    } else {
+      // email authentication
+      val email = data.getString("email") ?: ""
+      if (email.isNotEmpty()) {
+        otplessRequest.setEmail(email)
+        data.getString("otp")?.let {
+          otplessRequest.setOtp(it)
+        }
+      } else {
+        // oauth case
+        otplessRequest.setChannelType(OtplessChannelType.fromString(data.getString("channelType") ?: ""))
+      }
+    }
+    data.getString("expiry")?.takeIf { it.isNotBlank() }?.let {
+      otplessRequest.setExpiry(it)
+    }
+
+    data.getString("otpLength")?.takeIf { it.isNotBlank() }?.let {
+      otplessRequest.setOtpLength(it)
+    }
+
+    data.getString("deliveryChannel")?.takeIf { it.isNotBlank() }?.let { deliveryChannel ->
+      otplessRequest.setDeliveryChannel(deliveryChannel.uppercase())
+    }
+
+    data.getString("tid")?.takeIf { it.isNotBlank() }?.let { templateId ->
+      otplessRequest.setTemplateId(templateId)
+    }
+
+    OtplessSDK.startAsync(request = otplessRequest, this::sendHeadlessEventCallback)
+  }
+
+  @ReactMethod
+  fun setResponseCallback() {
+    OtplessSDK.setResponseCallback(this::sendHeadlessEventCallback)
+  }
+
+  @ReactMethod
+  fun cleanup() {
+    OtplessSDK.cleanup()
+  }
+
+  companion object {
+    const val NAME = "OtplessHeadlessRN"
+  }
+
+  override fun onActivityResult(
+    activity: Activity?,
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    OtplessSDK.onActivityResult(requestCode, resultCode, data)
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    intent ?: return
+    OtplessSDK.onNewIntentAsync(intent)
+  }
+
+  @ReactMethod
+  fun commitResponse(data: ReadableMap?) {
+    val dataMap = data?.toHashMap() ?: return
+    val jsonResponse = JSONObject(dataMap)
+    val otplessResponse = OtplessResponse(
+      responseType = getResponseType(responseTypeString = jsonResponse.optString("responseType", "")),
+      jsonResponse.optJSONObject("response"),
+      jsonResponse.optInt("statusCode", 0),
+    )
+    OtplessSDK.commit(otplessResponse)
+  }
+
+  private fun getResponseType(responseTypeString: String) : ResponseTypes {
+    return ResponseTypes.valueOf(responseTypeString)
+  }
+}
+
+
+
+
+
+

package/android/src/main/java/com/otplessheadlessrn/OtplessReactNativePackage.kt

@@ -0,0 +1,17 @@
+package com.otplessheadlessrn
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class OtplessHeadlessRNPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(OtplessHeadlessRNModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/otplessheadlessrn/utils.kt

@@ -0,0 +1,121 @@
+package com.otplessheadlessrn
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+
+internal fun convertMapToJson(map: ReadableMap?): JSONObject? {
+  map ?: return null
+  try {
+    val resultJson = JSONObject()
+    val iterator = map.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey() ?: continue
+      when (map.getType(key)) {
+        ReadableType.Null -> continue
+        ReadableType.Boolean -> resultJson.put(key, map.getBoolean(key))
+        ReadableType.String -> resultJson.put(key, map.getString(key))
+        ReadableType.Number -> resultJson.put(key, map.getDouble(key))
+        ReadableType.Map -> {
+          val innerMap = convertMapToJson(map.getMap(key)) ?: continue
+          resultJson.put(key, innerMap)
+        }
+
+        ReadableType.Array -> {
+          val array = map.getArray(key) ?: continue
+          resultJson.put(key, convertArrayToJson(array))
+        }
+      }
+    }
+    return resultJson
+  } catch (ex: Exception) {
+    return null
+  }
+}
+
+internal fun convertArrayToJson(array: ReadableArray?): JSONArray? {
+  array ?: return null
+  try {
+    val resultArray = JSONArray()
+    var index = 0
+    while (index < array.size()) {
+      when (array.getType(index)) {
+        ReadableType.Null -> continue
+        ReadableType.Boolean -> resultArray.put(array.getBoolean(index))
+        ReadableType.String -> resultArray.put(array.getString(index))
+        ReadableType.Number -> resultArray.put(array.getDouble(index))
+        ReadableType.Map -> {
+          val innerMap = convertMapToJson(array.getMap(index)) ?: continue
+          resultArray.put(innerMap)
+        }
+
+        ReadableType.Array -> {
+          val innerArray = convertArrayToJson(array.getArray(index)) ?: continue
+          resultArray.put(innerArray)
+        }
+      }
+      index++
+    }
+    return resultArray
+  } catch (ex: Exception) {
+    return null
+  }
+}
+
+@Throws(JSONException::class)
+internal fun convertJsonToMap(jsonObject: JSONObject): WritableMap {
+  val map: WritableMap = WritableNativeMap()
+  val iterator = jsonObject.keys()
+  while (iterator.hasNext()) {
+    val key = iterator.next()
+    val value = jsonObject[key]
+    if (value is JSONObject) {
+      map.putMap(key, convertJsonToMap(value))
+    } else if (value is JSONArray) {
+      map.putArray(key, convertJsonToArray(value))
+    } else if (value is Boolean) {
+      map.putBoolean(key, value)
+    } else if (value is Int) {
+      map.putInt(key, value)
+    } else if (value is Double) {
+      map.putDouble(key, value)
+    } else if (value is String) {
+      map.putString(key, value)
+    } else {
+      map.putString(key, value.toString())
+    }
+  }
+  return map
+}
+
+@Throws(JSONException::class)
+internal fun convertJsonToArray(jsonArray: JSONArray): WritableArray {
+  val array: WritableArray = WritableNativeArray()
+  for (i in 0 until jsonArray.length()) {
+    val value = jsonArray[i]
+    if (value is JSONObject) {
+      array.pushMap(convertJsonToMap(value))
+    } else if (value is JSONArray) {
+      array.pushArray(convertJsonToArray(value))
+    } else if (value is Boolean) {
+      array.pushBoolean(value)
+    } else if (value is Int) {
+      array.pushInt(value)
+    } else if (value is Double) {
+      array.pushDouble(value)
+    } else if (value is String) {
+      array.pushString(value)
+    } else {
+      array.pushString(value.toString())
+    }
+  }
+  return array
+}

package/ios/OtplessHeadlessRN.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>

package/ios/OtplessHeadlessRN.m

@@ -0,0 +1,27 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(OtplessHeadlessRN, RCTEventEmitter<RCTBridgeModule>)
+
+RCT_EXTERN_METHOD(initialize:(NSString *)appId
+                  loginUri: (nullable NSString *) loginUri
+                  )
+
+RCT_EXTERN_METHOD(setResponseCallback)
+
+RCT_EXTERN_METHOD(start:(NSDictionary *)request)
+
+RCT_EXTERN_METHOD(enableDebugLogging:(BOOL)enable)
+
+RCT_EXTERN_METHOD(commitResponse: (nullable NSDictionary *) response)
+
+RCT_EXTERN_METHOD(cleanup)
+
+RCT_EXTERN_METHOD(setOneTapDataCallback)
+
+RCT_EXTERN_METHOD(performOneTap: (NSDictionary *)request)
+
+RCT_EXTERN_METHOD(authorizeViaPasskey: (NSDictionary *)request)
+
+@end
+

package/ios/OtplessHeadlessRN.swift

@@ -0,0 +1,187 @@
+import OtplessBM
+
+
+@objc(OtplessHeadlessRN)
+class OtplessHeadlessRN: RCTEventEmitter, OtplessResponseDelegate {
+  private var currentTask: Task<Void, Never>?
+  
+  func onResponse(_ response: OtplessBM.OtplessResponse) {
+    onOtplessResponse(response: response)
+  }
+  
+  @objc(commitResponse:)
+  func commitResponse(response: [String: Any]?) {
+    guard let response = response else {
+      return
+    }
+    let responseType = response["responseType"] as? String ?? "FAILED"
+    let statusCode = response["statusCode"] as? Int ?? -25000
+    let responseDict = response["response"] as? [String: Any]
+    let otplessResponse = OtplessResponse(responseType: ResponseTypes(rawValue: responseType) ?? .FAILED, response: responseDict, statusCode: statusCode)
+    Otpless.shared.commitOtplessResponse(otplessResponse)
+  }
+  
+  func onOtplessResponse(response: OtplessResponse?) {
+    if response == nil {
+      return
+    }
+    var params = [String: Any]()
+    params["response"] = response!.response
+    params["statusCode"] = response!.statusCode
+    params["responseType"] = response!.responseType.rawValue
+    sendEvent(withName: "OTPlessEventResult", body: params)
+  }
+  
+  private func createOtplessRequest(args: [String: Any]) -> OtplessRequest {
+    let otplessRequest = OtplessRequest()
+    if let phone = args["phone"] as? String,
+       let countryCode = args["countryCode"] as? String {
+      otplessRequest.set(phoneNumber: phone, withCountryCode: countryCode)
+    } else if let email = args["email"] as? String {
+      otplessRequest.set(email: email)
+    } else if let channelType = args["channelType"] as? String {
+      otplessRequest.set(channelType: OtplessChannelType.fromString(channelType))
+    }
+    if let otp = args["otp"] as? String {
+      otplessRequest.set(otp: otp)
+    }
+    if let deliveryChannel = args["deliveryChannel"] as? String,
+       !deliveryChannel.isEmpty {
+      otplessRequest.set(deliveryChannelForTransaction: deliveryChannel)
+    }
+    if let otpExpiry = args["expiry"] as? String,
+       !otpExpiry.isEmpty {
+      otplessRequest.set(otpExpiry: otpExpiry)
+    }
+    if let otpLength = args["otpLength"] as? String,
+       !otpLength.isEmpty {
+      otplessRequest.set(otpLength: otpLength)
+    }
+    
+    if let tid = args["tid"] as? String,
+       !tid.isEmpty {
+      otplessRequest.set(tid: tid)
+    }
+    
+    return otplessRequest
+  }
+  
+  @objc(authorizeViaPasskey:)
+  func authorizeViaPasskey(request: [String: Any]) {
+    let requestId = request["requestId"] as? String ?? ""
+    let request = OtplessRequest()
+    request.set(requestIdForWebAuthn: requestId)
+      if let windowScene = getWindowScene() {
+        Task(priority: .userInitiated) {
+          await Otpless.shared.authorizeViaPasskey(withRequest: request, windowScene: windowScene)
+        }
+      }
+  }
+  
+  @objc(enableDebugLogging:)
+  func enableDebugLogging(enable: Bool) {
+    if enable {
+      Otpless.shared.setLoggerDelegate(self)
+    }
+  }
+  
+  override func supportedEvents() -> [String]! {
+    return ["OTPlessEventResult"]
+  }
+  
+  @MainActor
+  @objc(initialize:loginUri:)
+  func initialize(appId: String, loginUri: String?) {
+    DispatchQueue.main.async {
+      let rootViewController = UIApplication.shared.delegate?.window??.rootViewController
+      if rootViewController != nil {
+        Otpless.shared.initialise(withAppId: appId, vc: rootViewController!)
+        return
+      }
+      
+      // Could not get an instance of RootViewController. Try to get RootViewController from `windowScene`.
+      if #available(iOS 13.0, *) {
+        let windowSceneVC = self.getRootViewControllerFromWindowScene()
+        if windowSceneVC != nil {
+          Otpless.shared.initialise(withAppId: appId, vc: rootViewController!)
+          return
+        }
+      }
+    }
+  }
+  
+  @objc(setResponseCallback)
+  func setResponseCallback() {
+    Otpless.shared.setResponseDelegate(self)
+  }
+  
+  @objc(start:)
+  func start(request: [String: Any]) {
+      let otplessRequest = createOtplessRequest(args: request)
+
+      let isOtpVerification = (request["otp"] as? String)?.isEmpty == false
+
+      if !isOtpVerification {
+          // Cancel the existing task if it's not an OTP verification request
+          currentTask?.cancel()
+      }
+
+      let newTask = Task(priority: .userInitiated) {
+          await Otpless.shared.start(withRequest: otplessRequest)
+      }
+
+      if !isOtpVerification {
+          currentTask = newTask
+      }
+  }
+  
+  @objc(cleanup)
+  func cleanup() {
+    Otpless.shared.cleanup()
+    currentTask?.cancel()
+    currentTask = nil
+  }
+  
+  @MainActor @available(iOS 13.0, *)
+  private func getRootViewControllerFromWindowScene() -> UIViewController? {
+    guard let windowScene = UIApplication.shared.connectedScenes
+      .filter({ $0.activationState == .foregroundActive })
+      .first as? UIWindowScene else {
+      return nil
+    }
+    
+    if #available(iOS 15.0, *) {
+      let keyWindowVC = windowScene.windows.first?.windowScene?.keyWindow?.rootViewController
+      if keyWindowVC != nil {
+        return keyWindowVC
+      }
+    }
+    
+    return windowScene.windows.first?.rootViewController
+  }
+  
+  @MainActor @available(iOS 13.0, *)
+  private func getWindowScene() -> UIWindowScene? {
+    guard let windowScene = UIApplication.shared.connectedScenes
+      .filter({ $0.activationState == .foregroundActive })
+      .first as? UIWindowScene else {
+      return nil
+    }
+    return windowScene
+  }
+  
+  @objc(performOneTap:)
+  func performOneTap(request: [String: Any]) {
+    let oneTapIdentity = OneTapIdentity(name: request["name"] as? String, identity: request["identity"] as? String ?? "", uiId: request["uiId"] as? String ?? "", logo: request["logo"] as? String)
+    Task(priority: .userInitiated) {
+      await Otpless.shared.performOneTap(forIdentity: oneTapIdentity)
+    }
+  }
+}
+
+extension OtplessHeadlessRN: OtplessLoggerDelegate {
+  func log(message: String, type: OtplessBM.LogType) {
+    print("OtplessHeadlessRN: \(type)\n \(message)")
+  }
+
+}