From 4fc8db6fa4e894dab3ccc1c57da166313f7304b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Torma=20Krist=C3=B3f?= Date: Wed, 18 Aug 2021 16:44:29 +0200 Subject: [PATCH] use kotlin serialize --- build.gradle | 10 ++++++++- src/Application.kt | 5 ++--- src/api/model/ApiObject.kt | 8 +++---- src/api/route/OutputServiceRDBServer.kt | 22 ++++++++------------ src/database/dao/ResultObjects.kt | 6 +++--- src/database/service/IResultObjectService.kt | 15 +++++++------ src/database/service/ResultObjectService.kt | 22 ++++++++++---------- 7 files changed, 45 insertions(+), 43 deletions(-) diff --git a/build.gradle b/build.gradle index a276ab4..b764ad3 100644 --- a/build.gradle +++ b/build.gradle @@ -7,15 +7,21 @@ buildscript { dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" classpath "com.github.jengelman.gradle.plugins:shadow:5.2.0" + classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version" } } +plugins { + id 'org.jetbrains.kotlin.plugin.serialization' version '1.5.21' +} + tasks.withType(JavaCompile) { sourceCompatibility = JavaVersion.VERSION_11 targetCompatibility = JavaVersion.VERSION_11 } apply plugin: 'kotlin' +apply plugin: 'kotlinx-serialization' apply plugin: "com.github.johnrengelman.shadow" apply plugin: 'application' @@ -43,13 +49,15 @@ dependencies { compile 'org.jetbrains.exposed:exposed-jdbc:0.33.1' compile 'org.jetbrains.exposed:exposed-java-time:0.33.1' compile 'com.zaxxer:HikariCP:5.0.0' + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2" + implementation "org.jetbrains.kotlinx:kotlinx-datetime:0.2.1" implementation "io.insert-koin:koin-core:$koin_version" implementation "io.insert-koin:koin-ktor:$koin_version" + implementation "io.ktor:ktor-serialization:$ktor_version" implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation "io.ktor:ktor-server-netty:$ktor_version" implementation "ch.qos.logback:logback-classic:$logback_version" implementation "io.ktor:ktor-server-core:$ktor_version" - implementation "io.ktor:ktor-gson:$ktor_version" implementation "io.ktor:ktor-server-host-common:$ktor_version" implementation "io.ktor:ktor-client-core:$ktor_version" implementation "io.ktor:ktor-client-core-jvm:$ktor_version" diff --git a/src/Application.kt b/src/Application.kt index d2e55dc..2086bbf 100644 --- a/src/Application.kt +++ b/src/Application.kt @@ -5,11 +5,11 @@ import io.ktor.application.* import io.ktor.response.* import io.ktor.routing.* import io.ktor.http.* -import io.ktor.gson.* import io.ktor.features.* import org.apache.http.HttpException import com.kmalbz.database.DatabaseFactory import com.kmalbz.database.dao.ResultObjects +import io.ktor.serialization.* import io.ktor.util.KtorExperimentalAPI import org.jetbrains.exposed.sql.SchemaUtils import org.jetbrains.exposed.sql.transactions.transaction @@ -21,8 +21,7 @@ fun main(args: Array): Unit = io.ktor.server.netty.EngineMain.main(args) @Suppress("unused") // Referenced in application.conf fun Application.module() { install(ContentNegotiation) { - gson { - } + json() } install(Koin) { diff --git a/src/api/model/ApiObject.kt b/src/api/model/ApiObject.kt index 697971f..d21f6a7 100644 --- a/src/api/model/ApiObject.kt +++ b/src/api/model/ApiObject.kt @@ -1,9 +1,9 @@ package com.kmalbz.api.model -import com.google.gson.annotations.SerializedName -import java.util.* +import kotlinx.serialization.Serializable +@Serializable data class ApiObject( - @SerializedName("tag") val tag: String, - @SerializedName("probability") val probability: Double + val tag: String, + val probability: Double ) \ No newline at end of file diff --git a/src/api/route/OutputServiceRDBServer.kt b/src/api/route/OutputServiceRDBServer.kt index fae21a9..400cd13 100644 --- a/src/api/route/OutputServiceRDBServer.kt +++ b/src/api/route/OutputServiceRDBServer.kt @@ -6,11 +6,9 @@ import io.ktor.http.HttpStatusCode import io.ktor.response.respond import io.ktor.routing.Routing import io.ktor.routing.get +import kotlinx.datetime.LocalDateTime import org.koin.ktor.ext.inject -import java.time.LocalDate -import java.time.format.DateTimeFormatter -import kotlin.math.ceil -import kotlin.math.roundToInt + /** * Output Service - RDB @@ -40,41 +38,39 @@ class OutputServiceRDBServer { get("/output/filter/negative") { val resultList = - resultObjectService.getResultObjecLessthanProbability(0.5) ?: call.respond(HttpStatusCode.NotFound) + resultObjectService.getResultObjecLessthanProbability(0.5) call.respond(resultList) } get("/output/filter/positive") { val resultList = - resultObjectService.getResultObjecGreaterthanProbability(0.5) ?: call.respond(HttpStatusCode.NotFound) + resultObjectService.getResultObjecGreaterthanProbability(0.5) call.respond(resultList) } get("/output/filter/undecided") { val resultList = - resultObjectService.getResultObjecEqualsProbability(0.5) ?: call.respond(HttpStatusCode.NotFound) + resultObjectService.getResultObjecEqualsProbability(0.5) call.respond(resultList) } get("/output/after/{dateAfter}") { val dateAfter = call.parameters["dateAfter"] ?: error(HttpStatusCode.NotAcceptable) - val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE - val localDateAfter: LocalDate = LocalDate.parse(dateAfter, dateTimeFormatter) + val localDateAfter: LocalDateTime = LocalDateTime.parse(dateAfter) val resultList = - resultObjectService.getResultObjectafterDate(localDateAfter) ?: call.respond(HttpStatusCode.NotFound) + resultObjectService.getResultObjectafterDate(localDateAfter) call.respond(resultList) } get("/output/before/{dateBefore}") { val dateAfter = call.parameters["dateBefore"] ?: error(HttpStatusCode.NotAcceptable) - val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE - val localDateBefore: LocalDate = LocalDate.parse(dateAfter, dateTimeFormatter) + val localDateBefore: LocalDateTime = LocalDateTime.parse(dateAfter) val resultList = - resultObjectService.getResultObjectbeforeDate(localDateBefore) ?: call.respond(HttpStatusCode.NotFound) + resultObjectService.getResultObjectbeforeDate(localDateBefore) call.respond(resultList) } diff --git a/src/database/dao/ResultObjects.kt b/src/database/dao/ResultObjects.kt index 6bbebf7..2a74720 100644 --- a/src/database/dao/ResultObjects.kt +++ b/src/database/dao/ResultObjects.kt @@ -2,12 +2,12 @@ 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 +import org.jetbrains.exposed.sql.`java-time`.datetime +import java.time.LocalDateTime object ResultObjects : IntIdTable() { val tag: Column = varchar("tag", 32) - val date: Column = date("date").default(LocalDate.now()) + val date: Column = datetime("date").default(LocalDateTime.now()) val probability: Column = double("probability") override val primaryKey = PrimaryKey(id, name = "PK_ResultObject_Id") } \ No newline at end of file diff --git a/src/database/service/IResultObjectService.kt b/src/database/service/IResultObjectService.kt index 535ac09..a451f25 100644 --- a/src/database/service/IResultObjectService.kt +++ b/src/database/service/IResultObjectService.kt @@ -1,8 +1,7 @@ package com.kmalbz.database.service import com.kmalbz.api.model.ApiObject -import java.time.LocalDate -import java.util.* +import kotlinx.datetime.LocalDateTime interface IResultObjectService{ fun addOne(apiObject: ApiObject) @@ -10,10 +9,10 @@ interface IResultObjectService{ suspend fun getCount(): Long suspend fun getPage(page: Long): List suspend fun getResultObjectbyTag(tag: String): ApiObject? - suspend fun getResultObjectbyDate(date: LocalDate): List? - suspend fun getResultObjectbeforeDate(date: LocalDate): List? - suspend fun getResultObjectafterDate(date: LocalDate): List? - suspend fun getResultObjecGreaterthanProbability(probability: Double): List? - suspend fun getResultObjecLessthanProbability(probability: Double): List? - suspend fun getResultObjecEqualsProbability(probability: Double): List? + suspend fun getResultObjectbyDate(date: LocalDateTime): List + suspend fun getResultObjectbeforeDate(date: LocalDateTime): List + suspend fun getResultObjectafterDate(date: LocalDateTime): List + suspend fun getResultObjecGreaterthanProbability(probability: Double): List + suspend fun getResultObjecLessthanProbability(probability: Double): List + suspend fun getResultObjecEqualsProbability(probability: Double): List } \ No newline at end of file diff --git a/src/database/service/ResultObjectService.kt b/src/database/service/ResultObjectService.kt index 97ede98..6079758 100644 --- a/src/database/service/ResultObjectService.kt +++ b/src/database/service/ResultObjectService.kt @@ -4,12 +4,12 @@ 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 kotlinx.datetime.LocalDateTime +import kotlinx.datetime.toJavaLocalDateTime 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 -import java.util.* class ResultObjectService : IResultObjectService { @@ -42,37 +42,37 @@ class ResultObjectService : IResultObjectService { .singleOrNull() } - override suspend fun getResultObjectbyDate(date: LocalDate): List? = dbQuery { + override suspend fun getResultObjectbyDate(date: LocalDateTime): List = dbQuery { ResultObjects.select { - (ResultObjects.date eq date) + (ResultObjects.date eq date.toJavaLocalDateTime()) }.mapNotNull { toResultObject(it) } } - override suspend fun getResultObjectbeforeDate(date: LocalDate): List? = dbQuery { + override suspend fun getResultObjectbeforeDate(date: LocalDateTime): List = dbQuery { ResultObjects.select { - (ResultObjects.date less date) + (ResultObjects.date less date.toJavaLocalDateTime()) }.mapNotNull { toResultObject(it) } } - override suspend fun getResultObjectafterDate(date: LocalDate): List? = dbQuery { + override suspend fun getResultObjectafterDate(date: LocalDateTime): List = dbQuery { ResultObjects.select { - (ResultObjects.date greater date) + (ResultObjects.date greater date.toJavaLocalDateTime()) }.mapNotNull { toResultObject(it) } } - override suspend fun getResultObjecGreaterthanProbability(probability: Double): List? = dbQuery { + override suspend fun getResultObjecGreaterthanProbability(probability: Double): List = dbQuery { ResultObjects.select { (ResultObjects.probability greater probability) }.mapNotNull { toResultObject(it) } } - override suspend fun getResultObjecLessthanProbability(probability: Double): List? = dbQuery { + override suspend fun getResultObjecLessthanProbability(probability: Double): List = dbQuery { ResultObjects.select { (ResultObjects.probability less probability) }.mapNotNull { toResultObject(it) } } - override suspend fun getResultObjecEqualsProbability(probability: Double): List? = dbQuery { + override suspend fun getResultObjecEqualsProbability(probability: Double): List = dbQuery { ResultObjects.select { (ResultObjects.probability eq probability) }.mapNotNull { toResultObject(it) }