start adding signature and encryption

src/main/kotlin/com/restapi/controllers/Entities.kt

@@ -1,9 +1,7 @@
 package com.restapi.controllers
 
-import com.restapi.domain.ApprovalStatus
-import com.restapi.domain.DataModel
-import com.restapi.domain.EntityModel
-import com.restapi.domain.Session
+import com.restapi.domain.*
+import com.restapi.domain.Session.currentUser
 import com.restapi.domain.Session.database
 import com.restapi.domain.Session.findByEntityAndId
 import com.restapi.integ.Scripting
@@ -14,17 +12,24 @@ import io.javalin.http.Context
 import io.javalin.http.NotFoundResponse
 import io.javalin.http.bodyAsClass
 import org.slf4j.LoggerFactory
+import java.sql.Types
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.LocalTime
 import java.time.format.DateTimeFormatter
 
-data class PatchValue(val key: String, val value: Any)
 data class Query(
     val sql: String,
     val params: Map<String, Any>
 )
 
+enum class ResultType {
+    INTEGER, DECIMAL, STRING, DATETIME, ARRAY, OBJECT
+}
+
+data class RejectAction(val reason: String)
+data class StoredProcedure(val input: Map<String, Any>, val output: Map<String, ResultType> = hashMapOf())
+
 object Entities {
     private val logger = LoggerFactory.getLogger("Entities")
     fun delete(ctx: Context) {
@@ -37,47 +42,90 @@ object Entities {
 
     fun patch(ctx: Context) {
         val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
-        val pv = ctx.bodyAsClass<PatchValue>()
-        e.data[pv.key] = pv.value;
+        val pv = ctx.bodyAsClass<Map<String, Any>>()
+        pv.forEach { (key, value) ->
+            e.data[key] = value;
+        }
+
         e.update()
     }
 
     fun update(ctx: Context) {
+        val purgeExisting = ctx.queryParam("purge")?.toBooleanStrictOrNull() == true
         val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
+
         val newData = ctx.bodyAsClass<Map<String, Any>>()
+        if (purgeExisting) {
+            e.data.clear();
+        }
         e.data.putAll(newData)
+
         e.update()
     }
 
     fun action(ctx: Context) {}
-    fun approve(ctx: Context) {}
-    fun reject(ctx: Context) {}
+    fun approve(ctx: Context) {
+        approveOrReject(ctx, ApprovalStatus.APPROVED)
+    }
+
+    fun reject(ctx: Context) {
+        approveOrReject(ctx, ApprovalStatus.REJECTED)
+    }
+
+    private fun approveOrReject(ctx: Context, rejected: ApprovalStatus) {
+        val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
+        val reject = ctx.bodyAsClass<RejectAction>()
+        e.approvalStatus = rejected
+        e.comments.add(Comments(text = reject.reason, by = currentUser()))
+        e.save()
+    }
 
     fun executeScript(ctx: Context) {
         val name = ctx.pathParam("name")
+        val file = ctx.pathParam("file")
         val params = ctx.bodyAsClass<Map<String, Any>>()
         ctx.json(
-            Scripting.
-            execute(name, "execute", params, logger)
+            Scripting.execute(file, name, params)
         )
     }
 
     fun executeStoredProcedure(ctx: Context) {
         val name = ctx.pathParam("name")
-        val params = ctx.bodyAsClass<Map<String, Any>>()
-        val placeholders = (0..params.entries.size + 1).joinToString(",") { "?" }
+        val sp = ctx.bodyAsClass<StoredProcedure>()
+
+        val inputParams = sp.input.entries.toList()
+        val outputParams = sp.output.entries.toList()
+
+        val placeholders = (0..inputParams.size + 1).joinToString(",") { "?" }
 
         val sql = "{call $name($placeholders)}"
         val cs: CallableSql = database.createCallableSql(sql)
 
-        params.entries.forEachIndexed { index, entry ->
+        inputParams.forEachIndexed { index, entry ->
             cs.setParameter(index + 1, entry.value)
         }
-        cs.setParameter(params.entries.size + 1, Session.currentTenant())
+        cs.setParameter(inputParams.size + 1, Session.currentTenant())
+
+        outputParams.forEachIndexed { idx, entry ->
+            when (entry.value) {
+                ResultType.INTEGER -> cs.registerOut(idx + 1, Types.INTEGER)
+                ResultType.DECIMAL -> cs.registerOut(idx + 1, Types.DOUBLE)
+                ResultType.STRING -> cs.registerOut(idx + 1, Types.VARCHAR)
+                ResultType.DATETIME -> cs.registerOut(idx + 1, Types.DATE)
+                ResultType.ARRAY -> cs.registerOut(idx + 1, Types.ARRAY)
+                ResultType.OBJECT -> cs.registerOut(idx + 1, Types.JAVA_OBJECT)
+            }
+
+        }
         val done = database.execute(cs)
+        val output = outputParams.mapIndexed { index, entry ->
+            Pair(entry.key, cs.getObject(index + 1))
+        }.toMap()
+
         ctx.json(
             mapOf(
-                "done" to done
+                "done" to done,
+                "output" to output
             )
         )
     }
@@ -204,7 +252,7 @@ object Entities {
                         }
                     }
                     if (!setupEntity.preSaveScript.isNullOrEmpty()) {
-                        val ok = Scripting.preSave(setupEntity.preSaveScript!!, "preSave", this, logger) as Boolean
+                        val ok = Scripting.execute(setupEntity.preSaveScript!!, "preSave", this) as Boolean
                         if (!ok) {
                             throw BadRequestResponse("PreSave Failed")
                         }
@@ -219,6 +267,10 @@ object Entities {
                 }
             }
         )
+
+        if (setupEntity != null && !setupEntity.postSaveScript.isNullOrEmpty()) {
+            Scripting.execute(setupEntity.postSaveScript!!, "postSave", dataModel)
+        }
     }
 
     private fun isValidDate(f: String) = try {