mq done, dao refactor, endpoints refactor

src/Application.kt

@@ -1,8 +1,10 @@
 package com.kmalbz
 
+import com.google.gson.Gson
+import com.kmalbz.api.model.ApiObject
+import com.kmalbz.api.route.OutputServiceRDBServer
 import io.ktor.application.*
 import io.ktor.response.*
-import io.ktor.request.*
 import io.ktor.routing.*
 import io.ktor.http.*
 import io.ktor.gson.*
@@ -10,11 +12,20 @@ import io.ktor.features.*
 import io.ktor.client.*
 import io.ktor.client.engine.apache.*
 import io.ktor.auth.*
-import kotlin.reflect.*
-import java.util.*
 import org.apache.http.HttpException
 import com.kmalbz.database.DatabaseFactory
+import com.kmalbz.database.dao.ResultObjects
+import com.kmalbz.database.service.ResultObjectService
+import com.kmalbz.mq.RecieveOutput
 import io.ktor.util.KtorExperimentalAPI
+import com.rabbitmq.client.*
+import com.typesafe.config.ConfigFactory
+import io.ktor.config.HoconApplicationConfig
+import com.viartemev.thewhiterabbit.channel.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import org.jetbrains.exposed.sql.SchemaUtils
 
 fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)
 
@@ -34,6 +45,32 @@ fun Application.module(testing: Boolean = false) {
     }
 
     DatabaseFactory.init()
+    SchemaUtils.create(ResultObjects)
+
+    val appConfig = HoconApplicationConfig(ConfigFactory.load())
+    val factory = ConnectionFactory()
+    factory.host = appConfig.property("mq.host").getString()
+    val connection = factory.newConnection()
+    val channel = connection.createChannel()
+
+    channel.exchangeDeclare(RecieveOutput.EXCHANGE_NAME, "FANOUT")
+    val queueName = channel.queueDeclare().queue
+    channel.queueBind(queueName, RecieveOutput.EXCHANGE_NAME, "")
+
+    GlobalScope.launch(Dispatchers.Default) {
+        connection.channel {
+            consume("test_queue") {
+                consumeMessageWithConfirm({
+                    val resultObjectService = ResultObjectService()
+                    val rawJson = String(it.body)
+                    val gson = Gson()
+                    val apiObject = gson.fromJson(rawJson,ApiObject::class.java)
+
+                    resultObjectService.addOne(apiObject)
+                })
+            }
+        }
+    }
 
     routing {
         get("/") {

src/api/model/ApiObject.kt

@@ -0,0 +1,11 @@
+package com.kmalbz.api.model
+
+import com.google.gson.annotations.SerializedName
+import java.time.LocalDate
+
+data class ApiObject(
+    @SerializedName("tag") val tag: String,
+    @SerializedName("date") val date: LocalDate,
+    @SerializedName("decision") val decision: Boolean,
+    @SerializedName("confidence") val confidence: Double
+)

src/api/route/OutputServiceRDBServer.kt

@@ -1,4 +1,4 @@
-package com.kmalbz
+package com.kmalbz.api.route
 
 import io.ktor.application.*
 import io.ktor.response.*

src/database/dao/ResultObjects.kt

@@ -1,11 +1,11 @@
 package com.kmalbz.database.dao
 
+import org.jetbrains.exposed.dao.id.IntIdTable
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.`java-time`.date
 import java.time.LocalDate
 
-object ResultObjects : Table() {
-    val id: Column<Int> = integer("id").autoIncrement()
+object ResultObjects : IntIdTable() {
     val tag: Column<String> = varchar("tag",32)
     val date: Column<LocalDate> = date("date")
     val decision: Column<Boolean> = bool("decision")

src/database/model/ResultObject.kt

@@ -1,11 +1,14 @@
 package com.kmalbz.database.model
 
-import java.time.LocalDate
+import com.kmalbz.database.dao.ResultObjects
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
 
-data class ResultObject(
-    val id: Int,
-    val tag: String,
-    val date: LocalDate,
-    val decision: Boolean,
-    val confidence: Double
-)
+class ResultObject(id: EntityID<Int>): IntEntity(id) {
+    companion object : IntEntityClass<ResultObject>(ResultObjects)
+    var tag by ResultObjects.tag
+    var date by ResultObjects.tag
+    var decision by ResultObjects.decision
+    var confidence by ResultObjects.confidence
+}

src/database/service/ResultObjectService.kt

@@ -3,52 +3,64 @@ package com.kmalbz.database.service
 import com.kmalbz.database.DatabaseFactory.dbQuery
 import com.kmalbz.database.model.ResultObject
 import com.kmalbz.database.dao.ResultObjects
+import com.kmalbz.api.model.ApiObject
 import org.jetbrains.exposed.sql.ResultRow
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
 import java.time.LocalDate
 
 
 class ResultObjectService {
 
-    suspend fun getAllResultObjects(): List<ResultObject> = dbQuery {
+    fun addOne(apiObject: ApiObject) {
+        transaction {
+            ResultObject.new {
+                tag = apiObject.tag
+                date = apiObject.date.toString()
+                decision = apiObject.decision
+                confidence = apiObject.confidence
+            }
+        }
+    }
+
+    suspend fun getAllResultObjects(): List<ApiObject> = dbQuery {
         ResultObjects.selectAll().map { toResultObject(it) }
     }
 
-    suspend fun getResultObjectbyTag(tag: String): ResultObject? = dbQuery {
+    suspend fun getResultObjectbyTag(tag: String): ApiObject? = dbQuery {
         ResultObjects.select {
             (ResultObjects.tag eq tag)
         }.mapNotNull { toResultObject(it) }
             .singleOrNull()
     }
 
-    suspend fun getResultObjectbyDate(date: LocalDate): List<ResultObject>? = dbQuery {
+    suspend fun getResultObjectbyDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date eq date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjectbeforeDate(date: LocalDate): List<ResultObject>? = dbQuery {
+    suspend fun getResultObjectbeforeDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date less  date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjectafterDate(date: LocalDate): List<ResultObject>? = dbQuery {
+    suspend fun getResultObjectafterDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date greater  date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjectbyDecision(decision: Boolean): List<ResultObject>? = dbQuery {
+    suspend fun getResultObjectbyDecision(decision: Boolean): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.decision eq  decision)
         }.mapNotNull { toResultObject(it) }
     }
 
-    private fun toResultObject(row: ResultRow): ResultObject =
-        ResultObject(
-            id = row[ResultObjects.id],
+    private fun toResultObject(row: ResultRow): ApiObject =
+        ApiObject(
             tag = row[ResultObjects.tag],
             date = row[ResultObjects.date],
             decision = row[ResultObjects.decision],

src/mq/RecieveOutput.kt

@@ -0,0 +1,7 @@
+package com.kmalbz.mq
+
+class RecieveOutput {
+    companion object {
+        const val EXCHANGE_NAME = "output"
+    }
+}