() {
diff --git a/fme-android/src/main/java/com/vwo/enums/EventEnum.kt b/fme-android/src/main/java/com/vwo/enums/EventEnum.kt
index b0a6583..a839428 100644
--- a/fme-android/src/main/java/com/vwo/enums/EventEnum.kt
+++ b/fme-android/src/main/java/com/vwo/enums/EventEnum.kt
@@ -30,5 +30,7 @@ enum class EventEnum(val value: String) {
/**
* Event triggered when a user attribute is set.
*/
- VWO_SYNC_VISITOR_PROP("vwo_syncVisitorProp")
+ VWO_SYNC_VISITOR_PROP("vwo_syncVisitorProp"),
+
+ VWO_RECOMMENDATION_SHOWN("vwo_recommendation_block_shown");
}
diff --git a/fme-android/src/main/java/com/vwo/enums/UrlEnum.kt b/fme-android/src/main/java/com/vwo/enums/UrlEnum.kt
index 55bec37..d2aab6f 100644
--- a/fme-android/src/main/java/com/vwo/enums/UrlEnum.kt
+++ b/fme-android/src/main/java/com/vwo/enums/UrlEnum.kt
@@ -33,5 +33,9 @@ enum class UrlEnum(val url: String) {
/**
* URL for retrieving user data.
*/
- GET_USER_DATA("/get-user-details")
+ GET_USER_DATA("/get-user-details"),
+
+ GENERATE_RECOMMENDATION("/internalcall/generate-recommendation"), // TODO -- Change this to actual URL
+
+ EVALUATE_DSL("/evaluate-event-dsl")
}
diff --git a/fme-android/src/main/java/com/vwo/enums/VariableTypeEnum.kt b/fme-android/src/main/java/com/vwo/enums/VariableTypeEnum.kt
new file mode 100644
index 0000000..0129cf8
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/enums/VariableTypeEnum.kt
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.enums
+
+enum class VariableTypeEnum(val value: String) {
+ /** Recommendation type*/
+ RECOMMENDATION("recommendation")
+}
diff --git a/fme-android/src/main/java/com/vwo/interfaces/IVwoListener.java b/fme-android/src/main/java/com/vwo/interfaces/IVwoListener.java
new file mode 100644
index 0000000..dd0fde9
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/interfaces/IVwoListener.java
@@ -0,0 +1,38 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.interfaces;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Callback interface to receive notifications about the operation in VWO.
+ */
+public interface IVwoListener {
+ /**
+ * Called when VWO action is successful.
+ * @param data Additional data
+ */
+ void onSuccess(Object data);
+
+ /**
+ * Called when VWO action is failed.
+ *
+ * Most common reason for failure is device unable to connect to Internet.
+ *
+ * @param message String message
+ */
+ void onFailure(@NotNull String message);
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/models/Campaign.kt b/fme-android/src/main/java/com/vwo/models/Campaign.kt
index f86afd0..7e82474 100644
--- a/fme-android/src/main/java/com/vwo/models/Campaign.kt
+++ b/fme-android/src/main/java/com/vwo/models/Campaign.kt
@@ -42,6 +42,11 @@ class Campaign {
@JsonProperty("segments")
var segments: Map? = null
+ @get:JsonProperty("segments_events")
+ @set:JsonProperty("segments_events")
+ @JsonProperty("segments_events")
+ var segments_events: List? = null
+
@JsonProperty("ruleKey")
var ruleKey: String? = null
@@ -94,6 +99,8 @@ class Campaign {
@JsonProperty("weight")
var weight: Double = 0.0
+ var isEventsDsl: Boolean = false
+
/**
* Sets the properties of this campaign from another campaign object.
*
@@ -153,6 +160,10 @@ class Campaign {
if (model.endRangeVariation != 0) {
this.endRangeVariation = model.endRangeVariation
}
+
+ if (model.segments_events != null) {
+ this.segments_events = model.segments_events
+ }
}
}
diff --git a/fme-android/src/main/java/com/vwo/models/Groups.kt b/fme-android/src/main/java/com/vwo/models/Groups.kt
index 164e648..0548261 100644
--- a/fme-android/src/main/java/com/vwo/models/Groups.kt
+++ b/fme-android/src/main/java/com/vwo/models/Groups.kt
@@ -18,6 +18,7 @@ package com.vwo.models
import com.fasterxml.jackson.annotation.JsonInclude
import com.fasterxml.jackson.annotation.JsonProperty
+
/**
* Represents a group of campaigns in VWO.
*
@@ -33,7 +34,7 @@ class Groups {
@get:JsonProperty("campaigns")
@set:JsonProperty("campaigns")
@JsonProperty("campaigns")
- var campaigns: List? = null
+ var campaigns: List? = null
// this is where algo, priority, weight go
@JsonProperty("et")
@@ -42,12 +43,12 @@ class Groups {
@get:JsonProperty("p")
@set:JsonProperty("p")
@JsonProperty("p")
- var p: List? = null
+ var p: MutableList? = ArrayList()
@get:JsonProperty("wt")
@set:JsonProperty("wt")
@JsonProperty("wt")
- var wt: Map? = null
+ var wt: Map? = mutableMapOf()
/**
* Sets the experiment type for the group.
diff --git a/fme-android/src/main/java/com/vwo/models/RecommendedProduct.kt b/fme-android/src/main/java/com/vwo/models/RecommendedProduct.kt
new file mode 100644
index 0000000..55967f1
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/models/RecommendedProduct.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.models
+
+
+import com.google.gson.annotations.SerializedName
+import androidx.annotation.Keep
+
+@Keep
+data class RecommendedProduct(
+ @SerializedName("id")
+ val id: String = "",
+)
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/models/Variable.kt b/fme-android/src/main/java/com/vwo/models/Variable.kt
index 6bd2242..1f160dc 100644
--- a/fme-android/src/main/java/com/vwo/models/Variable.kt
+++ b/fme-android/src/main/java/com/vwo/models/Variable.kt
@@ -36,4 +36,7 @@ class Variable {
@JsonProperty("id")
var id: Int? = null
+
+ @JsonProperty("displayConfiguration")
+ var displayConfiguration: Any? = null
}
diff --git a/fme-android/src/main/java/com/vwo/models/Variation.kt b/fme-android/src/main/java/com/vwo/models/Variation.kt
index 94036a7..99699cf 100644
--- a/fme-android/src/main/java/com/vwo/models/Variation.kt
+++ b/fme-android/src/main/java/com/vwo/models/Variation.kt
@@ -35,6 +35,12 @@ class Variation {
@JsonProperty("name")
var name: String? = null
+ @JsonProperty("ruleKey")
+ var ruleKey: String? = null
+
+ @JsonProperty("type")
+ var type: String? = null
+
@JsonProperty("weight")
var weight: Double = 0.0
@@ -52,4 +58,9 @@ class Variation {
@JsonProperty("segments")
var segments: Map = HashMap()
+
+ @get:JsonProperty("segments_events")
+ @set:JsonProperty("segments_events")
+ @JsonProperty("segments_events")
+ var segments_events: List? = null
}
diff --git a/fme-android/src/main/java/com/vwo/models/user/GetFlag.kt b/fme-android/src/main/java/com/vwo/models/user/GetFlag.kt
index 9fd1775..2e2a346 100644
--- a/fme-android/src/main/java/com/vwo/models/user/GetFlag.kt
+++ b/fme-android/src/main/java/com/vwo/models/user/GetFlag.kt
@@ -15,8 +15,11 @@
*/
package com.vwo.models.user
+import com.vwo.constants.Constants
import com.vwo.constants.Constants.defaultString
+import com.vwo.enums.VariableTypeEnum
import com.vwo.models.Variable
+import org.json.JSONObject
/**
* Represents a feature flag and its associated variables.
@@ -24,10 +27,17 @@ import com.vwo.models.Variable
* This class encapsulates information about a feature flag, including its enabled status and a
* list of variables with their values.
*/
-class GetFlag {
- var isEnabled: Boolean = false
+class GetFlag(val context: VWOContext) {
+ private var isEnabled: Boolean = false
+
private var variables: List = ArrayList()
+ fun isEnabled() = isEnabled
+
+ fun setIsEnabled(value: Boolean) {
+ isEnabled = value
+ }
+
/**
* Sets the variables for the feature flag.
*
@@ -50,11 +60,30 @@ class GetFlag {
fun getVariable(key: String?, defaultValue: Any): Any {
for (variable in variablesValue) {
if (variable.key.equals(key)) {
+ if (variable.type.equals(VariableTypeEnum.RECOMMENDATION.value,true)) {
+ // Return a Recommendation Object if type is RECOMMENDATION
+ val value = variable.value.toString().toIntOrNull()?:0
+ return Recommendation(value, context)
+ }
+
return variable.value?:defaultValue
}
}
return defaultValue
}
+
+ fun getRecommendationDisplayConfig(key: String?): Map? {
+ for (variable in variablesValue) {
+ if (variable.key.equals(key)) {
+ if (variable.type.equals(VariableTypeEnum.RECOMMENDATION.value, true)) {
+ // Return a Recommendation Object if type is RECOMMENDATION
+ return variable.displayConfiguration as? Map
+ }
+ }
+ }
+ return null
+ }
+
/**
* Retrieves the list of variables as a list of maps.
*
@@ -63,7 +92,10 @@ class GetFlag {
fun getVariables(): List> {
val result: MutableList> = ArrayList()
for (variable in variablesValue) {
- result.add(convertVariableModelToMap(variable))
+ // Check if the variable's type is not "recommendation"
+ if (!variable.type.equals(VariableTypeEnum.RECOMMENDATION.value,true)) {
+ result.add(convertVariableModelToMap(variable))
+ }
}
return result
}
diff --git a/fme-android/src/main/java/com/vwo/models/user/Recommendation.kt b/fme-android/src/main/java/com/vwo/models/user/Recommendation.kt
new file mode 100644
index 0000000..af76bf1
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/models/user/Recommendation.kt
@@ -0,0 +1,115 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.models.user
+
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.vwo.api.TrackEventAPI.createAndSendImpressionForTrack
+import com.vwo.enums.EventEnum
+import com.vwo.interfaces.IVwoListener
+import com.vwo.models.RecommendedProduct
+import com.vwo.utils.RecommendationUtil.getRecommendation
+import com.vwo.utils.SettingsUtil
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.concurrent.thread
+
+
+class Recommendation(val recommendationBlock: Int, private val context: VWOContext) {
+ /**
+ * This method is used to get recommendations based on the options passed.
+ *
+ * @param options Map containing the options to be passed to the recommendation API
+ * @param listener IVwoListener interface to handle the success and failure of the recommendation API
+ *
+ * @return JSONObject containing the recommendations and the recommendationBlock
+ */
+ fun getRecommendations(options: Map, category:String?, productIds:List?, listener:IVwoListener) {
+ thread(start = true) {
+ try {
+ val eventType = options["pageType"] as? String ?: ""
+ val recommendations = getRecommendation(
+ recommendationBlock,
+ context.id!!,
+ eventType,
+ category,
+ productIds
+ )
+ // Add configId to the recommendations
+ recommendations.put("recommendationBlock", recommendationBlock)
+
+ var results = recommendations.optJSONArray("results")
+ // if recommendations is an empty object or if the results array is empty, then return the recommendations as is
+ if (results == null) {
+ recommendations.put("results", JSONArray())
+ }
+
+ // Send recommendationShown event
+ results = recommendations.getJSONArray("results")
+ if (results?.length() != 0) {
+ SettingsUtil.settingsFile?.let {
+
+ val inputProducts = (options["productIds"] as? String) ?: ""
+ val data = mapOf(
+ "recommendation_block" to recommendationBlock.toString(),
+ "input_products" to inputProducts,
+ "recommended_products" to getRecommendedProductIds(results),
+ "page_type" to (options["pageType"] as? String ?: "")
+ )
+
+ val eventName = EventEnum.VWO_RECOMMENDATION_SHOWN.value
+ createAndSendImpressionForTrack(it, eventName, context, data)
+ }
+ }
+
+ listener.onSuccess(recommendations)
+ } catch (e: Exception) {
+ listener.onFailure(e.message ?: e.toString())
+ }
+ return@thread
+ }
+ }
+
+ private fun getRecommendedProductIds(results: JSONArray?): String {
+ val resultString = results.toString()
+ val listType = object : TypeToken>() {}.type
+ val products:List = Gson().fromJson(resultString, listType)
+ return products.joinToString(separator = ",") { it.id }
+ }
+
+ fun getRecommendationWidget(featureFlag: GetFlag, overrideVariables:Map, callback:IVwoListener){
+ try {
+ val displayConfig = featureFlag.getRecommendationDisplayConfig("recommendationBlock")
+ if (displayConfig.isNullOrEmpty()) {
+ callback.onFailure("Invalid displayConfig")
+ return
+ }
+ val result = JSONObject(displayConfig)
+ for ((key, value) in overrideVariables) {
+ if (result.has(key)) {
+ result.put(key, value)
+ }
+ }
+ callback.onSuccess(result)
+ } catch (e:Exception) {
+ callback.onFailure(e.message?:e.toString())
+ }
+ }
+
+ override fun toString(): String {
+ return recommendationBlock.toString()
+ }
+}
diff --git a/fme-android/src/main/java/com/vwo/models/user/VWOContext.kt b/fme-android/src/main/java/com/vwo/models/user/VWOContext.kt
index f369891..71554a1 100644
--- a/fme-android/src/main/java/com/vwo/models/user/VWOContext.kt
+++ b/fme-android/src/main/java/com/vwo/models/user/VWOContext.kt
@@ -25,6 +25,7 @@ class VWOContext {
var userAgent: String = ""
var ipAddress: String = ""
var customVariables: MutableMap = HashMap()
+ var sessionId: Long = 0L
var variationTargetingVariables: MutableMap = HashMap()
diff --git a/fme-android/src/main/java/com/vwo/models/user/VWOInitOptions.kt b/fme-android/src/main/java/com/vwo/models/user/VWOInitOptions.kt
index 0ceb7d0..c901e00 100644
--- a/fme-android/src/main/java/com/vwo/models/user/VWOInitOptions.kt
+++ b/fme-android/src/main/java/com/vwo/models/user/VWOInitOptions.kt
@@ -15,11 +15,13 @@
*/
package com.vwo.models.user
+import android.content.Context
import com.vwo.VWOBuilder
import com.vwo.interfaces.networking.NetworkClientInterface
import com.vwo.packages.segmentation_evaluator.evaluators.SegmentEvaluator
import com.vwo.packages.storage.Connector
import com.vwo.interfaces.integration.IntegrationCallback
+import com.vwo.packages.storage.MobileDefaultStorage
/**
* Represents initialization options for the VWO SDK.
@@ -30,15 +32,18 @@ import com.vwo.interfaces.integration.IntegrationCallback
*/
class VWOInitOptions {
var sdkKey: String? = null
- var accountId: Int?=null
+ var accountId: Int? = null
var integrations: IntegrationCallback? = null
var logger: Map = HashMap()
var networkClientInterface: NetworkClientInterface? = null
var segmentEvaluator: SegmentEvaluator? = null
- var storage: Connector? = null
+ var storage: Connector = MobileDefaultStorage()
var pollInterval: Int? = null
var vwoBuilder: VWOBuilder? = null
var gatewayService: Map = HashMap()
+ var context: Context? = null
+ /**If this value is provided, SDK will keep using cached settings till this interval is valid.*/
+ var cachedSettingsExpiryTime: Int = 0
}
diff --git a/fme-android/src/main/java/com/vwo/packages/network_layer/client/ApiCallRepeater.kt b/fme-android/src/main/java/com/vwo/packages/network_layer/client/ApiCallRepeater.kt
new file mode 100644
index 0000000..b77a73d
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/network_layer/client/ApiCallRepeater.kt
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.packages.network_layer.client
+
+import com.google.gson.Gson
+import com.vwo.providers.StorageProvider
+import com.vwo.packages.logger.enums.LogLevelEnum
+import com.vwo.packages.network_layer.manager.NetworkManager
+import com.vwo.packages.network_layer.models.RequestModel
+import com.vwo.services.LoggerService
+
+/**
+ * An object responsible for repeating failed API calls.
+ *
+ * This object provides a mechanism to retry failed API requests that have been
+ * stored in a request store. It ensures that only one instance of the repeater
+ * is running at a time and allows for execution on a new thread if desired.
+ */
+object ApiCallRepeater {
+
+ /**
+ * A flag indicating whether the repeater is already running.
+ */
+ private var isAlreadyRunning = false
+
+ /**
+ * Starts the API call repeater.
+ *
+ * @param useNewThread A boolean flag indicating whether to execute the repeater
+ * on a new thread. Defaults to `false`.
+ * @return `true` if the repeater was started successfully, `false` otherwise.
+ */
+ fun start(useNewThread: Boolean = false): Boolean {
+
+ if (isAlreadyRunning) return false
+
+ isAlreadyRunning = true
+
+ if (useNewThread)
+ Thread { process() }.start()
+ else
+ process()
+
+ return true
+ }
+
+ /**
+ * Processes the API call repetition.
+ *
+ * This method executes all pending requests and resets the `isAlreadyRunning`
+ * flag to `false` when finished.
+ */
+ private fun process() {
+ executeAllRequests()
+ isAlreadyRunning = false
+ }
+
+ /**
+ * Executes all pending API requests.
+ *
+ * This method retrieves pending requests from the request store, iterates
+ * through them, and attempts to re-execute them. If a request is successful,
+ * it is removed from the store. A delay is introduced between requests to
+ * avoid overwhelming the server.
+ */
+ private fun executeAllRequests() {
+ try {
+ val requests = StorageProvider.requestStore?.getPendingRequests()
+ if (requests.isNullOrEmpty()) return
+
+ for (index in requests.lastIndex downTo 0) {
+ //This loop must be from last to first, to avoid IndexOutOfBounds exception
+ val request = requests[index]
+ val requestModel = Gson().fromJson(request, RequestModel::class.java)
+ val response = NetworkManager.post(requestModel)
+ if (response?.statusCode == 200) {
+ StorageProvider.requestStore?.removeRequest(index)
+ }
+ Thread.sleep(100)
+ }
+ } catch (e: Exception) {
+ LoggerService.log(LogLevelEnum.DEBUG, e.toString())
+ }
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/packages/network_layer/client/NetworkClient.kt b/fme-android/src/main/java/com/vwo/packages/network_layer/client/NetworkClient.kt
index dafd982..35fc1f4 100644
--- a/fme-android/src/main/java/com/vwo/packages/network_layer/client/NetworkClient.kt
+++ b/fme-android/src/main/java/com/vwo/packages/network_layer/client/NetworkClient.kt
@@ -32,51 +32,56 @@ import java.util.Locale
* This class provides functionality for sending HTTP requests and receiving responses.
*/
class NetworkClient : NetworkClientInterface {
+
+ private val maxRetryAttempts = 3
+
/**
* Performs a GET request using the provided RequestModel.
* @param request The model containing request options.
* @return A ResponseModel with the response data.
*/
override fun GET(request: RequestModel): ResponseModel {
- val responseModel = ResponseModel()
- try {
- val networkOptions = request.options
- val url = URL(constructUrl(networkOptions))
+ return retryWrapper {
+ val responseModel = ResponseModel()
+ try {
+ val networkOptions = request.options
+ val url = URL(constructUrl(networkOptions))
- val connection = url.openConnection() as HttpURLConnection
- connection.requestMethod = "GET"
+ val connection = url.openConnection() as HttpURLConnection
+ connection.requestMethod = "GET"
- //connection.setConnectTimeout(5000);
- connection.connect()
+ //connection.setConnectTimeout(5000);
+ connection.connect()
- val statusCode = connection.responseCode
- responseModel.statusCode = statusCode
+ val statusCode = connection.responseCode
+ responseModel.statusCode = statusCode
- val contentType = connection.getHeaderField("Content-Type")
+ val contentType = connection.getHeaderField("Content-Type")
- if (statusCode != 200 || !contentType.contains("application/json")) {
- val error =
- "Invalid response. Status Code: " + statusCode + ", Response : " + connection.responseMessage
- responseModel.error = Exception(error)
- return responseModel
- }
+ if (statusCode != 200 || !contentType.contains("application/json")) {
+ val error =
+ "Invalid response. Status Code: " + statusCode + ", Response : " + connection.responseMessage
+ responseModel.error = Exception(error)
+ return@retryWrapper responseModel
+ }
- val `in` = BufferedReader(InputStreamReader(connection.inputStream))
- var inputLine: String?
- val response = StringBuilder()
+ val `in` = BufferedReader(InputStreamReader(connection.inputStream))
+ var inputLine: String?
+ val response = StringBuilder()
- while ((`in`.readLine().also { inputLine = it }) != null) {
- response.append(inputLine)
- }
- `in`.close()
+ while ((`in`.readLine().also { inputLine = it }) != null) {
+ response.append(inputLine)
+ }
+ `in`.close()
- val responseData = response.toString()
- responseModel.data = responseData
+ val responseData = response.toString()
+ responseModel.data = responseData
- return responseModel
- } catch (exception: Exception) {
- responseModel.error = exception
- return responseModel
+ return@retryWrapper responseModel
+ } catch (exception: Exception) {
+ responseModel.error = exception
+ return@retryWrapper responseModel
+ }
}
}
@@ -86,65 +91,85 @@ class NetworkClient : NetworkClientInterface {
* @return A ResponseModel with the response data.
*/
override fun POST(request: RequestModel): ResponseModel {
- val responseModel = ResponseModel()
- try {
- val networkOptions = request.options
- val url = URL(constructUrl(networkOptions))
-
- val connection = url.openConnection() as HttpURLConnection
- connection.requestMethod = "POST"
- connection.doOutput = true
- // set headers
- for ((key, value) in networkOptions) {
- if (key == "headers") {
- val headers = value as Map
- for ((key1, value1) in headers) {
- connection.setRequestProperty(key1, value1)
- }
- }
- }
+ return retryWrapper {
+ val responseModel = ResponseModel()
+ try {
+ val networkOptions = request.options
+ val url = URL(constructUrl(networkOptions))
+
+ val connection = url.openConnection() as HttpURLConnection
+ connection.requestMethod = "POST"
+ connection.doOutput = true
- connection.outputStream.use { os ->
val body = networkOptions["body"]
- if (body is LinkedHashMap<*, *>) {
- // Convert LinkedHashMap to JSON string
+ val bodyArray = if (body is LinkedHashMap<*, *>) {
val jsonBody: String = VWOClient.objectMapper.writeValueAsString(body)
- val input = jsonBody.toByteArray(StandardCharsets.UTF_8)
- os.write(input, 0, input.size)
+ jsonBody.toByteArray(StandardCharsets.UTF_8)
} else if (body is String) {
- val input = body.toByteArray(StandardCharsets.UTF_8)
- os.write(input, 0, input.size)
+ body.toByteArray(StandardCharsets.UTF_8)
} else {
throw IllegalArgumentException("Unsupported body type: " + body?.javaClass?.name)
}
- }
- val statusCode = connection.responseCode
- responseModel.statusCode = statusCode
- val `in` = BufferedReader(InputStreamReader(connection.inputStream, "utf-8"))
- val response = StringBuilder()
- var inputLine: String?
+ // set headers
+ for ((key, value) in networkOptions) {
+ if (key == "headers") {
+ val headers = value as Map
+ for ((key1, value1) in headers) {
+ connection.setRequestProperty(key1, value1)
+ }
+ if (bodyArray.isNotEmpty())
+ connection.setRequestProperty(
+ "Content-Length",
+ bodyArray.size.toString()
+ )
+ }
+ }
- while ((`in`.readLine().also { inputLine = it }) != null) {
- response.append(inputLine)
- }
- `in`.close()
+ connection.outputStream.use { os ->
+ os.write(bodyArray)
+ os.flush()
+ }
+ val statusCode = connection.responseCode
+ responseModel.statusCode = statusCode
- val responseData = response.toString()
- responseModel.data = responseData
+ val `in` = BufferedReader(InputStreamReader(connection.inputStream, "utf-8"))
+ val response = StringBuilder()
+ var inputLine: String?
- if (statusCode != 200) {
- val error = "Request failed. Status Code: $statusCode, Response: $responseData"
- responseModel.error = Exception(error)
- }
+ while ((`in`.readLine().also { inputLine = it }) != null) {
+ response.append(inputLine)
+ }
+ `in`.close()
+
+ val responseData = response.toString()
+ responseModel.data = responseData
- return responseModel
- } catch (exception: Exception) {
- responseModel.error = exception
- return responseModel
+ if (statusCode != 200) {
+ val error = "Request failed. Status Code: $statusCode, Response: $responseData"
+ responseModel.error = Exception(error)
+ }
+
+ return@retryWrapper responseModel
+ } catch (exception: Exception) {
+ responseModel.error = exception
+ responseModel.statusCode = 404
+ return@retryWrapper responseModel
+ }
}
}
+ private fun retryWrapper(requestProcessor: () -> ResponseModel): ResponseModel {
+ var countOfRetries = 0
+ var response: ResponseModel
+ do {
+ response = requestProcessor()
+ countOfRetries++
+ } while (countOfRetries < maxRetryAttempts && response.error != null)
+
+ return response
+ }
+
companion object {
/**
* Constructs a URL from network options.
@@ -154,7 +179,8 @@ class NetworkClient : NetworkClientInterface {
* @param networkOptions A map containing network options.
* @return The constructed URL string.
*/
- fun constructUrl(networkOptions: Map): String {var hostname = networkOptions["hostname"] as String?
+ fun constructUrl(networkOptions: Map): String {
+ var hostname = networkOptions["hostname"] as String?
val path = networkOptions["path"] as String?
if (networkOptions["port"] != null && networkOptions["port"].toString().toInt() != 0) {
hostname += ":" + networkOptions["port"]
diff --git a/fme-android/src/main/java/com/vwo/packages/network_layer/manager/NetworkManager.kt b/fme-android/src/main/java/com/vwo/packages/network_layer/manager/NetworkManager.kt
index a7e93d6..9a7884d 100644
--- a/fme-android/src/main/java/com/vwo/packages/network_layer/manager/NetworkManager.kt
+++ b/fme-android/src/main/java/com/vwo/packages/network_layer/manager/NetworkManager.kt
@@ -15,7 +15,9 @@
*/
package com.vwo.packages.network_layer.manager
+import com.google.gson.Gson
import com.vwo.interfaces.networking.NetworkClientInterface
+import com.vwo.providers.StorageProvider
import com.vwo.packages.logger.enums.LogLevelEnum
import com.vwo.packages.network_layer.client.NetworkClient
import com.vwo.packages.network_layer.handlers.RequestHandler
@@ -118,7 +120,13 @@ object NetworkManager {
*/
fun postAsync(request: RequestModel) {
executorService.submit {
- post(request)
+ val response = post(request)
+ if (StorageProvider.requestStore == null) return@submit
+
+ if (response == null || response.statusCode != 200) {
+ val requestString = Gson().toJson(request)
+ StorageProvider.requestStore?.addRequest(requestString)
+ }
}
}
}
diff --git a/fme-android/src/main/java/com/vwo/packages/network_layer/models/RequestModel.kt b/fme-android/src/main/java/com/vwo/packages/network_layer/models/RequestModel.kt
index abc00b9..466e29b 100644
--- a/fme-android/src/main/java/com/vwo/packages/network_layer/models/RequestModel.kt
+++ b/fme-android/src/main/java/com/vwo/packages/network_layer/models/RequestModel.kt
@@ -69,9 +69,7 @@ class RequestModel(
}
if (body != null) {
- val postBody: String = Gson().toJson(body)
headers?.set("Content-Type", "application/json")
- headers?.set("Content-Length", postBody.toByteArray().size.toString())
options["headers"] = headers
options["body"] = body
}
diff --git a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/core/SegmentationManager.kt b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/core/SegmentationManager.kt
index 3837273..2d5c6b4 100644
--- a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/core/SegmentationManager.kt
+++ b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/core/SegmentationManager.kt
@@ -82,8 +82,11 @@ object SegmentationManager {
try {
val params = GatewayServiceUtil.getQueryParams(queryParams)
- val vwo = GatewayServiceUtil.getFromGatewayService(params, UrlEnum.GET_USER_DATA.url)
- val gatewayServiceModel = VWOClient.objectMapper.readValue(vwo, GatewayService::class.java)
+ val vwo =
+ GatewayServiceUtil.getFromGatewayService(params, UrlEnum.GET_USER_DATA.url)
+ val gatewayServiceModel =
+ VWOClient.objectMapper.readValue(vwo, GatewayService::class.java)
+
context.vwo = gatewayServiceModel
} catch (err: Exception) {
LoggerService.log(
@@ -102,10 +105,10 @@ object SegmentationManager {
*/
fun validateSegmentation(dsl: Any, properties: Map): Boolean {
try {
- val dslNodes: JsonNode = if (dsl is String) VWOClient.objectMapper.readValue(
- dsl.toString(),
- JsonNode::class.java
- ) else VWOClient.objectMapper.valueToTree(dsl)
+ val dslNodes: JsonNode = if (dsl is String)
+ VWOClient.objectMapper.readValue(dsl.toString(), JsonNode::class.java)
+ else
+ VWOClient.objectMapper.valueToTree(dsl)
return evaluator?.isSegmentationValid(dslNodes, properties)?:false
} catch (exception: Exception) {
LoggerService.log(
diff --git a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentEvaluator.kt b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentEvaluator.kt
index 124f5d8..08118ab 100644
--- a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentEvaluator.kt
+++ b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentEvaluator.kt
@@ -291,7 +291,7 @@ class SegmentEvaluator {
try {
val storageMapAsString: String =
VWOClient.objectMapper.writeValueAsString(storedDataMap)
- val storedData: Storage =
+ val storedData: Storage? =
VWOClient.objectMapper.readValue(storageMapAsString, Storage::class.java)
return storedData != null && (storedDataMap?.size ?: 0) > 1
diff --git a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentOperandEvaluator.kt b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentOperandEvaluator.kt
index ffffb3e..9494291 100644
--- a/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentOperandEvaluator.kt
+++ b/fme-android/src/main/java/com/vwo/packages/segmentation_evaluator/evaluators/SegmentOperandEvaluator.kt
@@ -60,7 +60,7 @@ class SegmentOperandEvaluator {
// Handle 'inlist' operand
if (operandValue.contains("inlist")) {
- val listIdPattern = Pattern.compile("inlist\\((\\w+:\\d+)\\)")
+ val listIdPattern = Pattern.compile("inlist\\(([^)]+)\\)")
val matcher = listIdPattern.matcher(operandValue)
if (!matcher.find()) {
LoggerService.log(LogLevelEnum.ERROR, "Invalid 'inList' operand format")
diff --git a/fme-android/src/main/java/com/vwo/packages/storage/DefaultStorage.kt b/fme-android/src/main/java/com/vwo/packages/storage/DefaultStorage.kt
new file mode 100644
index 0000000..2c5738d
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/storage/DefaultStorage.kt
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.packages.storage
+
+import android.content.Context
+
+/**
+ * A default implementation of the `LocalStorageController` interface.
+ * This class provides methods for storing and retrieving data from the device's
+ * local storage using SharedPreferences. It uses a default storage key to store
+ * the data and provides methods for accessing and managing feature keys.
+ */
+internal class DefaultStorage(context: Context) : LocalStorageController(context) {
+
+ /**
+ * The default storage key used to store the data.
+ */
+ private val DEFAULT_STORAGE_STORE_KEY = "Storage"
+
+ /**
+ * Retrieves the feature key from the storage.
+ *
+ * @param featureKey The key used to identify the feature.
+ * @return The feature key if found, or an empty string otherwise.
+ */
+ fun getFeatureKey(featureKey: String): String {
+ return getString(getKey(featureKey))
+ }
+
+ /**
+ * Saves the feature key to the storage.
+ *
+ * @param featureKey The key used to identify the feature.
+ * @param feature The feature value to be stored.
+ */
+ fun saveFeatureKey(featureKey: String, feature: String) {
+ saveString(getKey(featureKey), feature)
+ }
+
+ /**
+ * Clears the feature key from the storage.
+ *
+ * @param featureKey The key used to identify the feature.
+ */
+ fun clearFeatureKey(featureKey: String) {
+ clearData(getKey(featureKey))
+ }
+
+ /**
+ * Generates the storage key for a given feature key.
+ *
+ * @param featureKey The key used to identify the feature.
+ * @return The storage key.
+ */
+ private fun getKey(featureKey: String): String {
+ return DEFAULT_STORAGE_STORE_KEY + featureKey
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/packages/storage/LocalStorageController.kt b/fme-android/src/main/java/com/vwo/packages/storage/LocalStorageController.kt
new file mode 100644
index 0000000..83c8b02
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/storage/LocalStorageController.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.packages.storage
+
+import android.content.Context
+import android.content.Context.MODE_PRIVATE
+import android.content.SharedPreferences
+
+/**
+ * An abstract class that provides methods for accessing and managing local storage.*
+ * This class uses SharedPreferences to store and retrieve data. It provides methods
+ * for getting and saving strings and longs, as well as clearing data for specific keys.
+ */
+internal open class LocalStorageController(context: Context) {
+
+ /**
+ * The name of the Shared Preferences file.
+ */
+ private val sharedPrefs = "vwo_fme_shared_prefs"
+
+ /**
+ * The SharedPreferences instance.
+ */
+ private val sharedPreferences = context.getSharedPreferences(sharedPrefs, MODE_PRIVATE)
+
+ /**
+ * Retrieves a string value from the storage.
+ *
+ * @param key The key associated with the string value.
+ * @return The string value if found, or an empty string otherwise.
+ */
+ fun getString(key: String): String {
+ return sharedPreferences.getString(key,"") ?: ""
+ }
+
+ /**
+ * Saves a string value to the storage.
+ *
+ * @param key The key associated with the string value.
+ * @param value The string value to be saved.
+ */
+ fun saveString(key: String, value: String) {
+ val editor = sharedPreferences.edit()
+ editor.putString(key, value)
+ editor.apply()
+ }
+
+ /**
+ * Retrieves a long value from the storage.
+ *
+ * @param key The key associated with the long value.
+ * @return The long value if found, or -1 otherwise.
+ */
+ fun getLong(key: String): Long {
+ return sharedPreferences.getLong(key, -1)
+ }
+
+ /**
+ * Saves a long value to the storage.
+ *
+ * @param key The key associated with the long value.
+ * @param value The long value to be saved.
+ */
+ fun saveLong(key: String, value: Long) {
+ val editor = sharedPreferences.edit()
+ editor.putLong(key,value)
+ editor.apply()
+ }
+
+ /**
+ * Clears the data associated with a specific key.
+ *
+ * @param key The key associated with the data to be cleared.
+ */
+ fun clearData(key: String) {
+ val editor: SharedPreferences.Editor = sharedPreferences.edit()
+ editor.remove(key)
+ editor.apply()
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/packages/storage/MobileDefaultStorage.kt b/fme-android/src/main/java/com/vwo/packages/storage/MobileDefaultStorage.kt
new file mode 100644
index 0000000..7641fbb
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/storage/MobileDefaultStorage.kt
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package com.vwo.packages.storage
+
+import com.vwo.providers.StorageProvider.contextRef
+import com.vwo.utils.toMap
+import org.json.JSONObject
+
+/**
+ * A class that provides a default implementation for storing and retrieving data* using the device's local storage.
+ *
+ * This class implements the `Connector` interface and uses a `DefaultStorage`
+ * instance to interact with the local storage. It provides methods for setting
+ * and getting data associated with feature keys and user IDs.
+ */
+class MobileDefaultStorage :Connector() {
+
+ /**
+ * The instance of `DefaultStorage` used for local storage operations.
+ */
+ private var storage: DefaultStorage? = null
+
+ /**
+ * Initializes the `MobileDefaultStorage` instance.
+ *
+ * This method retrieves the application context and initializes the
+ * `storage` instance using the context.
+ */
+ fun init() {
+ val context = contextRef.get()
+ context?.let { storage = DefaultStorage(context) }
+ }
+
+ /**
+ * Stores data associated with a feature key and userID.
+ *
+ * @param data A map containing the data to be stored. The map should
+ * contain the following keys:
+ * - "featureKey": The feature key for the data.
+ * - "user": The user ID for the data.
+ * - "rolloutKey": The rollout key for the data (optional).
+ * - "rolloutVariationId": The rollout variation ID for the data (optional).
+ * - "experimentKey": The experiment key for the data (optional).
+ * - "experimentVariationId": The experiment variation ID for the data (optional).
+ * - "rolloutId": The rollout ID for the data (optional).
+ * - "experimentId": The experiment ID for the data (optional).
+ */
+ override fun set(data: Map) {
+ if (storage == null) return
+
+ val key = data["featureKey"].toString() + "_" + data["userId"]
+
+ // Create a map to store the data
+ val value: MutableMap = HashMap()
+ data["rolloutKey"]?.let { value["rolloutKey"] = it }
+ data["rolloutVariationId"]?.let { value["rolloutVariationId"] = it }
+ data["experimentKey"]?.let { value["experimentKey"] = it }
+ data["experimentVariationId"]?.let { value["experimentVariationId"] = it }
+
+ data["rolloutId"]?.let { value["rolloutId"] = it }
+ data["experimentId"]?.let { value["experimentId"] = it }
+
+ val jsonValue = JSONObject(value)
+ // Store the value in the storage
+ storage?.saveFeatureKey(key, jsonValue.toString())
+ }
+
+ /**
+ * Retrieves data associated with a feature key and user ID.
+ *
+ * @param featureKey The feature key for the data.
+ * @param userId The user ID for the data.
+ * @return The data if found, or null otherwise.
+ */
+ override fun get(featureKey: String?, userId: String?): Any? {
+ val key = featureKey + "_" + userId
+
+ val stringValue = storage?.getFeatureKey(key)
+ // Check if the key exists in the storage
+ if (stringValue.isNullOrEmpty()) {
+ return null
+ }
+ return JSONObject(stringValue).toMap()
+ }
+}
diff --git a/fme-android/src/main/java/com/vwo/packages/storage/RequestStore.kt b/fme-android/src/main/java/com/vwo/packages/storage/RequestStore.kt
new file mode 100644
index 0000000..534baac
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/storage/RequestStore.kt
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.packages.storage
+
+import android.content.Context
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.google.gson.reflect.TypeToken
+import com.vwo.packages.logger.enums.LogLevelEnum
+import com.vwo.services.LoggerService.Companion.log
+
+/**
+ * A class for managing pending API requests.
+ *
+ * This class uses local storage to persist pending requests and provides methods
+ * for adding, retrieving, removing, and clearing requests. It utilizes Gson
+ * for JSON serialization and deserialization.
+ */
+internal class RequestStore(context: Context) : LocalStorageController(context) {
+
+ /**
+ * The key used to store pending requests in local storage.
+ */
+ private val KEY = "PendingRequests"
+
+ /**
+ * A mutable list to store pending requests.
+ */
+ private val pendingRequests = mutableListOf()
+
+ /**
+ * Retrieves the list of pending requests.
+ *
+ * This method retrieves pending requests from local storage and populates
+ * the `pendingRequests` list. If the list is already populated, it is
+ * returned directly. If there are no pending requests in local storage,
+ * an empty list is returned.
+ * @return The list of pending requests.
+ */
+ fun getPendingRequests(): List {
+ if (pendingRequests.isNotEmpty()) return pendingRequests
+
+ val stringArray = getString(KEY)
+ if (stringArray.isEmpty()) return pendingRequests
+ try {
+ val myType = object : TypeToken>() {}.type
+ val requests = Gson().fromJson>(stringArray, myType)
+ pendingRequests.addAll(requests)
+ } catch (e: JsonSyntaxException) {
+ val map = mutableMapOf()
+ map["err"] = e.message
+ log(LogLevelEnum.ERROR, "PARSING_ERROR", map)
+ }
+ return pendingRequests
+ }
+
+ /**
+ * Adds a request to the list of pending requests.
+ *
+ * @param request The request to be added.
+ */
+ fun addRequest(request: String) {
+ pendingRequests.add(request)
+ saveAllRequests()
+ }
+
+ /**
+ * Saves all pending requests to local storage.
+ *
+ * This method serializes the `pendingRequests`list to JSON using Gson
+ * and saves it to local storage using the `KEY`.
+ */
+ private fun saveAllRequests() {
+ saveString(key = KEY, Gson().toJson(pendingRequests))
+ }
+
+ /**
+ * Clears all pending requests from local storage.
+ */
+ fun clearSettings() {
+ clearData(KEY)
+ }
+
+ /**
+ * Removes a request from the list of pending requests.
+ *
+ * @param index The index of the request to be removed.
+ */
+ fun removeRequest(index: Int) {
+ pendingRequests.removeAt(index)
+ saveAllRequests()
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/packages/storage/SettingsStore.kt b/fme-android/src/main/java/com/vwo/packages/storage/SettingsStore.kt
new file mode 100644
index 0000000..3dc81e2
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/packages/storage/SettingsStore.kt
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.packages.storage
+
+import android.content.Context
+
+/**
+ * A class for managing the storage and retrieval of settings data.*
+ * This class uses local storage to persist settings data and provides methods
+ * for getting, saving, and clearing settings. It also manages the expiry time
+ * of the settings data.
+ */
+internal class SettingsStore(context: Context) : LocalStorageController(context) {
+
+ /*** The key used to store the settings data in local storage.
+ */
+ private val SETTINGS_KEY = "settings"
+
+ /**
+ * The key used to store the settings expiry time in local storage.
+ */
+ private val SETTINGS_EXPIRY_KEY = "settingsExpiry"
+
+ /**
+ * Retrieves the settings data from local storage.
+ *
+ * @return The settings data as a string.
+ */
+ fun getSettings(): String {
+ return getString(SETTINGS_KEY)
+ }
+
+ /**
+ * Saves the settings data to local storage.
+ *
+ * @param settings The settings data to be saved.
+ */
+ fun saveSettings(settings: String) {
+ saveString(SETTINGS_KEY, settings)
+ }
+
+ /**
+ * Clears the settings data from local storage.
+ */
+ fun clearSettings() {
+ clearData(SETTINGS_KEY)
+ }
+
+ /**
+ * Retrieves the settings expiry time from local storage.
+ *
+ * @return The settings expiry time as a long value.
+ */
+ fun getSettingsExpiry(): Long {
+ return getLong(SETTINGS_EXPIRY_KEY)
+ }
+
+ /**
+ * Saves the settings expiry time to local storage.
+ *
+ * @param expiryTime The settings expiry time to be saved.
+ */
+ fun saveSettingsExpiry(expiryTime: Long) {
+ saveLong(SETTINGS_EXPIRY_KEY, expiryTime)
+ }
+
+ /**
+ * Clears the settings expiry time from local storage.
+ */
+ fun clearSettingsExpiry() {
+ clearData(SETTINGS_EXPIRY_KEY)
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/providers/StorageProvider.kt b/fme-android/src/main/java/com/vwo/providers/StorageProvider.kt
new file mode 100644
index 0000000..d3c60ee
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/providers/StorageProvider.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.providers
+
+import android.content.Context
+import com.vwo.packages.storage.RequestStore
+import com.vwo.packages.storage.SettingsStore
+import java.lang.ref.WeakReference
+
+/**
+ * An object that provides access to various components and data stores.
+ * This object acts as a central point for accessing instances of `SettingsStore`,
+ * `RequestStore`, and the application context. It uses weak references to avoid
+ * memory leaks.
+ */
+internal object StorageProvider {
+
+ /**
+ * The instance of `SettingsStore` used to manage settingsdata.
+ */
+ var settingsStore: SettingsStore? = null
+
+ /**
+ * The instance of `RequestStore` used to manage API requests.
+ */
+ var requestStore: RequestStore? = null
+
+ /**
+ * A weak reference to the application context.
+ */
+ var contextRef: WeakReference = WeakReference(null)
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/services/CampaignDecisionService.kt b/fme-android/src/main/java/com/vwo/services/CampaignDecisionService.kt
index 3236ffc..d845863 100644
--- a/fme-android/src/main/java/com/vwo/services/CampaignDecisionService.kt
+++ b/fme-android/src/main/java/com/vwo/services/CampaignDecisionService.kt
@@ -23,6 +23,8 @@ import com.vwo.models.user.VWOContext
import com.vwo.packages.decision_maker.DecisionMaker
import com.vwo.packages.logger.enums.LogLevelEnum
import com.vwo.packages.segmentation_evaluator.core.SegmentationManager
+import com.vwo.utils.EventsUtils
+
/**
* Provides decision-making logic for campaigns.
@@ -62,8 +64,13 @@ class CampaignDecisionService {
object : HashMap() {
init {
put("userId", userId)
- put("campaignKey", campaign.ruleKey)
put("notPart", if (isUserPart) "" else "not")
+ put("campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
}
})
return isUserPart
@@ -141,37 +148,57 @@ class CampaignDecisionService {
fun getPreSegmentationDecision(campaign: Campaign, context: VWOContext): Boolean {
val campaignType = campaign.type
- val segments =
+ val segmentsEvents =
if (campaignType == CampaignTypeEnum.ROLLOUT.value || campaignType == CampaignTypeEnum.PERSONALIZE.value) {
+ campaign.variations!![0].segments_events
+ } else if (campaignType == CampaignTypeEnum.AB.value) {
+ campaign.segments_events
+ } else {
+ emptyList()
+ }
+ var segments: Map? = emptyMap()
+ if (!segmentsEvents.isNullOrEmpty()) {
+ segments = mapOf("cnds" to segmentsEvents)
+ } else {
+ segments = if (campaignType == CampaignTypeEnum.ROLLOUT.value || campaignType == CampaignTypeEnum.PERSONALIZE.value) {
campaign.variations!![0].segments
} else if (campaignType == CampaignTypeEnum.AB.value) {
- campaign.segments
+ campaign.segments ?: emptyMap()
} else {
emptyMap()
}
-
- if (segments!!.isEmpty()) {
+ }
+ if (segments.isEmpty()) {
LoggerService.log(
LogLevelEnum.INFO,
"SEGMENTATION_SKIP",
object : HashMap() {
init {
put("userId", context.id)
- put("campaignKey", campaign.ruleKey)
+ put("campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
}
})
return true
} else {
- val preSegmentationResult = SegmentationManager.validateSegmentation(
- segments, context.customVariables
- )
+
+ val preSegmentationResult = getPreSegmentationResult(campaign, context, segments)
LoggerService.log(
LogLevelEnum.INFO,
"SEGMENTATION_STATUS",
object : HashMap() {
init {
put("userId", context.id)
- put("campaignKey", campaign.ruleKey)
+ put("campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
put("status", if (preSegmentationResult) "passed" else "failed")
}
})
@@ -179,6 +206,21 @@ class CampaignDecisionService {
}
}
+ private fun getPreSegmentationResult(
+ campaign: Campaign,
+ context: VWOContext,
+ segments: Map
+ ): Boolean {
+ val preSegmentationResult = if (campaign.isEventsDsl) {
+ EventsUtils().getEventsPreSegmentation(segments, context)
+ } else {
+ SegmentationManager.validateSegmentation(
+ segments, context.customVariables
+ )
+ }
+ return preSegmentationResult
+ }
+
/**
* This method is used to get the variation allotted to the user in the campaign.
* @param userId User ID for which the variation is to be allotted.
diff --git a/fme-android/src/main/java/com/vwo/services/SettingsManager.kt b/fme-android/src/main/java/com/vwo/services/SettingsManager.kt
index 7875227..7c6861b 100644
--- a/fme-android/src/main/java/com/vwo/services/SettingsManager.kt
+++ b/fme-android/src/main/java/com/vwo/services/SettingsManager.kt
@@ -17,6 +17,7 @@ package com.vwo.services
import com.vwo.VWOClient
import com.vwo.constants.Constants
+import com.vwo.providers.StorageProvider
import com.vwo.models.Settings
import com.vwo.models.schemas.SettingsSchema
import com.vwo.models.user.VWOInitOptions
@@ -35,10 +36,9 @@ import java.net.URL
*/
class SettingsManager(options: VWOInitOptions) {
private val sdkKey = options.sdkKey
- private val accountId = options.accountId
+ val accountId = options.accountId
- // TODO -- check expiry logic
- private val expiry = Constants.SETTINGS_EXPIRY.toInt()
+ private val cachedSettingsExpiryInterval = options.cachedSettingsExpiryTime
private val networkTimeout = Constants.SETTINGS_TIMEOUT.toInt()
var hostname: String
@@ -46,11 +46,11 @@ class SettingsManager(options: VWOInitOptions) {
var port: Int = 0
@JvmField
- var protocol: String = "https"
+ var protocol: String = Constants.HTTPS_PROTOCOL
var isGatewayServiceProvided: Boolean = false
init {
- if (options.gatewayService != null && !options.gatewayService.isEmpty()) {
+ if (options.gatewayService.isNotEmpty()) {
isGatewayServiceProvided = true
try {
val parsedUrl: URL
@@ -60,8 +60,8 @@ class SettingsManager(options: VWOInitOptions) {
parsedUrl =
if (gatewayServiceUrl.startsWith("http://") || gatewayServiceUrl.startsWith("https://")) {
URL(gatewayServiceUrl)
- } else if (gatewayServiceProtocol != null && !gatewayServiceProtocol.toString()
- .isEmpty()
+ } else if (gatewayServiceProtocol != null
+ && gatewayServiceProtocol.toString().isNotEmpty()
) {
URL("$gatewayServiceProtocol://$gatewayServiceUrl")
} else {
@@ -90,22 +90,62 @@ class SettingsManager(options: VWOInitOptions) {
/**
* Fetches settings from the server
*/
- private fun fetchSettingsAndCacheInStorage(): String? {
+ private fun fetchFromCacheOrServer(): String? {
try {
- return fetchSettings()
+ var responseString: String?
+
+ if (canUseCachedSettings()) {
+ responseString = getCachedSetting()
+ if (responseString.isNullOrEmpty()) {
+ responseString = fetchAndCacheServerSettings()
+ }
+ } else {
+ responseString = fetchSettings()
+ if (!responseString.isNullOrEmpty()) {
+ updateSettingsCache(responseString)
+ } else if (cachedSettingsAllowed()) {
+ //Return settings even if it is expired - SDK should work as long as there is setting in cache.
+ responseString = getCachedSetting()
+ }
+ }
+ return responseString
} catch (e: Exception) {
- LoggerService.log(
- LogLevelEnum.ERROR,
- "SETTINGS_FETCH_ERROR",
- object : HashMap() {
- init {
- put("err", e.toString())
- }
- })
+ val map = mapOf("err" to e.toString())
+ LoggerService.log(LogLevelEnum.ERROR, "SETTINGS_FETCH_ERROR", map)
}
return null
}
+ private fun cachedSettingsAllowed() = cachedSettingsExpiryInterval != 0
+
+ private fun fetchAndCacheServerSettings(): String? {
+ val response: String? = fetchSettings()
+ if (response != null) {
+ updateSettingsCache(response)
+ }
+ return response
+ }
+
+ private fun updateSettingsCache(responseString: String) {
+ StorageProvider.settingsStore?.saveSettings(responseString)
+ val expiryTime = System.currentTimeMillis() + cachedSettingsExpiryInterval
+ StorageProvider.settingsStore?.saveSettingsExpiry(expiryTime)
+ }
+
+ private fun getCachedSetting(): String? {
+ return StorageProvider.settingsStore?.getSettings()
+ }
+
+ private fun canUseCachedSettings(): Boolean {
+ if (cachedSettingsExpiryInterval == 0) return false
+ return isCachedSettingValid()
+ }
+
+ private fun isCachedSettingValid(): Boolean {
+ val expiryTime = StorageProvider.settingsStore?.getSettingsExpiry() ?: -1
+ return expiryTime != -1L && System.currentTimeMillis() <= expiryTime
+ }
+
/**
* Fetches settings from the server
* @return settings
@@ -135,7 +175,7 @@ class SettingsManager(options: VWOInitOptions) {
val response = NetworkManager.get(request)
if (response?.statusCode != 200) {
- LoggerService.Companion.log(
+ LoggerService.log(
LogLevelEnum.ERROR,
"SETTINGS_FETCH_ERROR",
object : HashMap() {
@@ -164,19 +204,17 @@ class SettingsManager(options: VWOInitOptions) {
*/
fun getSettings(forceFetch: Boolean): String? {
if (forceFetch) {
- return fetchSettingsAndCacheInStorage()
+ LoggerService.log(LogLevelEnum.INFO, "Settings: Fetched from: ServerPoll")
+ return fetchAndCacheServerSettings()
} else {
try {
- val settings = fetchSettingsAndCacheInStorage()
+ val settings = fetchFromCacheOrServer()
if (settings == null) {
LoggerService.log(LogLevelEnum.ERROR, "SETTINGS_SCHEMA_INVALID", null)
return null
}
val settingsValid = SettingsSchema().isSettingsValid(
- VWOClient.objectMapper.readValue(
- settings,
- Settings::class.java
- )
+ VWOClient.objectMapper.readValue(settings, Settings::class.java)
)
if (settingsValid) {
return settings
diff --git a/fme-android/src/main/java/com/vwo/services/StorageService.kt b/fme-android/src/main/java/com/vwo/services/StorageService.kt
index 957c60c..31c8743 100644
--- a/fme-android/src/main/java/com/vwo/services/StorageService.kt
+++ b/fme-android/src/main/java/com/vwo/services/StorageService.kt
@@ -37,7 +37,7 @@ class StorageService {
fun getDataInStorage(featureKey: String?, context: VWOContext): Map? {
val storageInstance = Storage.instance?.getConnector() ?: return null
try {
- return (storageInstance as Connector).get(featureKey, context.id) as Map
+ return (storageInstance as Connector).get(featureKey, context.id) as? Map
} catch (e: Exception) {
LoggerService.log(
LogLevelEnum.ERROR,
diff --git a/fme-android/src/main/java/com/vwo/utils/AppLifecycleListener.kt b/fme-android/src/main/java/com/vwo/utils/AppLifecycleListener.kt
new file mode 100644
index 0000000..e0d9cc1
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/utils/AppLifecycleListener.kt
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.utils
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import com.vwo.packages.logger.enums.LogLevelEnum
+import com.vwo.packages.network_layer.client.ApiCallRepeater
+import com.vwo.services.LoggerService
+
+/**
+ * A class that listens to the application's activity lifecycle events.*
+ * This class implements the `Application.ActivityLifecycleCallbacks` interface
+ * and provides methods to start and stop listening to activity lifecycle events.
+ * It also keeps track of the number of active activities and triggers actions
+ * based on the activity lifecycle state.
+ */
+class AppLifecycleListener : Application.ActivityLifecycleCallbacks {
+
+ /**
+ * The number of active activities.
+ */
+ private var activityCounter = 0
+
+ /**
+ * Starts listening to activity lifecycle events.
+ *
+ * @param application The application instance to register the lifecycle callbacks with.
+ */
+ fun start(application: Application) {
+ application.registerActivityLifecycleCallbacks(this)
+ }
+
+ /**
+ * Stops listening to activity lifecycle events.
+ *
+ * @param application The application instance to unregister the lifecycle callbacks from.
+ */
+ fun stop(application: Application) {
+ application.unregisterActivityLifecycleCallbacks(this)
+ }
+
+ /**
+ * Called when an activity is created.
+ *
+ * @param activity The activity that was created.
+ * @param savedInstanceState If the activity is being re-created after
+ * previously being destroyed, then this Bundle contains the data it most
+ * recently supplied in [onSaveInstanceState].
+ * **Note: Otherwise it is null.**
+ */
+ override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+ }
+
+ /**
+ * Called when an activity is started.
+ *
+ * @param activity The activity that was started.
+ */
+ override fun onActivityStarted(activity: Activity) {
+ activityCounter++
+ LoggerService.log(LogLevelEnum.INFO, "APP_LIFECYCLE_EVENT $activityCounter")
+ }
+
+ /**
+ * Called when an activity is resumed.
+ *
+ * @param activity The activity that was resumed.
+ */
+ override fun onActivityResumed(activity: Activity) {
+ }
+
+ /**
+ * Called whenan activity is paused.
+ *
+ * @param activity The activity that was paused.
+ */
+ override fun onActivityPaused(activity: Activity) {
+ }
+
+ /**
+ * Called when an activity is stopped. This is used to trigger the API call repeater when app
+ * is finished off all activities.
+ *
+ * @param activity The activity that was stopped.
+ */
+ override fun onActivityStopped(activity: Activity) {
+ activityCounter--
+ if (activityCounter <= 0) {
+ ApiCallRepeater.start()
+ }
+ LoggerService.log(LogLevelEnum.INFO, "APP_LIFECYCLE_EVENT $activityCounter")
+ }
+
+ /**
+ * Called to retrieve per-instance state from an activity before being killed
+ * so that the state can be restored in [onActivityCreated] or
+ * [onRestoreInstanceState] (the [Bundle] populated by this method
+ * will be passed to both).
+ *
+ * @param activity The activity that was stopped.
+ * @param outState Bundle in which to place your saved state.
+ */
+ override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
+ }
+
+ /**
+ * Called when an activity is destroyed.
+ *
+ * @param activity The activity that was destroyed.
+ */
+ override fun onActivityDestroyed(activity: Activity) {
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/utils/CampaignUtil.kt b/fme-android/src/main/java/com/vwo/utils/CampaignUtil.kt
index ccb6021..5b7f76c 100644
--- a/fme-android/src/main/java/com/vwo/utils/CampaignUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/CampaignUtil.kt
@@ -28,6 +28,7 @@ import java.util.function.Consumer
import kotlin.math.ceil
import kotlin.math.min
+
/**
* Utility class for campaign operations.
*
@@ -166,15 +167,23 @@ object CampaignUtil {
*/
fun getGroupDetailsIfCampaignPartOfIt(
settings: Settings,
- campaignId: Int
- ): Map {
- // Check if the campaign is associated with a group and return the group details
- val groupDetails: MutableMap = HashMap()
- if (settings.campaignGroups != null && settings.campaignGroups!!.containsKey(campaignId.toString())) {
- val groupId = settings.campaignGroups!![campaignId.toString()]!!
- val groupName = settings.groups!![groupId.toString()]!!.name
+ campaignId: Int,
+ variationId: Int
+ ): MutableMap {
+ // If variationId is null, that means that campaign is testing campaign
+ // If variationId is not null, that means that campaign is personalization campaign and we need to append variationId to campaignId using _
+ // then check if the current campaign is part of any group
+ val groupDetails: MutableMap = HashMap()
+ var campaignToCheck = campaignId.toString()
+ if (variationId != -1) {
+ campaignToCheck = campaignToCheck + "_" + variationId
+ }
+ val campaignGroups = settings.campaignGroups
+ if (campaignGroups!= null && campaignGroups.containsKey(campaignToCheck)) {
+ val groupId = campaignGroups[campaignToCheck]
+ val groupName = settings.groups?.get(groupId.toString())?.name
groupDetails["groupId"] = groupId.toString()
- groupDetails["groupName"] = groupName
+ groupDetails["groupName"] = groupName?:""
return groupDetails
}
return groupDetails
@@ -188,27 +197,36 @@ object CampaignUtil {
*/
fun findGroupsFeaturePartOf(
settings: Settings,
- featureKey: String
- ): List> {
- val campaignIds: MutableList = ArrayList()
- // Loop over all rules inside the feature where the feature key matches and collect all campaign IDs
- for (feature in settings.features!!) {
- if (feature.key == featureKey) {
- feature.rules!!.forEach(Consumer { rule: Rule ->
- if (!campaignIds.contains(rule.campaignId)) {
- campaignIds.add(rule.campaignId!!)
+ featureKey: String?
+ ): MutableList> {
+ // Initialize an array to store all rules for the given feature to fetch campaignId and variationId later
+ val ruleArrayList: MutableList = ArrayList()
+ for (feature in settings.features) {
+ if (feature.key.equals(featureKey)) {
+ feature.rules?.forEach { rule ->
+ // Add rule to the array if it's not already present
+ if (!ruleArrayList.contains(rule)) {
+ ruleArrayList.add(rule)
}
- })
+ }
}
}
- // Loop over all campaigns and find the group for each campaign
- val groups: MutableList> = ArrayList()
- for (campaignId in campaignIds) {
- val group = getGroupDetailsIfCampaignPartOfIt(settings, campaignId)
- if (!group.isEmpty() && groups.stream()
- .noneMatch { g: Map -> g["groupId"] == group["groupId"] }
- ) {
+ // Initialize an array to store all groups associated with the feature
+ val groups: MutableList> = ArrayList()
+ // Iterate over each rule to find the group details
+ for (rule in ruleArrayList) {
+ val variationId = if (rule.type == CampaignTypeEnum.PERSONALIZE.value)
+ rule.variationId?:-1
+ else
+ -1
+ val group: MutableMap = getGroupDetailsIfCampaignPartOfIt(
+ settings,
+ rule.campaignId!!,
+ variationId
+ )
+ // Add group to the array if it's not already present
+ if (group.isNotEmpty() && groups.none { it["groupId"] == group["groupId"] }) {
groups.add(group)
}
}
@@ -221,7 +239,7 @@ object CampaignUtil {
* @param groupId The ID of the group.
* @return An array of campaigns associated with the specified group ID.
*/
- fun getCampaignsByGroupId(settings: Settings, groupId: Int): List {
+ fun getCampaignsByGroupId(settings: Settings, groupId: Int): List {
// find the group
val group = settings.groups?.get(groupId.toString())
return group?.campaigns?: emptyList()
@@ -230,16 +248,39 @@ object CampaignUtil {
/**
* Retrieves feature keys from a list of campaign IDs.
* @param settings The settings model containing all features.
- * @param campaignIds An array of campaign IDs.
+ * @param campaignIdWithVariation An array of campaign IDs.
* @return An array of feature keys associated with the provided campaign IDs.
*/
- fun getFeatureKeysFromCampaignIds(settings: Settings, campaignIds: List): List {
+ fun getFeatureKeysFromCampaignIds(
+ settings: Settings,
+ campaignIdWithVariation: List
+ ): MutableList {
val featureKeys: MutableList = ArrayList()
- for (campaignId in campaignIds) {
+ for (campaign in campaignIdWithVariation) {
+ // split key with _ to separate campaignId and variationId
+ val campaignIdVariationId = campaign.split("_".toRegex()).dropLastWhile { it.isEmpty() }
+ .toTypedArray()
+ val campaignId = campaignIdVariationId[0].toInt()
+ val variationId =
+ if ((campaignIdVariationId.size > 1)) campaignIdVariationId[1].toInt() else null
+ // Iterate over each feature to find the feature key
for (feature in settings.features) {
- feature.rules?.forEach { rule: Rule ->
+ // Break if feature key is already added
+ if (featureKeys.contains(feature.key)) {
+ continue
+ }
+ feature.rules?.forEach { rule ->
if (rule.campaignId == campaignId) {
- feature.key?.let { featureKeys.add(it) }
+ // Check if variationId is provided and matches the rule's variationId
+ if (variationId != null) {
+ // Add feature key if variationId matches
+ if (rule.variationId== variationId) {
+ feature.key?.let { featureKeys.add(it) }
+ }
+ } else {
+ // Add feature key if no variationId is provided
+ feature.key?.let { featureKeys.add(it) }
+ }
}
}
}
@@ -255,9 +296,9 @@ object CampaignUtil {
*/
fun getCampaignIdsFromFeatureKey(settings: Settings, featureKey: String?): List {
val campaignIds: MutableList = ArrayList()
- for (feature in settings.features!!) {
+ for (feature in settings.features) {
if (feature.key == featureKey) {
- feature.rules!!.forEach(Consumer { rule: Rule -> campaignIds.add(rule.campaignId) })
+ feature.rules?.forEach { rule: Rule -> campaignIds.add(rule.campaignId) }
}
}
return campaignIds
diff --git a/fme-android/src/main/java/com/vwo/utils/DataTypeUtil.kt b/fme-android/src/main/java/com/vwo/utils/DataTypeUtil.kt
index bb9ce47..9afcd45 100644
--- a/fme-android/src/main/java/com/vwo/utils/DataTypeUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/DataTypeUtil.kt
@@ -16,6 +16,7 @@
package com.vwo.utils
import com.vwo.utils.NetworkUtil.Companion
+import org.json.JSONObject
import java.util.Date
import java.util.function.Function
@@ -219,3 +220,14 @@ object DataTypeUtil {
return cleanedMap
}
}
+
+fun JSONObject.toMap(): MutableMap {
+ val map = mutableMapOf()
+ val keys = this.keys()
+ while (keys.hasNext()) {
+ val key = keys.next()
+ val value = this.get(key)
+ map[key] = value
+ }
+ return map
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/utils/DecisionUtil.kt b/fme-android/src/main/java/com/vwo/utils/DecisionUtil.kt
index 4677eb9..1e03343 100644
--- a/fme-android/src/main/java/com/vwo/utils/DecisionUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/DecisionUtil.kt
@@ -15,6 +15,9 @@
*/
package com.vwo.utils
+import com.vwo.VWOClient
+import com.vwo.constants.Constants
+import com.vwo.decorators.StorageDecorator
import com.vwo.enums.CampaignTypeEnum
import com.vwo.enums.StatusEnum
import com.vwo.models.Campaign
@@ -28,6 +31,11 @@ import com.vwo.packages.segmentation_evaluator.core.SegmentationManager
import com.vwo.services.CampaignDecisionService
import com.vwo.services.LoggerService.Companion.log
import com.vwo.services.StorageService
+import com.vwo.utils.CampaignUtil.getGroupDetailsIfCampaignPartOfIt
+import com.vwo.utils.MegUtil.evaluateGroups
+import com.vwo.utils.UUIDUtils.getUUID
+import com.vwo.models.Storage
+
/**
* Utility object for decision-making operations.
@@ -53,67 +61,182 @@ object DecisionUtil {
campaign: Campaign,
context: VWOContext,
evaluatedFeatureMap: MutableMap,
- megGroupWinnerCampaigns: MutableMap?,
- storageService: StorageService,
+ megGroupWinnerCampaigns: MutableMap?,
+ storageService: StorageService?,
decision: MutableMap
- ): Map {
- val vwoUserId = UUIDUtils.getUUID(context.id, settings.accountId.toString())
- val campaignId = campaign.id
+ ): MutableMap {
+ val vwoUserId = getUUID(context.id, settings.accountId.toString())
+ val campaignId = campaign.id!!
// If the campaign is of type AB, set the _vwoUserId for variation targeting variables
if (campaign.type == CampaignTypeEnum.AB.value) {
// set _vwoUserId for variation targeting variables
- val id = if (campaign.isUserListEnabled == true) vwoUserId else context.id
- id?.let { context.variationTargetingVariables.put("_vwoUserId", it) }
+ context.variationTargetingVariables = object : HashMap() {
+ init {
+ putAll(context.variationTargetingVariables)
+ val id = if (campaign.isUserListEnabled == true) vwoUserId else context.id
+ id?.let { put("_vwoUserId", it) }
+ }
+ }
- // for integration
- decision["variationTargetingVariables"] = context.variationTargetingVariables
+ decision["variationTargetingVariables"] =
+ context.variationTargetingVariables // for integration
// check if the campaign satisfies the whitelisting
- if (campaign.isForcedVariationEnabled==true) {
+ if (campaign.isForcedVariationEnabled == true) {
val whitelistedVariation = checkCampaignWhitelisting(campaign, context)
if (whitelistedVariation != null) {
- val variation = whitelistedVariation["variation"]?:""
- return mapOf(
- "preSegmentationResult" to true,
- "whitelistedObject" to variation
- )
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", whitelistedVariation["variation"])
+ }
+ }
}
} else {
- log(LogLevelEnum.INFO, "WHITELISTING_SKIP", mapOf(
- "userId" to context.id,
- "campaignKey" to campaign.ruleKey,
- ))
+ log(LogLevelEnum.INFO, "WHITELISTING_SKIP", object : HashMap() {
+ init {
+ put("userId", context.id)
+ put("campaignKey", campaign.ruleKey)
+ }
+ })
}
}
// set _vwoUserId for custom variables
- val userId=if (campaign.isUserListEnabled == true) vwoUserId else context.id
- context.customVariables["_vwoUserId"] = userId?:""
+ context.customVariables = object : HashMap() {
+ init {
+ putAll(context.customVariables)
+ val id = if (campaign.isUserListEnabled == true) vwoUserId else context.id
+ id?.let { put("_vwoUserId", it) }
+ }
+ }
decision["customVariables"] = context.customVariables // for integration
// Check if RUle being evaluated is part of Mutually Exclusive Group
- val groupId = CampaignUtil.getGroupDetailsIfCampaignPartOfIt(settings, campaignId?:0)["groupId"]
- if (!groupId.isNullOrEmpty()) {
- val groupWinnerCampaignId = megGroupWinnerCampaigns!![groupId.toInt()]
- if (groupWinnerCampaignId != null && groupWinnerCampaignId.toString().isNotEmpty()
- && groupWinnerCampaignId == campaignId) {
- // If the campaign is the winner of the MEG, return true
- return object : HashMap() {
- init {
- put("preSegmentationResult", true)
- remove("whitelistedObject")
+ val id = if (campaign.type == CampaignTypeEnum.PERSONALIZE.value) campaign.variations?.get(0)?.id?:-1 else -1
+ val groupId = getGroupDetailsIfCampaignPartOfIt(
+ settings,
+ campaign.id!!,
+ id
+ )["groupId"]
+ if (groupId != null && !groupId.isEmpty()) {
+ // check if the group is already evaluated for the user
+ val groupWinnerCampaignId = megGroupWinnerCampaigns?.get(groupId.toInt())
+ if (groupWinnerCampaignId != null && !groupWinnerCampaignId.isEmpty()) {
+ if (campaign.type == CampaignTypeEnum.AB.value) {
+ if (groupWinnerCampaignId == campaignId.toString()) {
+ // If the campaign is the winner of the MEG, return true
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
+ }
+ } else if (campaign.type == CampaignTypeEnum.PERSONALIZE.value) {
+ // if personalise then check if the reqeusted variation is the winner
+ if (groupWinnerCampaignId == campaign.id.toString() + "_" + campaign.variations!![0].id) {
+ // If the campaign is the winner of the MEG, return true
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
}
}
- } else if (groupWinnerCampaignId != null && groupWinnerCampaignId.toString().isNotEmpty()) {
// If the campaign is not the winner of the MEG, return false
- return object : HashMap() {
+ return object : HashMap() {
init {
put("preSegmentationResult", false)
- remove("whitelistedObject")
+ put("whitelistedObject", null)
+ }
+ }
+ } else {
+ // check in storage if the group is already evaluated for the user
+ val storedDataMap = StorageDecorator().getFeatureFromStorage(
+ Constants.VWO_META_MEG_KEY + groupId, context,
+ storageService!!
+ )
+ try {
+ val storageMapAsString =
+ VWOClient.objectMapper.writeValueAsString(storedDataMap)
+ val storedData: Storage? = VWOClient.objectMapper.readValue(
+ storageMapAsString,
+ Storage::class.java
+ )
+ if (storedData != null && storedData.experimentId != null && storedData.experimentKey != null) {
+ log(
+ LogLevelEnum.INFO,
+ "MEG_CAMPAIGN_FOUND_IN_STORAGE",
+ object : HashMap() {
+ init {
+ put("campaignKey", storedData.experimentKey)
+ put("userId", context.id)
+ }
+ })
+ if (storedData.experimentId === campaignId) {
+ if (campaign.type == CampaignTypeEnum.PERSONALIZE.value) {
+ // if personalise then check if the reqeusted variation is the winner
+ if (storedData.experimentVariationId==campaign.variations!![0].id) {
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
+ } else {
+ // store the campaign in local cache, so that it can be used later without looking into user storage again
+ megGroupWinnerCampaigns?.set(groupId.toInt(),
+ "${storedData.experimentId}_${storedData.experimentVariationId}"
+ )
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", false)
+ put("whitelistedObject", null)
+ }
+ }
+ }
+ } else {
+ // return the campaign if the called campaignId matches
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
+ }
+ }
+ // if experimentId is not -1 then campaign is personalise campaign, store the details and return
+ if (storedData.experimentVariationId !== -1) {
+ megGroupWinnerCampaigns?.set(groupId.toInt(),
+ "${storedData.experimentId}_${storedData.experimentVariationId}"
+ )
+ } else {
+ // else store the campaignId only and return
+ megGroupWinnerCampaigns?.set(groupId.toInt(),
+ java.lang.String.valueOf(storedData.experimentId)
+ )
+ }
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", false)
+ put("whitelistedObject", null)
+ }
+ }
}
+ } catch (e: Exception) {
+ log(
+ LogLevelEnum.ERROR,
+ "STORED_DATA_ERROR",
+ object : HashMap() {
+ init {
+ put("err", e.toString())
+ }
+ })
}
}
}
@@ -122,35 +245,78 @@ object DecisionUtil {
val isPreSegmentationPassed =
CampaignDecisionService().getPreSegmentationDecision(campaign, context)
- if (isPreSegmentationPassed && !groupId.isNullOrEmpty()) {
- val variationModel = MegUtil.evaluateGroups(
+ if (isPreSegmentationPassed && groupId != null && groupId.isNotEmpty()) {
+ val variationModel = evaluateGroups(
settings,
feature,
groupId.toInt(),
evaluatedFeatureMap,
context,
- storageService
+ storageService!!
)
+ // this condition would be true only when the current campaignId match with group winner campaignId
+ // for personalise campaign, all personalise variations have same campaignId, so we check for campaignId_variationId
if (variationModel?.id != null && variationModel.id == campaignId) {
- return object : HashMap() {
+ // if campaign is AB then return true
+ if (variationModel.type== CampaignTypeEnum.AB.value) {
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
+ } else {
+ // if personalise then check if the requested variation is the winner
+ if (variationModel.variations[0].id == campaign.variations!![0].id) {
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", true)
+ put("whitelistedObject", null)
+ }
+ }
+ } else {
+ // store the campaign in local cache, so that it can be used later
+ megGroupWinnerCampaigns?.set(groupId.toInt(),
+ variationModel.id.toString() + "_" + variationModel.variations[0].id
+ )
+ return object : HashMap() {
+ init {
+ put("preSegmentationResult", false)
+ put("whitelistedObject", null)
+ }
+ }
+ }
+ }
+ } else if (variationModel?.id != null) { // when there is a winner but not the current campaign
+ if (variationModel.type==CampaignTypeEnum.AB.value) {
+ // if campaign is AB then store only the campaignId
+ megGroupWinnerCampaigns?.set(groupId.toInt(), variationModel.id.toString())
+ } else {
+ // if campaign is personalise then store the campaignId_variationId
+ megGroupWinnerCampaigns?.set(groupId.toInt(),
+ variationModel.id.toString() + "_" + variationModel.variations[0].id
+ )
+ }
+ return object : HashMap() {
init {
- put("preSegmentationResult", true)
- remove("whitelistedObject")
+ put("preSegmentationResult", false)
+ put("whitelistedObject", null)
}
}
}
- megGroupWinnerCampaigns!![groupId.toInt()] = variationModel?.id?:0
- return object : HashMap() {
+ // store -1 if no winner found, so that we don't evaluate the group again as the result would be the same for the current getFlag call
+ megGroupWinnerCampaigns?.set(groupId.toInt(), "-1")
+ return object : HashMap() {
init {
put("preSegmentationResult", false)
- remove("whitelistedObject")
+ put("whitelistedObject", null)
}
}
}
- return object : HashMap() {
+ return object : HashMap() {
init {
put("preSegmentationResult", isPreSegmentationPassed)
- remove("whitelistedObject")
+ put("whitelistedObject", null)
}
}
}
@@ -181,7 +347,13 @@ object DecisionUtil {
object : HashMap() {
init {
put("userId", userId)
- put("campaignKey", campaign.ruleKey)
+ put(
+ "campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
put("status", "did not get any variation")
}
})
@@ -215,7 +387,13 @@ object DecisionUtil {
log(LogLevelEnum.INFO, "WHITELISTING_STATUS", object : HashMap() {
init {
put("userId", context.id)
- put("campaignKey", campaign.ruleKey)
+ put(
+ "campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
put("status", status.status)
put("variationString", variationString)
}
@@ -237,10 +415,16 @@ object DecisionUtil {
log(LogLevelEnum.INFO, "WHITELISTING_SKIP", object : HashMap() {
init {
put("userId", context.id)
- put("campaignKey", campaign.ruleKey)
+ put(
+ "campaignKey",
+ if (campaign.type.equals(CampaignTypeEnum.AB.value))
+ campaign.key
+ else
+ campaign.name + "_" + campaign.ruleKey
+ )
put(
"variation",
- if (variation.name?.isNotEmpty()==true) "for variation: " + variation.name else ""
+ if (variation.name?.isNotEmpty() == true) "for variation: " + variation.name else ""
)
}
})
diff --git a/fme-android/src/main/java/com/vwo/utils/EventsUtils.kt b/fme-android/src/main/java/com/vwo/utils/EventsUtils.kt
new file mode 100644
index 0000000..d73a0ce
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/utils/EventsUtils.kt
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.utils
+
+import com.vwo.enums.UrlEnum
+import com.vwo.models.user.VWOContext
+import com.vwo.packages.network_layer.manager.NetworkManager
+import com.vwo.packages.network_layer.models.RequestModel
+import com.vwo.services.SettingsManager.Companion.instance
+import com.vwo.services.UrlService.baseUrl
+
+/**
+ * Utility class for handling events related operations, such as pre-segmentation.
+ *
+ * This class provides methods for evaluating DSLs against user context to determine if events
+ * should be tracked before segmentation. It also includes helper functions for validating
+ * event data and other related tasks.
+ */
+class EventsUtils {
+
+ /**
+ * Evaluates the given DSL against the provided context to determine if the event
+ * should be tracked before segmentation.
+ *
+ * This function sends a POST request to the VWO server with the DSL and context
+ * information. It returns `true` if the server responds with a status code of 200
+ * and the response data contains "true" (case-insensitive), indicating that the
+ * event should be tracked. Otherwise, it returns `false`.
+ *
+ * @param dsl The DSL to evaluate.
+ * @param context The VWO context containing user information.
+ * @return `true` if the event should be tracked before segmentation, `false` otherwise.
+ */
+ fun getEventsPreSegmentation(dsl: Any, context: VWOContext): Boolean {
+ var result = false
+ val queryParams: MutableMap = HashMap()
+ val accountId = instance?.accountId.toString()
+ queryParams["uuid"] = UUIDUtils.getUUID(context.id, accountId)
+ queryParams["accountId"] = accountId
+
+ val body: MutableMap = LinkedHashMap()
+ body["dsl"] = dsl
+ val contextBody = mutableMapOf()
+ contextBody["id"] = context.id ?: ""
+ contextBody["customVariables"] = context.customVariables
+ contextBody["ipAddress"] = context.ipAddress
+ contextBody["userAgent"] = context.userAgent
+ contextBody["variationTargetingVariables"] = context.variationTargetingVariables
+ body["context"] = contextBody
+
+ NetworkManager.attachClient()
+ val request = RequestModel(
+ baseUrl,
+ "POST",
+ UrlEnum.EVALUATE_DSL.url,
+ queryParams,
+ body,
+ HashMap(),
+ instance?.protocol,
+ instance?.port ?: 0
+ )
+ val responseModel = NetworkManager.post(request)
+ if (responseModel?.statusCode == 200) {
+ if (responseModel.data?.contains("true", ignoreCase = true) == true) {
+ result = true
+ }
+ }
+ return result
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/main/java/com/vwo/utils/GatewayServiceUtil.kt b/fme-android/src/main/java/com/vwo/utils/GatewayServiceUtil.kt
index 2175949..67b4e9e 100644
--- a/fme-android/src/main/java/com/vwo/utils/GatewayServiceUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/GatewayServiceUtil.kt
@@ -45,6 +45,7 @@ object GatewayServiceUtil {
log(LogLevelEnum.ERROR, "GATEWAY_URL_ERROR", null)
return null
}
+ var responseString: String? = null
try {
val request = RequestModel(
baseUrl,
@@ -58,10 +59,11 @@ object GatewayServiceUtil {
)
val response = NetworkManager.get(request)
- return response?.data
+ responseString = response?.data
} catch (e: Exception) {
- return null
+ responseString = null
}
+ return responseString
}
/**
diff --git a/fme-android/src/main/java/com/vwo/utils/ImpressionUtil.kt b/fme-android/src/main/java/com/vwo/utils/ImpressionUtil.kt
index d849e58..7c5b759 100644
--- a/fme-android/src/main/java/com/vwo/utils/ImpressionUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/ImpressionUtil.kt
@@ -55,6 +55,7 @@ object ImpressionUtil {
// Construct payload data for tracking the user
val payload: Map = NetworkUtil.getTrackUserPayloadData(
settings,
+ context,
context.id,
EventEnum.VWO_VARIATION_SHOWN.value,
campaignId,
diff --git a/fme-android/src/main/java/com/vwo/utils/MegUtil.kt b/fme-android/src/main/java/com/vwo/utils/MegUtil.kt
index 07bb472..a521916 100644
--- a/fme-android/src/main/java/com/vwo/utils/MegUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/MegUtil.kt
@@ -29,13 +29,14 @@ import com.vwo.models.user.VWOContext
import com.vwo.packages.decision_maker.DecisionMaker
import com.vwo.packages.logger.enums.LogLevelEnum
import com.vwo.services.CampaignDecisionService
-import com.vwo.services.LoggerService
+import com.vwo.services.LoggerService.Companion.log
import com.vwo.services.StorageService
-import java.util.function.Consumer
-import java.util.function.Function
-import java.util.function.Predicate
+import com.vwo.utils.CampaignUtil.getBucketingSeed
+import com.vwo.utils.CampaignUtil.setCampaignAllocation
+import com.vwo.utils.FunctionUtil.cloneObject
import java.util.stream.Collectors
+
/**
* Utility object for MEG-related operations.
*
@@ -61,17 +62,15 @@ object MegUtil {
storageService: StorageService
): Variation? {
val featureToSkip: MutableList = ArrayList()
- val campaignMap: MutableMap> =
- HashMap>()
+ val campaignMap: MutableMap> = HashMap()
// get all feature keys and all campaignIds from the groupId
val featureKeysAndGroupCampaignIds = getFeatureKeysFromGroup(settings, groupId)
val featureKeys = featureKeysAndGroupCampaignIds["featureKeys"] as List?
- val groupCampaignIds = featureKeysAndGroupCampaignIds["groupCampaignIds"] as List?
+ val groupCampaignIds:List? = featureKeysAndGroupCampaignIds["groupCampaignIds"] as List?
for (featureKey in featureKeys!!) {
val currentFeature = FunctionUtil.getFeatureFromKey(settings, featureKey)
- val featureCampaignIds = CampaignUtil.getCampaignIdsFromFeatureKey(settings, featureKey)
// check if the feature is already evaluated
if (currentFeature == null || featureToSkip.contains(featureKey)) {
@@ -88,18 +87,19 @@ object MegUtil {
storageService
)
if (isRolloutRulePassed) {
- for (campaign in settings.campaigns!!) {
- if (groupCampaignIds!!.contains(campaign.id)
- && featureCampaignIds.contains(campaign.id)
- ) {
- // Ensuring the list for a featureKey exists in the map
- val campaigns: MutableList =
- campaignMap.getOrPut(featureKey) { mutableListOf() }
-
- // Checking if the campaign with a specific key does not already exist in
- // the list and adding it if not
- if (campaigns.none { it.key == campaign.key }) {
- campaigns.add(campaign)
+ for (feature1 in settings.features) {
+ if (feature1.key == featureKey) {
+ for (campaign in feature1.rulesLinkedCampaign) {
+ if (groupCampaignIds!!.contains(campaign.id.toString())
+ || groupCampaignIds.contains(campaign.id.toString()
+ + "_" + campaign.variations!![0].id)) {
+
+ campaignMap.getOrPut(featureKey) { mutableListOf() }
+ val campaigns = campaignMap[featureKey]
+ if (campaigns!!.none { it.ruleKey == campaign.ruleKey }) {
+ campaigns.add(campaign)
+ }
+ }
}
}
}
@@ -119,7 +119,8 @@ object MegUtil {
eligibleCampaigns,
eligibleCampaignsWithStorage,
groupId,
- context
+ context,
+ storageService
)
}
@@ -208,7 +209,7 @@ object MegUtil {
}
// no rollout rule, evaluate experiments
- LoggerService.log(LogLevelEnum.INFO, "MEG_SKIP_ROLLOUT_EVALUATE_EXPERIMENTS",
+ log(LogLevelEnum.INFO, "MEG_SKIP_ROLLOUT_EVALUATE_EXPERIMENTS",
object : HashMap() {
init {
put("featureKey", featureKey)
@@ -240,11 +241,10 @@ object MegUtil {
try {
val storageMapAsString: String =
VWOClient.objectMapper.writeValueAsString(storedDataMap)
- val storedData: Storage =
- VWOClient.objectMapper.readValue(storageMapAsString, Storage::class.java)
- if (storedData.experimentVariationId != null && storedData.experimentVariationId.toString()
- .isNotEmpty()
- ) {
+ val storedData: Storage? = VWOClient.objectMapper.readValue(storageMapAsString, Storage::class.java)
+ if (storedData?.experimentVariationId != null
+ && storedData.experimentVariationId.toString().isNotEmpty()) {
+
if (!storedData.experimentKey.isNullOrEmpty() && storedData.experimentKey == campaign.key) {
val variation: Variation? = CampaignUtil.getVariationFromCampaignKey(
settings,
@@ -252,7 +252,7 @@ object MegUtil {
storedData.experimentVariationId!!
)
if (variation != null) {
- LoggerService.log(
+ log(
LogLevelEnum.INFO,
"MEG_CAMPAIGN_FOUND_IN_STORAGE",
object : HashMap() {
@@ -275,12 +275,15 @@ object MegUtil {
if (CampaignDecisionService().getPreSegmentationDecision(campaign, context) &&
CampaignDecisionService().isUserPartOfCampaign(context.id, campaign)
) {
- LoggerService.log(
+ log(
LogLevelEnum.INFO,
"MEG_CAMPAIGN_ELIGIBLE",
object : HashMap() {
init {
- put("campaignKey", campaign.key)
+ put(
+ "campaignKey",
+ if (campaign.type == CampaignTypeEnum.AB.value) campaign.key else campaign.name + "_" + campaign.ruleKey
+ )
put("userId", context.id)
}
})
@@ -309,13 +312,14 @@ object MegUtil {
* @param eligibleCampaignsWithStorage - A list of eligible campaigns with storage.
* @param groupId - The ID of the group.
* @param context - The context model.
+ * @param storageService - The storage service.
* @return The winner campaign.
*/
private fun findWinnerCampaignAmongEligibleCampaigns(
settings: Settings, featureKey: String?,
eligibleCampaigns: List?,
eligibleCampaignsWithStorage: List?,
- groupId: Int, context: VWOContext
+ groupId: Int, context: VWOContext, storageService: StorageService
): Variation? {
val campaignIds = CampaignUtil.getCampaignIdsFromFeatureKey(settings, featureKey)
var winnerCampaign: Variation? = null
@@ -335,11 +339,14 @@ object MegUtil {
}
val finalWinnerCampaign: Variation? = winnerCampaign
val map = mutableMapOf().apply {
- finalWinnerCampaign?.key?.let { put("campaignKey", it) }
+ put(
+ "campaignKey",
+ (if (finalWinnerCampaign?.type.equals(CampaignTypeEnum.AB.value)) finalWinnerCampaign!!.key else finalWinnerCampaign!!.name + "_" + finalWinnerCampaign.ruleKey)!!
+ )
put("groupId", groupId.toString())
context.id?.let { put("userId", it) }
}
- LoggerService.log(
+ log(
LogLevelEnum.INFO,
"MEG_WINNER_CAMPAIGN",
map as Map
@@ -349,7 +356,8 @@ object MegUtil {
eligibleCampaignsWithStorage,
context,
campaignIds,
- groupId
+ groupId,
+ storageService
)
} else if (eligibleCampaignsWithStorage.size > 1) {
winnerCampaign = getCampaignUsingAdvancedAlgo(
@@ -357,7 +365,8 @@ object MegUtil {
eligibleCampaignsWithStorage,
context,
campaignIds,
- groupId
+ groupId,
+ storageService
)
}
@@ -372,13 +381,18 @@ object MegUtil {
} catch (e: JsonProcessingException) {
throw RuntimeException(e)
}
- val finalWinnerCampaign1: Variation? = winnerCampaign
- LoggerService.log(
+ val finalWinnerCampaign1: Variation = winnerCampaign
+ log(
LogLevelEnum.INFO,
"MEG_WINNER_CAMPAIGN",
object : HashMap() {
init {
- put("campaignKey", finalWinnerCampaign1?.key)
+ put("campaignKey",
+ if (finalWinnerCampaign1.type.equals(CampaignTypeEnum.AB.value))
+ finalWinnerCampaign1.key
+ else
+ finalWinnerCampaign1.name + "_" + finalWinnerCampaign1.ruleKey
+ )
put("groupId", groupId.toString())
put("userId", context.id)
put("algo", "")
@@ -389,7 +403,8 @@ object MegUtil {
eligibleCampaigns,
context,
campaignIds,
- groupId
+ groupId,
+ storageService
)
} else if (eligibleCampaigns.size > 1) {
winnerCampaign = getCampaignUsingAdvancedAlgo(
@@ -397,15 +412,14 @@ object MegUtil {
eligibleCampaigns,
context,
campaignIds,
- groupId
+ groupId,
+ storageService
)
}
}
} catch (exception: Exception) {
- LoggerService.log(
- LogLevelEnum.ERROR,
- "MEG: error inside findWinnerCampaignAmongEligibleCampaigns$exception"
- )
+ log(LogLevelEnum.ERROR,
+ "MEG: error inside findWinnerCampaignAmongEligibleCampaigns$exception")
}
return winnerCampaign
}
@@ -421,11 +435,11 @@ object MegUtil {
*/
private fun normalizeWeightsAndFindWinningCampaign(
shortlistedCampaigns: List?,
- context: VWOContext, calledCampaignIds: List?, groupId: Int
+ context: VWOContext, calledCampaignIds: List?, groupId: Int, storageService:StorageService
): Variation? {
try {
- shortlistedCampaigns?.forEach { campaign: Campaign ->
- campaign.weight = 100.0 / shortlistedCampaigns.size
+ shortlistedCampaigns?.forEach{ campaign: Campaign ->
+ campaign.weight = Math.round(100.0 / shortlistedCampaigns.size) * 10000 / 10000.0
}
val variations: List = shortlistedCampaigns?.mapNotNull { campaign ->
@@ -446,23 +460,35 @@ object MegUtil {
)
)
- LoggerService.log(
+ if (winnerVariation != null) {
+ log(
LogLevelEnum.INFO,
"MEG_WINNER_CAMPAIGN",
object : HashMap() {
init {
- put("campaignKey", winnerVariation?.key)
+ put("campaignKey", if(winnerVariation.type==CampaignTypeEnum.AB.value) winnerVariation.key else winnerVariation.name + "_" + winnerVariation.ruleKey)
put("groupId", groupId.toString())
put("userId", context.id)
put("algo", "using random algorithm")
}
})
- if (winnerVariation != null && calledCampaignIds?.contains(winnerVariation.id) == true) {
- return winnerVariation
+ val storageMap: MutableMap = java.util.HashMap()
+ storageMap["featureKey"] = Constants.VWO_META_MEG_KEY + groupId
+ storageMap["userId"] = context.id?:0
+ storageMap["experimentId"] = winnerVariation.id?:0
+ storageMap["experimentKey"] = winnerVariation.key?:""
+ storageMap["experimentVariationId"] = if (winnerVariation.type.equals(CampaignTypeEnum.PERSONALIZE.value)) winnerVariation.variations[0].id?:-1 else -1
+ StorageDecorator().setDataInStorage(storageMap, storageService)
+
+ if (calledCampaignIds!!.contains(winnerVariation.id)) {
+ return winnerVariation
+ }
+ } else {
+ log(LogLevelEnum.INFO, "No winner campaign found for MEG group: $groupId")
}
} catch (exception: Exception) {
- LoggerService.log(
+ log(
LogLevelEnum.ERROR,
"MEG: error inside normalizeWeightsAndFindWinningCampaign"
)
@@ -478,27 +504,45 @@ object MegUtil {
* @param context - The context model.
* @param calledCampaignIds - A list of campaign IDs that have been called.
* @param groupId - The ID of the group.
+ * @param storageService - The storage service.
* @return The winning campaign or null if none is found.
*/
private fun getCampaignUsingAdvancedAlgo(
- settings: Settings, shortlistedCampaigns: List,
- context: VWOContext, calledCampaignIds: List?, groupId: Int
+ settings: Settings,
+ shortlistedCampaigns: List,
+ context: VWOContext,
+ calledCampaignIds: List,
+ groupId: Int,
+ storageService: StorageService
): Variation? {
var winnerCampaign: Variation? = null
var found = false
try {
val group = settings.groups!![groupId.toString()]
- val priorityOrder = group?.p ?: mutableListOf()
- val groupWt = group?.wt
- val wt = if (!groupWt.isNullOrEmpty()) convertWtToMap(groupWt) else mutableMapOf()
- for (integer in priorityOrder) {
+ val priorityOrder: List? = if (group != null && !group.p!!.isEmpty()
+ ) group.p else java.util.ArrayList()
+ val wt = if (group != null && !group.wt!!.isEmpty()
+ ) group.wt else java.util.HashMap()
+ for (integer in priorityOrder!!) {
for (shortlistedCampaign in shortlistedCampaigns) {
- if (shortlistedCampaign.id == integer) {
- val campaignModel: String = VWOClient.objectMapper.writeValueAsString(
- FunctionUtil.cloneObject(shortlistedCampaign)
+ if (shortlistedCampaign.id.toString() == integer) {
+ val campaignModel = VWOClient.objectMapper.writeValueAsString(
+ cloneObject(shortlistedCampaign)
+ )
+ winnerCampaign = VWOClient.objectMapper.readValue(
+ campaignModel,
+ Variation::class.java
+ )
+ found = true
+ break
+ } else if ((shortlistedCampaign.id.toString() + "_" + shortlistedCampaign.variations!![0].id) == integer) {
+ val campaignModel = VWOClient.objectMapper.writeValueAsString(
+ cloneObject(shortlistedCampaign)
+ )
+ winnerCampaign = VWOClient.objectMapper.readValue(
+ campaignModel,
+ Variation::class.java
)
- winnerCampaign =
- VWOClient.objectMapper.readValue(campaignModel, Variation::class.java)
found = true
break
}
@@ -507,33 +551,38 @@ object MegUtil {
}
if (winnerCampaign == null) {
- val participatingCampaignList: MutableList = ArrayList()
+ val participatingCampaignList: MutableList = java.util.ArrayList()
for (campaign in shortlistedCampaigns) {
- val campaignId = campaign.id
- if (campaignId!=null && wt.containsKey(campaignId)) {
- val clonedCampaign: Campaign =
- FunctionUtil.cloneObject(campaign) as Campaign
- clonedCampaign.weight = (wt[campaignId]?:0).toDouble()
+ val campaignId = campaign.id!!
+ if (wt!!.containsKey(campaignId.toString())) {
+ val clonedCampaign = cloneObject(campaign) as Campaign?
+ clonedCampaign!!.weight = wt!![campaignId.toString()]!!
+ participatingCampaignList.add(clonedCampaign)
+ } else if (wt!!.containsKey(campaignId.toString() + "_" + campaign.variations!![0].id)) {
+ val clonedCampaign = cloneObject(campaign) as Campaign?
+ clonedCampaign!!.weight =
+ wt!![campaignId.toString() + "_" + campaign.variations!![0].id]!!
participatingCampaignList.add(clonedCampaign)
}
}
- val variations: List = participatingCampaignList.mapNotNull { campaign ->
- try {
- val campaignModel = VWOClient.objectMapper.writeValueAsString(campaign)
- VWOClient.objectMapper.readValue(campaignModel, Variation::class.java)
- } catch (e: JsonProcessingException) {
- LoggerService.log(LogLevelEnum.ERROR,e.toString())
- null // Optionally log the error or handle it as needed
+ val variations = participatingCampaignList.map { campaign: Campaign? ->
+ try {
+ val campaignModel = VWOClient.objectMapper.writeValueAsString(campaign)
+ return@map VWOClient.objectMapper.readValue(
+ campaignModel,
+ Variation::class.java
+ )
+ } catch (e: JsonProcessingException) {
+ throw java.lang.RuntimeException(e)
+ }
}
- }
-
- CampaignUtil.setCampaignAllocation(variations)
+ setCampaignAllocation(variations)
winnerCampaign = CampaignDecisionService().getVariation(
variations,
DecisionMaker().calculateBucketValue(
- CampaignUtil.getBucketingSeed(
+ getBucketingSeed(
context.id,
null,
groupId
@@ -542,24 +591,45 @@ object MegUtil {
)
}
- val finalWinnerCampaign: Variation? = winnerCampaign
- LoggerService.log(
- LogLevelEnum.INFO,
- "MEG_WINNER_CAMPAIGN",
- object : HashMap() {
- init {
- put("campaignKey", finalWinnerCampaign?.name)
- put("groupId", groupId.toString())
- put("userId", context.id)
- put("algo", "using advanced algorithm")
- }
- })
+ val finalWinnerCampaign = winnerCampaign
+
- if (calledCampaignIds!!.contains(winnerCampaign?.id)) {
- return winnerCampaign
+ if (winnerCampaign != null) {
+ log(
+ LogLevelEnum.INFO,
+ "MEG_WINNER_CAMPAIGN",
+ object : java.util.HashMap() {
+ init {
+ put(
+ "campaignKey",
+ if (finalWinnerCampaign!!.type == CampaignTypeEnum.AB.value) finalWinnerCampaign!!.key else finalWinnerCampaign!!.name + "_" + finalWinnerCampaign!!.ruleKey
+ )
+ put("groupId", groupId.toString())
+ put("userId", context.id)
+ put("algo", "using advanced algorithm")
+ }
+ })
+
+ val storageMap: MutableMap = java.util.HashMap()
+ storageMap["featureKey"] = Constants.VWO_META_MEG_KEY + groupId
+ storageMap["userId"] = context.id?:0
+ storageMap["experimentId"] = winnerCampaign.id?:0
+ storageMap["experimentKey"] = winnerCampaign.key?:""
+ storageMap["experimentVariationId"] =
+ if (winnerCampaign.type == CampaignTypeEnum.PERSONALIZE.value) winnerCampaign.variations[0].id?:-1 else -1
+ StorageDecorator().setDataInStorage(storageMap, storageService)
+
+ if (calledCampaignIds.contains(winnerCampaign.id)) {
+ return winnerCampaign
+ }
+ } else {
+ log(
+ LogLevelEnum.INFO,
+ "No winner campaign found for MEG group: $groupId"
+ )
}
- } catch (exception: Exception) {
- LoggerService.log(
+ } catch (exception: java.lang.Exception) {
+ log(
LogLevelEnum.ERROR,
"MEG: error inside getCampaignUsingAdvancedAlgo " + exception.message
)
@@ -573,8 +643,9 @@ object MegUtil {
* @param wt - The weight map.
* @return The converted map.
*/
- private fun convertWtToMap(wt: Map): Map {
+ private fun convertWtToMap(wt: Map?): Map {
val wtToReturn: MutableMap = HashMap()
+ if (wt == null) return wtToReturn
for ((key, value) in wt) {
wtToReturn[key.toInt()] = value
}
diff --git a/fme-android/src/main/java/com/vwo/utils/NetworkUtil.kt b/fme-android/src/main/java/com/vwo/utils/NetworkUtil.kt
index ad4461e..cef5503 100644
--- a/fme-android/src/main/java/com/vwo/utils/NetworkUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/NetworkUtil.kt
@@ -93,6 +93,7 @@ class NetworkUtil {
*/
fun getEventBasePayload(
settings: Settings,
+ context: VWOContext,
userId: String?,
eventName: String,
visitorUserAgent: String?,
@@ -100,12 +101,12 @@ class NetworkUtil {
): EventArchPayload {
val uuid = UUIDUtils.getUUID(userId, settings.accountId.toString())
val eventArchData = EventArchData()
- eventArchData.msgId = generateMsgId(uuid)
+ eventArchData.msgId = generateMsgId(uuid, context)
eventArchData.visId = uuid
- eventArchData.sessionId = generateSessionId()
+ eventArchData.sessionId = generateSessionId(context)
setOptionalVisitorData(eventArchData, visitorUserAgent, ipAddress)
- val event = createEvent(eventName, settings)
+ val event = createEvent(eventName, settings, context)
eventArchData.event = event
val visitor = createVisitor(settings)
@@ -142,12 +143,19 @@ class NetworkUtil {
* @param settings The settings model containing configuration.
* @return The event model.
*/
- private fun createEvent(eventName: String, settings: Settings): Event {
+ private fun createEvent(eventName: String, settings: Settings, context: VWOContext): Event {
val event = Event()
val props = createProps(settings)
+ var time = Calendar.getInstance().timeInMillis
+
+ // Commenting this code as it causing same time in all the events.
+// if (context.sessionId != 0L) {
+// time = context.sessionId
+// }
+
event.props = props
event.name = eventName
- event.time = Calendar.getInstance().timeInMillis
+ event.time = time
return event
}
@@ -161,6 +169,7 @@ class NetworkUtil {
props.setSdkName(Constants.SDK_NAME)
props.setSdkVersion(SDKMetaUtil.sdkVersion)
props.setEnvKey(settings.sdkKey)
+ props.setEnvKey(settings.sdkKey)
return props
}
@@ -172,7 +181,7 @@ class NetworkUtil {
private fun createVisitor(settings: Settings): Visitor {
val visitor = Visitor()
val visitorProps: MutableMap = HashMap()
- visitorProps[Constants.VWO_FS_ENVIRONMENT] = settings.sdkKey?:defaultString
+ visitorProps[Constants.VWO_FS_ENVIRONMENT] = settings.sdkKey ?: defaultString
visitor.setProps(visitorProps)
return visitor
}
@@ -190,6 +199,7 @@ class NetworkUtil {
*/
fun getTrackUserPayloadData(
settings: Settings,
+ context: VWOContext,
userId: String?,
eventName: String,
campaignId: Int,
@@ -198,7 +208,14 @@ class NetworkUtil {
ipAddress: String?
): Map {
val properties =
- getEventBasePayload(settings, userId, eventName, visitorUserAgent, ipAddress)
+ getEventBasePayload(
+ settings,
+ context,
+ userId,
+ eventName,
+ visitorUserAgent,
+ ipAddress
+ )
properties.d!!.event!!.props!!.id = campaignId
properties.d!!.event!!.props!!.variation = variationId.toString()
properties.d!!.event!!.props!!.setIsFirst(1)
@@ -235,6 +252,7 @@ class NetworkUtil {
): Map {
val properties = getEventBasePayload(
settings,
+ context,
userId,
eventName,
context.userAgent,
@@ -282,12 +300,13 @@ class NetworkUtil {
*/
fun getAttributePayloadData(
settings: Settings,
+ context: VWOContext,
userId: String?,
eventName: String,
attributeKey: String,
attributeValue: Any
): Map {
- val properties = getEventBasePayload(settings, userId, eventName, null, null)
+ val properties = getEventBasePayload(settings, context, userId, eventName, null, null)
properties.d?.event?.props?.setIsCustomEvent(true)
properties.d?.visitor?.props?.set(attributeKey, attributeValue)
log(
@@ -388,15 +407,25 @@ class NetworkUtil {
* @param uuid The UUID of the user.
* @return The message ID.
*/
- private fun generateMsgId(uuid: String?): String {
- return uuid + "-" + Calendar.getInstance().timeInMillis
+ private fun generateMsgId(uuid: String?, context: VWOContext): String {
+ var time = Calendar.getInstance().timeInMillis
+
+ if (context.sessionId != 0L) {
+ time = context.sessionId
+ }
+
+ return uuid + "-" + time
}
/**
* Generates a session ID for the event.
* @return The session ID.
*/
- private fun generateSessionId(): Long {
+ private fun generateSessionId(context: VWOContext): Long {
+ if (context.sessionId != 0L) {
+ return context.sessionId / 1000
+ }
+
return Calendar.getInstance().timeInMillis / 1000
}
@@ -406,7 +435,10 @@ class NetworkUtil {
* @param ipAddress The IP address of the user.
* @return Map containing the headers.
*/
- private fun createHeaders(userAgent: String?, ipAddress: String?): MutableMap {
+ private fun createHeaders(
+ userAgent: String?,
+ ipAddress: String?
+ ): MutableMap {
val headers: MutableMap = HashMap()
if (!userAgent.isNullOrEmpty())
headers[HeadersEnum.USER_AGENT.header] = userAgent
diff --git a/fme-android/src/main/java/com/vwo/utils/RecommendationUtil.kt b/fme-android/src/main/java/com/vwo/utils/RecommendationUtil.kt
new file mode 100644
index 0000000..500e405
--- /dev/null
+++ b/fme-android/src/main/java/com/vwo/utils/RecommendationUtil.kt
@@ -0,0 +1,102 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.utils
+
+import com.vwo.constants.Constants
+import com.vwo.constants.Constants.AUTH_TOKEN
+import com.vwo.enums.UrlEnum
+import com.vwo.packages.logger.enums.LogLevelEnum
+import com.vwo.packages.network_layer.manager.NetworkManager
+import com.vwo.packages.network_layer.models.RequestModel
+import com.vwo.services.LoggerService.Companion.log
+import com.vwo.services.SettingsManager.Companion.instance
+import org.json.JSONObject
+
+
+object RecommendationUtil {
+
+ var request :RequestModel?=null
+ /**
+ * This method is used to get recommendations based on the options passed.
+ * @param configId The configId for which recommendation is to be fetched
+ * @return The recommendations
+ */
+ fun getRecommendation(
+ configId: Int,
+ userId: String,
+ eventType: String,
+ category: String?,
+ productIds: List?
+ ): JSONObject {
+ try {
+ // set the query parameters
+ val queryParams: MutableMap = HashMap()
+ queryParams["accountId"] = instance?.accountId.toString()
+
+ // create payload for the request
+ val array = ArrayList>()
+ productIds?.forEach {
+ val productMap: MutableMap = HashMap()
+ productMap["id"] = it
+ array.add(productMap)
+ }
+
+ val payload: MutableMap = LinkedHashMap()
+ payload["configId"] = configId.toString()
+ payload["eventType"] = eventType
+ payload["products"] = array
+ payload["visitorId"] = userId
+ if (productIds != null && category != null) {
+ val variables: MutableMap = LinkedHashMap()
+ variables["product_id"] = productIds[0]
+ variables["category"] = category
+ payload["variables"] = variables
+ }
+
+ NetworkManager.attachClient()
+ val header = mutableMapOf("authToken" to AUTH_TOKEN)
+ val request = RequestModel(
+ Constants.VWO_APP_URL,
+ "POST",
+ UrlEnum.GENERATE_RECOMMENDATION.url,
+ queryParams,
+ payload,
+ header,
+ instance?.protocol,
+ 0
+ )
+ val map = mapOf(
+ "accountId" to instance?.accountId.toString(),
+ "userId" to userId
+ )
+ log(LogLevelEnum.DEBUG, "IMPRESSION_FOR_GET_RECOMMENDATION", map)
+ val responseModel = NetworkManager.post(request)
+ val jsonObject = if (responseModel?.statusCode == 200) {
+ JSONObject(responseModel.data?:"{}")
+ } else {
+ val map = mutableMapOf()
+ map["err"]= responseModel?.error.toString()
+ log(LogLevelEnum.ERROR, "RECOMMENDATION_ERROR",map)
+ JSONObject()
+ }
+ return jsonObject
+ } catch (e: Exception) {
+ val map = mapOf("err" to e.message)
+ log(LogLevelEnum.ERROR, "RECOMMENDATION_ERROR", map)
+ return JSONObject()
+ }
+ }
+}
diff --git a/fme-android/src/main/java/com/vwo/utils/RuleEvaluationUtil.kt b/fme-android/src/main/java/com/vwo/utils/RuleEvaluationUtil.kt
index f45fbdf..43b3d03 100644
--- a/fme-android/src/main/java/com/vwo/utils/RuleEvaluationUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/RuleEvaluationUtil.kt
@@ -49,7 +49,7 @@ object RuleEvaluationUtil {
campaign: Campaign,
context: VWOContext,
evaluatedFeatureMap: MutableMap,
- megGroupWinnerCampaigns: MutableMap?,
+ megGroupWinnerCampaigns: MutableMap?,
storageService: StorageService,
decision: MutableMap
): Map {
diff --git a/fme-android/src/main/java/com/vwo/utils/SettingsUtil.kt b/fme-android/src/main/java/com/vwo/utils/SettingsUtil.kt
index 9e29eb2..dfeadbb 100644
--- a/fme-android/src/main/java/com/vwo/utils/SettingsUtil.kt
+++ b/fme-android/src/main/java/com/vwo/utils/SettingsUtil.kt
@@ -23,12 +23,7 @@ import com.vwo.models.Settings
import com.vwo.models.Variation
import com.vwo.packages.logger.enums.LogLevelEnum
import com.vwo.services.LoggerService
-import java.util.Objects
-import java.util.function.Consumer
-import java.util.function.Function
-import java.util.function.Predicate
import java.util.regex.Pattern
-import java.util.stream.Collectors
/**
* Utility object for settings-related operations.
@@ -37,6 +32,9 @@ import java.util.stream.Collectors
* values, validating settings data, or performing other settings-related tasks.
*/
object SettingsUtil {
+
+ var settingsFile: Settings? = Settings()
+
/**
* Processes the settings file and modifies it as required.
* This method is called before the settings are used by the SDK.
@@ -57,6 +55,8 @@ object SettingsUtil {
}
addLinkedCampaignsToSettings(settings)
addIsGatewayServiceRequiredFlag(settings)
+ addIsHistoricalEventDSL(settings)
+ settingsFile = settings
} catch (exception: Exception) {
LoggerService.log(
LogLevelEnum.ERROR,
@@ -143,6 +143,28 @@ object SettingsUtil {
}
}
+ private fun addIsHistoricalEventDSL(settings: Settings) {
+
+ val patternString = """\s*"cnds"\s*[:.]?\s*"""
+ val pattern = Pattern.compile(patternString)
+
+ for (feature in settings.features) {
+ val rules: List = feature.rulesLinkedCampaign
+ for (rule in rules) {
+ val segmentsEvents =
+ if (rule.type == CampaignTypeEnum.ROLLOUT.value || rule.type == CampaignTypeEnum.PERSONALIZE.value) {
+ rule.variations?.get(0)?.segments_events
+ } else {
+ rule.segments_events
+ }
+
+ if (segmentsEvents != null) {
+ rule.isEventsDsl = true
+ }
+ }
+ }
+ }
+
/**
* Checks if a given starting index is within a "custom_variable" block in a string.
*
diff --git a/fme-android/src/main/java/com/vwo/utils/UUIDUtils.kt b/fme-android/src/main/java/com/vwo/utils/UUIDUtils.kt
index 8308656..34c3d91 100644
--- a/fme-android/src/main/java/com/vwo/utils/UUIDUtils.kt
+++ b/fme-android/src/main/java/com/vwo/utils/UUIDUtils.kt
@@ -15,26 +15,34 @@
*/
package com.vwo.utils
+import com.google.common.hash.Hashing
+import java.nio.charset.StandardCharsets
import java.util.Locale
import java.util.UUID
-/**
- * Utility object for UUID (Universally Unique Identifier) operations.
- *
- * This object provides helper methods for generating and working with UUIDs.
- */
object UUIDUtils {
+
+ // Define the DNS and URL namespaces for UUID v5
+ private val DNS_NAMESPACE = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ private val URL_NAMESPACE = UUID.fromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+
+ // Define the SEED_URL constant
+ private const val SEED_URL = "https://vwo.com"
+
/**
* Generates a random UUID based on an API key.
- * @param apiKey The API key used to generate a namespace for the UUID.
+ * @param sdkKey The API key used to generate a namespace for the UUID.
* @return A random UUID string.
*/
- fun getRandomUUID(apiKey: String): String {
+ fun getRandomUUID(sdkKey: String): String {
// Generate a namespace based on the API key using DNS namespace
- val namespace = UUID.nameUUIDFromBytes(apiKey.toByteArray())
- // Generate a random UUID using the namespace derived from the API key
+ val namespace = generateUUID(sdkKey, DNS_NAMESPACE)
+ // Generate a random UUID (UUIDv4)
val randomUUID = UUID.randomUUID()
- return UUID(namespace.mostSignificantBits, randomUUID.leastSignificantBits).toString()
+ // Generate a UUIDv5 using the random UUID and the namespace
+ val uuidv5 = generateUUID(randomUUID.toString(), namespace)
+
+ return uuidv5.toString()
}
/**
@@ -44,11 +52,16 @@ object UUIDUtils {
* @return A UUID string formatted without dashes and in uppercase.
*/
fun getUUID(userId: String?, accountId: String?): String {
- val VWO_NAMESPACE = UUID.nameUUIDFromBytes("https://vwo.com".toByteArray())
+ // Generate a namespace UUID based on SEED_URL using URL namespace
+ val VWO_NAMESPACE = generateUUID(SEED_URL, URL_NAMESPACE)
+ // Ensure userId and accountId are strings
+ val userIdStr = userId ?: ""
+ val accountIdStr = accountId ?: ""
// Generate a namespace UUID based on the accountId
- val userIdNamespace = generateUUID(accountId, VWO_NAMESPACE.toString())
+ val userIdNamespace = generateUUID(accountIdStr, VWO_NAMESPACE)
// Generate a UUID based on the userId and the previously generated namespace
- val uuidForUserIdAccountId = generateUUID(userId, userIdNamespace.toString())
+ val uuidForUserIdAccountId = generateUUID(userIdStr, userIdNamespace)
+
// Remove all dashes from the UUID and convert it to uppercase
val desiredUuid = uuidForUserIdAccountId.toString().replace("-".toRegex(), "").uppercase(
Locale.getDefault()
@@ -60,14 +73,67 @@ object UUIDUtils {
* Helper function to generate a UUID v5 based on a name and a namespace.
* @param name The name from which to generate the UUID.
* @param namespace The namespace used to generate the UUID.
- * @return A UUID string or null if inputs are invalid.
+ * @return A UUID.
*/
- private fun generateUUID(name: String?, namespace: String?): UUID? {
- // Check for valid input to prevent errors
+ fun generateUUID(name: String?, namespace: UUID?): UUID? {
if (name == null || namespace == null) {
return null
}
- // Generate and return the UUID v5
- return UUID.nameUUIDFromBytes(name.toByteArray())
+
+ val namespaceBytes = toBytes(namespace)
+ val nameBytes = name.toByteArray(StandardCharsets.UTF_8)
+ val combined = ByteArray(namespaceBytes.size + nameBytes.size)
+ System.arraycopy(namespaceBytes, 0, combined, 0, namespaceBytes.size)
+ System.arraycopy(nameBytes, 0, combined, namespaceBytes.size, nameBytes.size)
+
+ val hash = Hashing.sha1().hashBytes(combined).asBytes()
+
+ // Set version to 5 (name-based using SHA-1)
+ hash[6] = (hash[6].toInt() and 0x0f).toByte() // Clear version
+ hash[6] = (hash[6].toInt() or 0x50).toByte() // Set to version 5
+ hash[8] = (hash[8].toInt() and 0x3f).toByte() // Clear variant
+ hash[8] = (hash[8].toInt() or 0x80).toByte() // Set to IETF variant
+
+ return fromBytes(hash)
+ }
+
+ /**
+ * Helper function to convert a UUID to a byte array.
+ * @param uuid The UUID to convert.
+ * @return A byte array.
+ */
+ private fun toBytes(uuid: UUID): ByteArray {
+ val bytes = ByteArray(16)
+ val msb = uuid.mostSignificantBits
+ val lsb = uuid.leastSignificantBits
+
+ // Convert the most significant bits and least significant bits to bytes
+ for (i in 0..7) {
+ bytes[i] = (msb ushr (8 * (7 - i))).toByte()
+ bytes[8 + i] = (lsb ushr (8 * (7 - i))).toByte()
+ }
+
+ return bytes
+ }
+
+ /**
+ * Helper function to convert a byte array to a UUID.
+ * @param bytes The byte array to convert.
+ * @return A UUID.
+ */
+ private fun fromBytes(bytes: ByteArray): UUID {
+ var msb: Long = 0
+ var lsb: Long = 0
+
+ // Convert the most significant bits and least significant bits to longs
+ for (i in 0..7) {
+ msb = msb shl 8 or (bytes[i].toLong() and 0xff)
+ }
+
+ for (i in 8..15) {
+ lsb = lsb shl 8 or (bytes[i].toLong() and 0xff)
+ }
+
+ return UUID(msb, lsb)
}
}
diff --git a/fme-android/src/test/java/com/vwo/e2e/GetFlagTests.kt b/fme-android/src/test/java/com/vwo/e2e/GetFlagTests.kt
new file mode 100644
index 0000000..9b8140e
--- /dev/null
+++ b/fme-android/src/test/java/com/vwo/e2e/GetFlagTests.kt
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.vwo.e2e
+
+import com.vwo.VWO
+import com.vwo.VWO.init
+import com.vwo.VWOBuilder
+import com.vwo.interfaces.IVwoInitCallback
+import com.vwo.interfaces.IVwoListener
+import com.vwo.models.user.GetFlag
+import com.vwo.models.user.VWOInitOptions
+import com.vwo.testcases.TestData
+import com.vwo.testcases.TestDataReader
+import com.vwo.utils.DummySettingsReader
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito.spy
+import org.mockito.kotlin.whenever
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+class GetFlagTests {
+ private val SDK_KEY: String = "abcd"
+ private val ACCOUNT_ID: Int = 1234
+ private lateinit var settingsReader: DummySettingsReader
+ private lateinit var vwo: VWO
+ private var vwoInitOptions = VWOInitOptions()
+ private val testCases = TestDataReader().testCases
+
+ @Before
+ fun setup() {
+ }
+
+ @Test
+ fun testGetFlagWithoutStorage() {
+ testCases?.getFlagWithoutStorage?.let { runTests(it) }
+ }
+
+ @Test
+ fun testGetFlagWithMegRandom() {
+ testCases?.getFlagMegRandom?.let { runTests(it) }
+ }
+
+ @Test
+ fun testGetFlagWithMegAdvance() {
+ testCases?.getFlagMegAdvance?.let { runTests(it) }
+ }
+
+ /*fun testGetFlagWithStorage() {
+ testCases?.getFlagWithStorage?.let { runTests(it) }
+ }*/
+
+ fun runTests(tests: List) {
+
+ var featureFlag: GetFlag? = null
+ tests.forEach { testData ->
+ val vwoInitOptions = VWOInitOptions()
+ vwoInitOptions.sdkKey = SDK_KEY
+ vwoInitOptions.accountId = ACCOUNT_ID
+
+ settingsReader = DummySettingsReader()
+ val vwoBuilder = VWOBuilder(vwoInitOptions)
+ val vwoBuilderSpy: VWOBuilder = spy(vwoBuilder)
+ val settingsMap = settingsReader.settingsMap
+ val settings = settingsMap[testData.settings]
+ settings?.let {
+ whenever(vwoBuilderSpy.getSettings(false)).thenReturn(settings)
+ }
+ /*val result = vwoBuilderSpy.getSettings(false)
+ println("VWO - Mocked settings matching: ${result == settings}")*/
+ vwoInitOptions.vwoBuilder = vwoBuilderSpy
+
+ var latch = CountDownLatch(1)
+ init(vwoInitOptions, object : IVwoInitCallback {
+ override fun vwoInitSuccess(vwo: VWO, message: String) {
+ this@GetFlagTests.vwo = vwo
+ latch.countDown()
+ }
+
+ override fun vwoInitFailed(message: String) {
+ println("VWO $message")
+ }
+ })
+
+ latch.await(10, TimeUnit.SECONDS)
+ if (!::vwo.isInitialized) return
+ latch = CountDownLatch(1)
+ vwo.getFlag(testData.featureKey!!, testData.context!!, object : IVwoListener {
+ override fun onSuccess(data: Any) {
+ featureFlag = data as? GetFlag
+ latch.countDown()
+ }
+
+ override fun onFailure(message: String) {
+ println(message)
+ }
+ })
+
+ // Wait for onSuccess to be called
+ latch.await(5, TimeUnit.SECONDS)
+ val isFeatureFlagEnabled = featureFlag?.isEnabled()
+ assertEquals(testData.expectation?.isEnabled, isFeatureFlagEnabled)
+ val variable = featureFlag?.getVariable("int", 1)
+ assertEquals(
+ testData.expectation?.intVariable,
+ (variable as? Int) ?: (variable as? Double)?.toInt() ?: 1
+ )
+ assertEquals(
+ testData.expectation?.stringVariable,
+ featureFlag?.getVariable("string", "VWO")
+ )
+ assertEquals(
+ testData.expectation?.floatVariable,
+ featureFlag?.getVariable("float", 1.1)
+ )
+ assertEquals(
+ testData.expectation?.booleanVariable,
+ featureFlag?.getVariable("boolean", false)
+ )
+ assertEquals(
+ testData.expectation?.jsonVariable,
+ featureFlag?.getVariable("json", HashMap())
+ )
+ }
+ }
+}
\ No newline at end of file
diff --git a/fme-android/src/test/java/com/vwo/packages/segmentor/AndOperatorTests.kt b/fme-android/src/test/java/com/vwo/packages/segmentor/AndOperatorTests.kt
new file mode 100644
index 0000000..bd48a4a
--- /dev/null
+++ b/fme-android/src/test/java/com/vwo/packages/segmentor/AndOperatorTests.kt
@@ -0,0 +1,183 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.packages.segmentor
+
+import com.vwo.VWO
+import com.vwo.interfaces.IVwoInitCallback
+import com.vwo.models.user.VWOInitOptions
+import com.vwo.packages.segmentation_evaluator.core.SegmentationManager
+import com.vwo.utils.NetworkUtil.Companion.removeNullValues
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+
+
+class AndOperatorTests {
+
+ private lateinit var vwo: VWO
+ private val SDK_KEY = "abcd"
+ private val ACCOUNT_ID = 1234
+
+ @Before
+ fun initialize() {
+ val vwoInitOptions = VWOInitOptions()
+ vwoInitOptions.sdkKey = SDK_KEY
+ vwoInitOptions.accountId = ACCOUNT_ID
+ VWO.init(vwoInitOptions, object : IVwoInitCallback {
+ override fun vwoInitSuccess(vwo: VWO, message: String) {
+ this@AndOperatorTests.vwo = vwo
+ }
+
+ override fun vwoInitFailed(message: String) {
+ }
+ })
+ }
+
+ @Test
+ fun singleAndOperatorMatchingTest() {
+ val dsl = "{\"and\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "eq_value")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun singleAndOperatorMismatchTest() {
+ val dsl = "{\"and\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("a", "n_eq_value")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun singleAndOperatorCaseMismatchTest() {
+ val dsl = "{\"and\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "Eq_Value")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun multipleAndOperatorTest2() {
+ val dsl =
+ "{\"and\":[{\"and\":[{\"and\":[{\"and\":[{\"and\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]}]}]}]}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "eq_value")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun multipleAndOperatorWithSingleCorrectValueTest() {
+ val dsl =
+ "{\"and\":[{\"or\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]},{\"or\":[{\"custom_variable\":{\"reg\":\"regex(myregex+)\"}}]}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "eq_value")
+ put("reg", "wrong")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun multipleAndOperatorWithSingleCorrectValueTest2() {
+ val dsl =
+ "{\"and\":[{\"or\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]},{\"or\":[{\"custom_variable\":{\"reg\":\"regex(myregex+)\"}}]}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "wrong")
+ put("reg", "myregexxxxxx")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun multipleAndOperatorWithAllCorrectCustomVariablesTest() {
+ val dsl =
+ "{\"and\":[{\"or\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]},{\"or\":[{\"custom_variable\":{\"reg\":\"regex(myregex+)\"}}]}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "eq_value")
+ put("reg", "myregexxxxxx")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun multipleAndOperatorWithAllIncorrectCorrectCustomVariablesTest() {
+ val dsl =
+ "{\"and\":[{\"or\":[{\"custom_variable\":{\"eq\":\"eq_value\"}}]},{\"or\":[{\"custom_variable\":{\"reg\":\"regex(myregex+)\"}}]}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "wrong")
+ put("reg", "wrong")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun sdhgsjdh() {
+ val dsl = "{\"or\":[{\"user\":\"Varun\"}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "wrong")
+ put("reg", "wrong")
+ put("expectation", false)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ private fun verifyExpectation(dsl: String, customVariables: Map) {
+ SegmentationManager.attachEvaluator()
+ assertEquals(
+ SegmentationManager.validateSegmentation(dsl, customVariables),
+ customVariables["expectation"]
+ )
+ }
+}
diff --git a/fme-android/src/test/java/com/vwo/packages/segmentor/CaseInsensitiveEqualityOperandTests.kt b/fme-android/src/test/java/com/vwo/packages/segmentor/CaseInsensitiveEqualityOperandTests.kt
new file mode 100644
index 0000000..0043980
--- /dev/null
+++ b/fme-android/src/test/java/com/vwo/packages/segmentor/CaseInsensitiveEqualityOperandTests.kt
@@ -0,0 +1,489 @@
+/**
+ * Copyright 2024 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.vwo.packages.segmentor
+
+import com.vwo.VWO
+import com.vwo.VWO.init
+import com.vwo.interfaces.IVwoInitCallback
+import com.vwo.models.user.VWOInitOptions
+import com.vwo.packages.segmentation_evaluator.core.SegmentationManager.attachEvaluator
+import com.vwo.packages.segmentation_evaluator.core.SegmentationManager.validateSegmentation
+import com.vwo.utils.NetworkUtil.Companion.removeNullValues
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+
+class CaseInsensitiveEqualityOperandTests {
+
+ private val sdkKey = "abcd"
+ private val accountId = 1234
+ private lateinit var vwo: VWO
+
+ @Before
+ fun initialize() {
+ val vwoInitOptions = VWOInitOptions()
+ vwoInitOptions.sdkKey = sdkKey
+ vwoInitOptions.accountId = accountId
+ init(vwoInitOptions, object : IVwoInitCallback {
+ override fun vwoInitSuccess(vwo: VWO, message: String) {
+ this@CaseInsensitiveEqualityOperandTests.vwo = vwo
+ }
+
+ override fun vwoInitFailed(message: String) {
+ }
+ })
+ }
+
+ @Test
+ fun exactMatchTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(something)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "something")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun exactMatchWithSpecialCharactersTest() {
+ val dsl =
+ "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(f25u!v@b#k$6%9^f&o*v(m)w_-=+s,./`(*&^%$#@!)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "f25u!v@b#k$6%9^f&o*v(m)w_-=+s,./`(*&^%$#@!")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun exactMatchWithSpacesTest() {
+ val dsl =
+ "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(nice to see you. will YOU be my Friend?)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "nice to see you. will YOU be my Friend?")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun exactMatchWithUpperCaseTest() {
+ val dsl =
+ "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(HgUvshFRjsbTnvsdiUFFTGHFHGvDRT.YGHGH)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "HgUvshFRjsbTnvsdiUFFTGHFHGvDRT.YGHGH")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun caseMismatchTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(something)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "Something")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun caseMismatchTest2() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(something)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "SOMETHINg")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun trimValueTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(HI)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", " hi ")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun numericDataTypeTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", 123)
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun floatDataTypeTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123.456)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", 123.456)
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun floatDataTypeExtraDecimalZerosTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123.456)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", 123.456000000)
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun numericDataTypeMismatchTest2() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", 123.0)
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun stringifiedFloatTest() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123.456)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", "123.456000000")
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun stringifiedFloatTest2() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123.0)\"}}]}"
+ val customVariables: Map = object : HashMap() {
+ init {
+ put("eq", 123)
+ put("expectation", true)
+ }
+ }
+
+ verifyExpectation(dsl, removeNullValues(customVariables))
+ }
+
+ @Test
+ fun stringifiedFloatTest3() {
+ val dsl = "{\"or\":[{\"custom_variable\":{\"eq\":\"lower(123.4560000)\"}}]}"
+ val customVariables: Map = object : HashMap