Work on API pagination

Author: pklimai

README.md

@@ -200,5 +200,20 @@ curl -X POST -u USER:PASS -H "Content-Type: application/json" http://127.0.0.1/e
 '
 ```
 
-Note: `software_version` and `storage_name` must exist in the corresponding EMS database tables.
-The `file_path` will be automatically created in the `file_` table, if not there yet.
+The GET response also includes some extra data, like this (`limit` is the maximum number of events
+that were requested or could be returned, `offset` is offset starting from which events were retrieved,
+`count` is equal to actual number of events in `events`: 
+
+```
+{
+    "events": [ ... ]
+    "limit": 50000,
+    "offset": 0,
+    "count": 100
+}
+```
+
+Note: when POSTing or PUTing events, `software_version` and `storage_name` must exist in the corresponding 
+EMS database tables beforehand. However, the `file_path` entry will be automatically created in 
+the `file_` table, if not there yet.
+

src/commonMain/kotlin/ConfigFile.kt

@@ -2,7 +2,9 @@ package ru.mipt.npm.nica.ems
 
 import kotlinx.serialization.Serializable
 
-val DEFAULT_LIMIT_FOR_WEB = 1000
+val DEFAULT_LIMIT_FOR_WEB = 10_000L
+val DEFAULT_LIMIT_FOR_API = 50_000L
+val MAX_LIMIT_FOR_API = 100_000L
 
 /**
  * Determines configuration file structure
@@ -46,7 +48,8 @@ class PageConfig(
     val parameters: List<ParameterConfig>,
     // By default, this number of records is returned in WebUI if limit is not specified
     // does not need to be specified in YAML (uses given default value if not specified)
-    val default_limit_web: Int = DEFAULT_LIMIT_FOR_WEB
+    val default_limit_web: Long = DEFAULT_LIMIT_FOR_WEB,
+    val default_limit_api: Long = DEFAULT_LIMIT_FOR_API
 )
 
 @Serializable

src/jvmMain/kotlin/Application.kt

@@ -291,6 +291,8 @@ fun Application.main() {
                         try {
                             connEMD = newEMDConnection(config, this.context)!!
                             val res = queryEMD(parameterBundle, page, connCondition, connEMD!!, null)
+                            val limit = getLimit(page, parameterBundle.limit?.stringValue)
+                            val offset = parameterBundle.offset?.stringValue?.toLong() ?: 0
                             val lstEvents = ArrayList<EventRepr>()
                             while (res?.next() == true) {
                                 val paramMap = HashMap<String, Any>()
@@ -317,7 +319,12 @@ fun Application.main() {
                                     )
                                 )
                             }
-                            call.respond(mapOf("events" to lstEvents))
+                            call.respond(mapOf(
+                                "events" to lstEvents,
+                                "limit" to limit,
+                                "offset" to offset,
+                                "count" to lstEvents.size
+                            ))
                         } catch (err: PSQLException) {
                             if (err.toString().contains("The connection attempt failed.")) {
                                 call.respond(HttpStatusCode.ServiceUnavailable, "Database connection failed: $err")

src/jvmMain/kotlin/EventDBUtils.kt

@@ -58,13 +58,25 @@ fun getStorageMap(conn: java.sql.Connection): StorageMap {
     return StorageMap(strToId)
 }
 
+fun getLimit(page: PageConfig,providedLimit: String?): Long {
+    if (providedLimit.isNullOrEmpty()) {
+        return page.default_limit_api
+    } else {
+        if (providedLimit.toLong() > MAX_LIMIT_FOR_API) {
+            return MAX_LIMIT_FOR_API
+        } else {
+            return providedLimit.toLong()
+        }
+    }
+}
+
 fun queryEMD(
     parameterBundle: ParameterBundle,
     page: PageConfig,
     connCondition: Connection?,
     connEMD: Connection,
     body: BODY?,
-    defaultLimit: Int? = null,
+    //defaultLimit: Int? = null,
     countOnly: Boolean = false
 ): ResultSet? {
     with(parameterBundle) {
@@ -109,12 +121,10 @@ fun queryEMD(
             query += " WHERE " + filterCriteria.joinToString(" AND ")
         }
 
-        if (limit != null) {
-            query += " LIMIT ${limit.stringValue}"
-        } else if (defaultLimit != null) {
-            query += " LIMIT $defaultLimit"
-        }
+        query += " LIMIT ${getLimit(page, limit?.stringValue)}"
+
         offset?.let {
+            val offs = offset.stringValue.toLong()    // TODO better check bad characters, esp. "|"
             query += " OFFSET ${offset.stringValue}"
         }
 

src/jvmMain/kotlin/legacyUI/LegacyPages.kt

@@ -137,7 +137,7 @@ fun Route.legacyPage(page: PageConfig, config: ConfigFile, connCondition: java.s
                         h3 { +"Events found:" }
 
                         val res = queryEMD(
-                            parameterBundle, page, connCondition, connEMD, this, DEFAULT_LIMIT_FOR_WEB
+                            parameterBundle, page, connCondition, connEMD, this
                         )
 
                         br {}