chore: event-log filtering (#42)

* fix: get-history revert to original version * chore: event-log filtering
walt-id · Dec 14, 2023 · 485235c · 485235c
1 parent 56400db
commit 485235c
Show file tree

Hide file tree

Showing 5 changed files with 51 additions and 63 deletions.
diff --git a/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/SSIKit2WalletService.kt b/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/SSIKit2WalletService.kt
@@ -53,7 +53,6 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.*
 import kotlinx.uuid.UUID
-import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -651,13 +650,11 @@ class SSIKit2WalletService(tenant: String?, accountId: UUID, walletId: UUID) :
 // TODO
 //fun infoAboutOfferRequest
 
-    override fun getHistory(limit: Int, offset: Long): List<WalletOperationHistory> = transaction {
-        WalletOperationHistories
-            .select { (WalletOperationHistories.tenant eq tenant) and (WalletOperationHistories.accountId eq walletId) }
-            .orderBy(WalletOperationHistories.timestamp)
-            .limit(10)
-            .map { WalletOperationHistory(it) }
-    }
+    override fun getHistory(limit: Int, offset: Long): List<WalletOperationHistory> =
+        WalletOperationHistories.select { WalletOperationHistories.wallet eq walletId }
+            .orderBy(WalletOperationHistories.timestamp).limit(10).map { row ->
+                WalletOperationHistory(row)
+            }
 
     override suspend fun addOperationHistory(operationHistory: WalletOperationHistory) {
         transaction {
@@ -674,11 +671,12 @@ class SSIKit2WalletService(tenant: String?, accountId: UUID, walletId: UUID) :
 
     override fun filterEventLog(filter: EventLogFilter): EventLogFilterResult = runCatching {
         val startingAfterItemIndex = filter.startingAfter?.toLongOrNull()?.takeIf { it >= 0 } ?: -1L
-        val dataFilter = emptyMap<String, String>()
         val pageSize = filter.limit
-        val count = EventService.count(walletId, dataFilter)
+        val count = EventService.count(walletId, filter.data)
         val offset = startingAfterItemIndex + 1
-        val events = EventService.get(accountId, walletId, filter.limit, offset, dataFilter)
+        val events = EventService.get(
+            accountId, walletId, filter.limit, offset, filter.sortOrder ?: "asc", filter.sortBy ?: "", filter.data
+        )
         EventLogFilterDataResult(
             items = events,
             count = events.size,

diff --git a/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/events/EventLogFilter.kt b/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/events/EventLogFilter.kt
@@ -2,10 +2,8 @@ package id.walt.webwallet.service.events
 
 data class EventLogFilter(
     val limit: Int = 0,
-    val event: String? = null,
-    val action: String? = null,
-    val tenant: String? = null,
     val startingAfter: String? = null,
-    val sortBy: String?=null,
-    val sortOrder: String?=null,
+    val sortBy: String? = null,
+    val sortOrder: String? = null,
+    val data: Map<String, String> = emptyMap()
 )
diff --git a/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/events/EventService.kt b/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/service/events/EventService.kt
@@ -5,24 +5,27 @@ import kotlinx.datetime.toJavaInstant
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.uuid.UUID
-import org.jetbrains.exposed.sql.Query
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.or
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
 object EventService {
-    fun get(accountId: UUID, walletId: UUID, limit: Int, offset: Long, dataFilter: Map<String, String> = emptyMap()): List<Event> =
-        addWhereClause(
-            Events.select { Events.account eq accountId or (Events.wallet eq walletId) }, dataFilter
-        ).orderBy(Events.timestamp).limit(n = limit, offset = offset).map {
-                Event(it)
-            }
+    fun get(
+        accountId: UUID,
+        walletId: UUID,
+        limit: Int,
+        offset: Long,
+        sortOrder: String,
+        sortBy: String,
+        dataFilter: Map<String, String> = emptyMap()
+    ) = Events.select { Events.account eq accountId or (Events.wallet eq walletId) }
+        .orderBy(getColumn(sortBy) ?: Events.timestamp,
+            sortOrder.takeIf { it.uppercase() == "ASC" }?.let { SortOrder.ASC } ?: SortOrder.DESC)
+        .limit(n = limit, offset = offset).addWhereClause(dataFilter).map {
+            Event(it)
+        }
 
-    fun count(walletId: UUID, dataFilter: Map<String, String> = emptyMap()): Long = addWhereClause(
-        Events.select { Events.wallet eq walletId }, dataFilter
-    ).count()
+    fun count(walletId: UUID, dataFilter: Map<String, String> = emptyMap()): Long =
+        Events.select { Events.wallet eq walletId }.addWhereClause(dataFilter).count()
 
 
     fun add(event: Event): Unit = transaction {
@@ -38,19 +41,19 @@ object EventService {
         }
     }
 
-    private fun addWhereClause(query: Query, dataFilter: Map<String, String>) = let {
-        dataFilter["event"]?.let {
-            query.adjustWhere { Events.event eq it }
-        }
-        dataFilter["action"]?.let {
-            query.adjustWhere { Events.action eq it }
-        }
-        dataFilter["tenant"]?.let {
-            query.adjustWhere { Events.tenant eq it }
-        }
-        dataFilter["originator"]?.let {
-            query.adjustWhere { Events.originator eq it }
+    private fun Query.addWhereClause(dataFilter: Map<String, String>) = let {
+        dataFilter.forEach {
+            when (it.key) {
+                "event" -> this.andWhere { Events.event eq it.value }
+                "action" -> this.andWhere { Events.action eq it.value }
+                "tenant" -> this.andWhere { Events.tenant eq it.value }
+                "originator" -> this.andWhere { Events.originator eq it.value }
+            }
         }
-        query
+        this
+    }
+
+    private fun getColumn(name: String) = Events.columns.singleOrNull {
+        it.name == name.lowercase()
     }
 }
diff --git a/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/web/controllers/EventLogController.kt b/waltid-web-wallet/src/main/kotlin/id/walt/webwallet/web/controllers/EventLogController.kt
@@ -7,7 +7,9 @@ import io.github.smiley4.ktorswaggerui.dsl.get
 import io.github.smiley4.ktorswaggerui.dsl.route
 import io.ktor.http.*
 import io.ktor.server.application.*
+import io.ktor.server.request.*
 import io.ktor.server.response.*
+import kotlinx.serialization.Serializable
 import org.jetbrains.exposed.sql.transactions.transaction
 
 fun Application.eventLogs() = walletRoute {
@@ -22,19 +24,9 @@ fun Application.eventLogs() = walletRoute {
                     example = "10"
                     required = false
                 }
-                queryParameter<String>("event") {
-                    description = "Event type"
-                    example = "Account"
-                    required = false
-                }
-                queryParameter<String>("action") {
-                    description = "Action type"
-                    example = "Login"
-                    required = false
-                }
-                queryParameter<String>("tenant") {
-                    description = "Tenant"
-                    example = "global"
+                queryParameter<List<String>>("filter") {
+                    description = "List of key=value pairs for filtering"
+                    example = "key=value"
                     required = false
                 }
                 queryParameter<String>("startingAfter") {
@@ -63,22 +55,19 @@ fun Application.eventLogs() = walletRoute {
         }) {
             val wallet = getWalletService()
             val limit = call.request.queryParameters["limit"]?.toIntOrNull() ?: -1
-            val event = call.request.queryParameters["event"]
-            val action = call.request.queryParameters["action"]
-            val tenant = call.request.queryParameters["tenant"]
+            val data = call.request.queryParameters.getAll("filter")
+                ?.associate { it.substringBefore("=") to it.substringAfter("=") } ?: emptyMap()
             val startingAfter = call.request.queryParameters["startingAfter"]
             val sortBy = call.request.queryParameters["sortBy"]
             val sortOrder = call.request.queryParameters["sortOrder"]
             context.respond(transaction {
                 wallet.filterEventLog(
                     EventLogFilter(
                         limit = limit,
-                        event = event,
-                        action = action,
-                        tenant = tenant,
                         startingAfter = startingAfter,
                         sortBy = sortBy,
                         sortOrder = sortOrder,
+                        data = data,
                     )
                 )
             })

diff --git a/waltid-web-wallet/web/src/pages/wallet/[wallet]/eventlog.vue b/waltid-web-wallet/web/src/pages/wallet/[wallet]/eventlog.vue
@@ -129,7 +129,7 @@ const { data: eventLog, pending: pending } = await useLazyAsyncData(
     () =>
         $fetch(`/wallet-api/wallet/${currentWallet.value}/eventlog`, {
             params: {
-                limit: 2,
+                limit: 10,
                 startingAfter: startingAfter.value,
             },
         }),