[User Model] Backend Integration

* Implement `UserBackendService`, `IdentityBackendService`, and `SubscriptionBackendService`
* Tweak `OutcomeEventsBackendService` to provide `subscriptionId`

Author: brismithers

OneSignalSDK/onesignal/src/main/java/com/onesignal/common/JSONObjectExtensions.kt

@@ -1,5 +1,6 @@
 package com.onesignal.common
 
+import org.json.JSONArray
 import org.json.JSONObject
 
 /**
@@ -32,6 +33,21 @@ fun JSONObject.safeLong(name: String): Long? {
     return null
 }
 
+/**
+ * Retrieve a [Double] from the [JSONObject] safely.
+ *
+ * @param name The name of the attribute that contains a [Double] value.
+ *
+ * @return The [Double] value if it exists, null otherwise.
+ */
+fun JSONObject.safeDouble(name: String): Double? {
+    if (this.has(name)) {
+        return this.getDouble(name)
+    }
+
+    return null
+}
+
 /**
  * Retrieve a [Boolean] from the [JSONObject] safely.
  *
@@ -77,15 +93,134 @@ fun JSONObject.safeJSONObject(name: String): JSONObject? {
     return null
 }
 
+/**
+ * Create a [Map] from the [JSONObject].
+ */
+fun JSONObject.toMap(): Map<String, Any> {
+    val map = mutableMapOf<String, Any>()
+
+    for(key in this.keys()) {
+        map[key] = this[key]
+    }
+
+    return map
+}
+
 /**
  * Expand into a [JSONObject] safely.
  *
  * @param name The name of the attribute that contains a [JSONObject] value.
  * @param into The lambda method that will be executed to explore the [JSONObject] value, if the
  * attribute exists.
  */
-fun JSONObject.expand(name: String, into: (childObject: JSONObject) -> Unit) {
+fun JSONObject.expandJSONObject(name: String, into: (childObject: JSONObject) -> Unit) {
     if (this.has(name)) {
         into(this.getJSONObject(name))
     }
 }
+
+fun <T> JSONObject.expandJSONArray(name: String, into: (childObject: JSONObject) -> T?) : List<T> {
+    val listToRet = mutableListOf<T>()
+    if(this.has(name)) {
+        val jsonArray = this.getJSONArray(name)
+        for (index in 0 until jsonArray.length()) {
+            val itemJSONObject = jsonArray.getJSONObject(index)
+            val item = into(itemJSONObject)
+            if(item != null) {
+                listToRet.add(item)
+            }
+        }
+    }
+
+    return listToRet
+}
+
+/**
+ * Populate the [JSONObject] with the [Map] provided.
+ *
+ * @param map: The map that will contain the name/values.
+ *
+ * @return The [JSONObject] itself, to allow for chaining.
+ */
+fun JSONObject.putMap(map: Map<String, Any>) : JSONObject {
+    for (identity in map) {
+        this.put(identity.key, identity.value)
+    }
+
+    return this
+}
+
+/**
+ * Populate the [JSONObject] as attribute [name] with the [Map] provided.
+ *
+ * @param name: The name of the attribute that will contain the [JSONObject] value.
+ * @param map: The map that will contain the name/values.
+ *
+ * @return The [JSONObject] itself, to allow for chaining.
+ */
+fun JSONObject.putMap(name: String, map: Map<String, Any>?) : JSONObject {
+    if(map != null) {
+        this.putJSONObject(name) {
+            it.putMap(map)
+        }
+    }
+
+    return this
+}
+
+/**
+ * Put the attribute named by [name] with a [JSONObject] value, the contents
+ * of which are determined by the expand.
+ *
+ * @param name: The name of the attribute that will contain the [JSONObject] value.
+ * @param expand: The lambda that will be called to populate the [JSONObject] value.
+ *
+ * @return The [JSONObject] itself, to allow for chaining.
+ */
+fun JSONObject.putJSONObject(name: String, expand: (item: JSONObject) -> Unit ) : JSONObject {
+    val childJSONObject = JSONObject()
+    expand(childJSONObject)
+
+    this.put(name, childJSONObject)
+
+    return this
+}
+
+/**
+ * Put the attribute named by [name] with a [JSONArray] value, the contenxt of which
+ * are deteremined by the input.
+ *
+ * @param name: The name of the attribute that will contain the [JSONArray] value.
+ * @param list: The list of items that will be converted into the [JSONArray].
+ * @param create: The lambda that will be called for each item in [list], expecting a [JSONObject] to be added to the array.
+ */
+fun <T> JSONObject.putJSONArray(name: String, list: List<T>?, create: (item: T) -> JSONObject?): JSONObject {
+    if(list != null) {
+        val jsonArray = JSONArray()
+        list.forEach {
+            val item = create(it)
+            if(item != null)
+                jsonArray.put(item)
+        }
+        this.put(name, jsonArray)
+    }
+
+    return this
+}
+
+/**
+ * Put the name/value pair into the [JSONObject].  If the [value] provided is null,
+ * nothing will be put into the [JSONObject].
+ *
+ * @param name The name of the attribute the [value] will be saved to.
+ * @param value The value to put into the [JSONObject]. If not null, the attribute name will not be added.
+ *
+ * @return The [JSONObject] itself, to allow for chaining.
+ */
+fun JSONObject.putSafe(name: String, value: Any?): JSONObject {
+    if (value != null) {
+        this.put(name, value)
+    }
+
+    return this
+}

OneSignalSDK/onesignal/src/main/java/com/onesignal/core/internal/backend/impl/ParamsBackendService.kt

@@ -2,7 +2,7 @@ package com.onesignal.core.internal.backend.impl
 
 import com.onesignal.common.IDManager
 import com.onesignal.common.exceptions.BackendException
-import com.onesignal.common.expand
+import com.onesignal.common.expandJSONObject
 import com.onesignal.common.safeBool
 import com.onesignal.common.safeInt
 import com.onesignal.common.safeLong
@@ -39,13 +39,13 @@ internal class ParamsBackendService(
 
         // Process outcomes params
         var influenceParams: InfluenceParamsObject? = null
-        responseJson.expand("outcomes") {
+        responseJson.expandJSONObject("outcomes") {
             influenceParams = processOutcomeJson(it)
         }
 
         // Process FCM params
         var fcmParams: FCMParamsObject? = null
-        responseJson.expand("fcm") {
+        responseJson.expandJSONObject("fcm") {
             fcmParams = FCMParamsObject(
                 apiKey = it.safeString("api_key"),
                 appId = it.safeString("app_id"),
@@ -82,27 +82,27 @@ internal class ParamsBackendService(
         var isUnattributedEnabled: Boolean? = null
 
         // direct
-        outcomeJson.expand("direct") {
+        outcomeJson.expandJSONObject("direct") {
             isDirectEnabled = it.safeBool("enabled")
         }
 
         // indirect
-        outcomeJson.expand("indirect") { indirectJSON ->
+        outcomeJson.expandJSONObject("indirect") { indirectJSON ->
             isIndirectEnabled = indirectJSON.safeBool("enabled")
 
-            indirectJSON.expand("notification_attribution") {
+            indirectJSON.expandJSONObject("notification_attribution") {
                 indirectNotificationAttributionWindow = it.safeInt("minutes_since_displayed")
                 notificationLimit = it.safeInt("limit")
             }
 
-            indirectJSON.expand("in_app_message_attribution") {
+            indirectJSON.expandJSONObject("in_app_message_attribution") {
                 indirectIAMAttributionWindow = it.safeInt("minutes_since_displayed")
                 iamLimit = it.safeInt("limit")
             }
         }
 
         // unattributed
-        outcomeJson.expand("unattributed") {
+        outcomeJson.expandJSONObject("unattributed") {
             isUnattributedEnabled = it.safeBool("enabled")
         }
 

OneSignalSDK/onesignal/src/main/java/com/onesignal/core/internal/http/HttpResponse.kt

@@ -26,5 +26,5 @@ class HttpResponse(
      * Whether the response is a successful one.
      */
     val isSuccess: Boolean
-        get() = statusCode == HttpURLConnection.HTTP_OK || statusCode == HttpURLConnection.HTTP_ACCEPTED || statusCode == HttpURLConnection.HTTP_NOT_MODIFIED
+        get() = statusCode == HttpURLConnection.HTTP_OK || statusCode == HttpURLConnection.HTTP_ACCEPTED || statusCode == HttpURLConnection.HTTP_NOT_MODIFIED || statusCode == HttpURLConnection.HTTP_CREATED
 }

OneSignalSDK/onesignal/src/main/java/com/onesignal/core/internal/operations/impl/OperationRepo.kt

@@ -144,7 +144,10 @@ internal class OperationRepo(
             val executor = _executorsMap[startingOp.operation.name]
                 ?: throw Exception("Could not find executor for operation ${startingOp.operation.name}")
 
-            val response = executor.execute(ops.map { it.operation })
+            val operations = ops.map { it.operation }
+            val response = executor.execute(operations)
+
+            Logging.debug("OperationRepo: execute response = ${response.result}")
 
             // if the execution resulted in ID translations, run through the queue so they pick it up.
             // We also run through the ops just executed in case they are re-added to the queue.
@@ -162,6 +165,7 @@ internal class OperationRepo(
                     ops.forEach { it.waiter?.wake(true) }
                 }
                 ExecutionResult.FAIL_NORETRY -> {
+                    Logging.error("Operation execution failed without retry: $operations")
                     // on failure we remove the operation from the store and wake any waiters
                     ops.forEach { _operationModelStore.remove(it.operation.id) }
                     ops.forEach { it.waiter?.wake(false) }

OneSignalSDK/onesignal/src/main/java/com/onesignal/session/internal/outcomes/impl/IOutcomeEventsBackendService.kt

@@ -2,6 +2,8 @@ package com.onesignal.session.internal.outcomes.impl
 
 import com.onesignal.common.exceptions.BackendException
 import com.onesignal.core.internal.device.IDeviceService
+import com.onesignal.user.internal.subscriptions.SubscriptionModel
+import com.onesignal.user.subscriptions.ISubscription
 
 /**
  * The backend service for outcomes.
@@ -14,9 +16,10 @@ internal interface IOutcomeEventsBackendService {
      * If there is a non-successful response from the backend, a [BackendException] will be thrown with response data.
      *
      * @param appId The ID of the application this outcome event occurred under.
-     * @param deviceType The device type.
+     * @param userId The OneSignal user ID that is active during the outcome event.
+     * @param subscriptionId The subscription ID that is active during the outcome event.
      * @param direct Whether this outcome event is direct. `true` if it is, `false` if it isn't, `null` if should not be specified.
      * @param event The outcome event to send up.
      */
-    suspend fun sendOutcomeEvent(appId: String, deviceType: IDeviceService.DeviceType, direct: Boolean?, event: OutcomeEvent)
+    suspend fun sendOutcomeEvent(appId: String, userId: String, subscriptionId: String, direct: Boolean?, event: OutcomeEvent)
 }

OneSignalSDK/onesignal/src/main/java/com/onesignal/session/internal/outcomes/impl/OutcomeEventsBackendService.kt

@@ -8,10 +8,13 @@ import org.json.JSONObject
 internal class OutcomeEventsBackendService(private val _http: IHttpClient) :
     IOutcomeEventsBackendService {
 
-    override suspend fun sendOutcomeEvent(appId: String, deviceType: IDeviceService.DeviceType, direct: Boolean?, event: OutcomeEvent) {
+    override suspend fun sendOutcomeEvent(appId: String, userId: String, subscriptionId: String, direct: Boolean?, event: OutcomeEvent) {
         val jsonObject = JSONObject()
             .put("app_id", appId)
-            .put("device_type", deviceType.value)
+            .put("onesignal_id", userId)
+            .put("subscription", JSONObject()
+                .put("id", subscriptionId)
+            )
 
         if (direct != null) {
             jsonObject.put("direct", direct)

OneSignalSDK/onesignal/src/main/java/com/onesignal/session/internal/outcomes/impl/OutcomeEventsController.kt

@@ -4,7 +4,6 @@ import android.os.Process
 import com.onesignal.common.exceptions.BackendException
 import com.onesignal.common.threading.suspendifyOnThread
 import com.onesignal.core.internal.config.ConfigModelStore
-import com.onesignal.core.internal.device.IDeviceService
 import com.onesignal.core.internal.startup.IStartableService
 import com.onesignal.core.internal.time.ITime
 import com.onesignal.debug.internal.logging.Logging
@@ -15,6 +14,8 @@ import com.onesignal.session.internal.influence.InfluenceType
 import com.onesignal.session.internal.outcomes.IOutcomeEventsController
 import com.onesignal.session.internal.session.ISessionLifecycleHandler
 import com.onesignal.session.internal.session.ISessionService
+import com.onesignal.user.internal.identity.IdentityModelStore
+import com.onesignal.user.internal.subscriptions.ISubscriptionManager
 
 internal class OutcomeEventsController(
     private val _session: ISessionService,
@@ -23,8 +24,9 @@ internal class OutcomeEventsController(
     private val _outcomeEventsPreferences: IOutcomeEventsPreferences,
     private val _outcomeEventsBackend: IOutcomeEventsBackendService,
     private val _configModelStore: ConfigModelStore,
+    private val _identityModelStore: IdentityModelStore,
+    private val _subscriptionManager: ISubscriptionManager,
     private val _time: ITime,
-    private val _deviceService: IDeviceService
 ) : IOutcomeEventsController, IStartableService, ISessionLifecycleHandler {
     // Keeps track of unique outcome events sent for UNATTRIBUTED sessions on a per session level
     private var unattributedUniqueOutcomeEventsSentOnSession: MutableSet<String> = mutableSetOf()
@@ -264,8 +266,15 @@ Outcome event was cached and will be reattempted on app cold start"""
     }
 
     private suspend fun requestMeasureOutcomeEvent(eventParams: OutcomeEventParams) {
-        val deviceType = _deviceService.deviceType
         val appId: String = _configModelStore.model.appId
+        val subscriptionId = _subscriptionManager.subscriptions.push.id
+
+        // if we don't have a subscription ID yet, throw an exception. The outcome will be saved and processed
+        // later, when we do have a subscription ID.
+        if(subscriptionId.isEmpty()) {
+            throw BackendException(0)
+        }
+
         val event = OutcomeEvent.fromOutcomeEventParamstoOutcomeEvent(eventParams)
         val direct = when (event.session) {
             InfluenceType.DIRECT -> true
@@ -274,6 +283,6 @@ Outcome event was cached and will be reattempted on app cold start"""
             else -> null
         }
 
-        _outcomeEventsBackend.sendOutcomeEvent(appId, deviceType, direct, event)
+        _outcomeEventsBackend.sendOutcomeEvent(appId, _identityModelStore.model.onesignalId, subscriptionId,  direct, event)
     }
 }

OneSignalSDK/onesignal/src/main/java/com/onesignal/user/internal/backend/IIdentityBackendService.kt

@@ -14,19 +14,6 @@ interface IIdentityBackendService {
      */
     suspend fun createAlias(appId: String, aliasLabel: String, aliasValue: String, identities: Map<String, String>): Map<String, String>
 
-    /**
-     * Update the [aliasLabelToUpdate] from the user identified by the [aliasLabel]/[aliasValue] provided.
-     *
-     * If there is a non-successful response from the backend, a [BackendException] will be thrown with response data.
-     *
-     * @param appId The ID of the OneSignal application this user exists under.
-     * @param aliasLabel The alias label to retrieve the user under.
-     * @param aliasValue The identifier within the [aliasLabel] that identifies the user to retrieve.
-     * @param aliasLabelToUpdate The alias label to delete from the user identified.
-     * @param newAliasId The new ID for the [aliasLabelToUpdate].
-     */
-    suspend fun updateAlias(appId: String, aliasLabel: String, aliasValue: String, aliasLabelToUpdate: String, newAliasId: String)
-
     /**
      * Delete the [aliasLabelToDelete] from the user identified by the [aliasLabel]/[aliasValue] provided.
      *