Android Rules Engine

dependencies {
    implementation("io.gorules:zen-engine-kotlin-android:0.4.7")
}

import io.gorules.zen_engine.kotlin.ZenEngine
import io.gorules.zen_engine.kotlin.JsonBuffer
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        runBlocking {
            val ruleJson = assets.open("rules/pricing.json").readBytes()

            ZenEngine(null, null).use { engine ->
                val decision = engine.createDecision(JsonBuffer(ruleJson))

                val input = JsonBuffer("""
                    {
                        "customer": { "tier": "gold", "yearsActive": 3 },
                        "order": { "subtotal": 150, "items": 5 }
                    }
                """)

                val response = decision.evaluate(input, null)

                Log.d("ZenEngine", response.result.toString())
                // => {"discount":0.15,"freeShipping":true}
            }
        }
    }
}

import io.gorules.zen_engine.kotlin.ZenEngine
import io.gorules.zen_engine.kotlin.ZenLoader
import io.gorules.zen_engine.kotlin.JsonBuffer

fun createEngine(context: Context): ZenEngine {
    val pricing = context.assets.open("rules/pricing.json").readBytes()

    val loader = ZenLoader.Static(mapOf("pricing.json" to JsonBuffer(pricing)))
    return ZenEngine(loader, null)
}

import io.gorules.zen_engine.kotlin.ZenEngine
import io.gorules.zen_engine.kotlin.ZenLoader
import java.io.File

fun createEngine(context: Context): ZenEngine {
    val loader = ZenLoader.Filesystem(File(context.filesDir, "rules").absolutePath)
    return ZenEngine(loader, null)
}

import io.gorules.zen_engine.kotlin.ZenEngine
import io.gorules.zen_engine.kotlin.ZenLoader
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.File

val client = OkHttpClient()

fun createEngine(context: Context): ZenEngine {
    val cacheFile = File(context.cacheDir, "decisions.zip")

    val zipBytes = if (cacheFile.exists()) {
        cacheFile.readBytes()
    } else {
        val request = Request.Builder()
            .url("https://api.example.com/decisions.zip")
            .build()
        val bytes = client.newCall(request).execute().body!!.bytes()
        cacheFile.parentFile?.mkdirs()
        cacheFile.writeBytes(bytes)
        bytes
    }

    return ZenEngine(ZenLoader.Zip(zipBytes), null)
}

import io.gorules.zen_engine.kotlin.ZenEngine
import io.gorules.zen_engine.kotlin.ZenLoader
import io.gorules.zen_engine.kotlin.ZenDecisionLoaderCallback
import io.gorules.zen_engine.kotlin.JsonBuffer
import com.google.firebase.remoteconfig.FirebaseRemoteConfig

val remoteConfig = FirebaseRemoteConfig.getInstance()

fun createEngine(): ZenEngine {
    val callback = object : ZenDecisionLoaderCallback {
        override suspend fun load(key: String): JsonBuffer? {
            val json = remoteConfig.getString("decision_$key")
            return if (json.isEmpty()) null else JsonBuffer(json)
        }
    }
    return ZenEngine(ZenLoader.Callback(callback), null)
}

val results = engine.evaluateBatch(
    listOf(
        ZenBatchRequest("pricing.json", JsonBuffer("""{ "amount": 100 }""")),
        ZenBatchRequest("pricing.json", JsonBuffer("""{ "amount": 250 }"""))
    ),
    null
)

for (result in results) {
    if (result.success) {
        println(result.data?.result)
    } else {
        println("Evaluation failed: ${result.error}")
    }
}

import kotlinx.coroutines.*

lifecycleScope.launch {
    val results = inputs.map { input ->
        async(Dispatchers.Default) {
            decision.evaluate(JsonBuffer(input), null)
        }
    }.awaitAll()

    results.forEach { Log.d("ZenEngine", it.result.toString()) }
}

import io.gorules.zen_engine.kotlin.ZenException

try {
    val response = decision.evaluate(input, null)
    Log.d("ZenEngine", response.result.toString())
} catch (e: ZenException) {
    Log.e("ZenEngine", "Evaluation failed: ${e.message}")
}

import io.gorules.zen_engine.kotlin.ZenEvaluateOptions

val options = ZenEvaluateOptions(trace = true, maxDepth = null)

val response = decision.evaluate(input, options)

Log.d("ZenEngine", "Trace: ${response.trace}")
Log.d("ZenEngine", "Performance: ${response.performance}")

import io.gorules.zen_engine.kotlin.evaluateExpression
import io.gorules.zen_engine.kotlin.evaluateUnaryExpression
import io.gorules.zen_engine.kotlin.JsonBuffer

// Standard expressions
val result = evaluateExpression("a + b", JsonBuffer("""{ "a": 5, "b": 3 }"""))
// => 8

val total = evaluateExpression("sum(items)", JsonBuffer("""{ "items": [1, 2, 3, 4] }"""))
// => 10

// Unary expressions (comparison against $)
val isValid = evaluateUnaryExpression(">= 5", JsonBuffer("""{ "$": 10 }"""))
// => true

val inList = evaluateUnaryExpression("'US', 'CA', 'MX'", JsonBuffer("""{ "$": "US" }"""))
// => true

ZenEngine(null, null).use { engine ->
    // use engine
}