use fancy di

src/Application.kt

@@ -23,6 +23,7 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import org.jetbrains.exposed.sql.SchemaUtils
 import org.jetbrains.exposed.sql.transactions.transaction
+import org.koin.ktor.ext.Koin
 
 fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)
 
@@ -33,13 +34,16 @@ fun Application.module() {
         gson {
         }
     }
+    install(Koin) {
+        printLogger()
+        modules(com.kmalbz.di.injectionModule)
+    }
 
     DatabaseFactory.init()
     transaction{
         SchemaUtils.create(ResultObjects)
     }
 
-
     val appConfig = HoconApplicationConfig(ConfigFactory.load())
     val factory = ConnectionFactory()
     factory.host = appConfig.property("ktor.mq.host").getString()
@@ -72,14 +76,6 @@ fun Application.module() {
 
     routing {
         install(StatusPages) {
-            exception<AuthenticationException> {
-                call.respond(HttpStatusCode.Unauthorized)
-            }
-
-            exception<AuthorizationException> {
-                call.respond(HttpStatusCode.Forbidden)
-            }
-
             exception<HttpException> {
                 call.respond(HttpStatusCode.BadRequest)
             }

src/api/route/OutputServiceRDBServer.kt

@@ -1,10 +1,12 @@
 package com.kmalbz.api.route
 
-import io.ktor.application.*
-import io.ktor.response.*
-import io.ktor.routing.*
-import io.ktor.http.*
-import com.kmalbz.database.service.ResultObjectService
+import com.kmalbz.database.service.IResultObjectService
+import io.ktor.application.call
+import io.ktor.http.HttpStatusCode
+import io.ktor.response.respond
+import io.ktor.routing.Routing
+import io.ktor.routing.get
+import org.koin.ktor.ext.inject
 import java.time.LocalDate
 import java.time.format.DateTimeFormatter
 
@@ -17,8 +19,8 @@ class OutputServiceRDBServer {
     /**
      * output
      */
-    private val resultObjectService = ResultObjectService()
     fun Routing.registerOutput() {
+        val resultObjectService by inject<IResultObjectService>()
         get("/output"){
             call.respond(resultObjectService.getAllResultObjects())
         }

src/database/service/IResultObjectService.kt

@@ -0,0 +1,16 @@
+package com.kmalbz.database.service
+
+import com.kmalbz.api.model.ApiObject
+import java.time.LocalDate
+
+interface IResultObjectService{
+    fun addOne(apiObject: ApiObject)
+    suspend fun getAllResultObjects(): List<ApiObject>
+    suspend fun getResultObjectbyTag(tag: String): ApiObject?
+    suspend fun getResultObjectbyDate(date: LocalDate): List<ApiObject>?
+    suspend fun getResultObjectbeforeDate(date: LocalDate): List<ApiObject>?
+    suspend fun getResultObjectafterDate(date: LocalDate): List<ApiObject>?
+    suspend fun getResultObjecGreaterthanProbability(probability: Double): List<ApiObject>?
+    suspend fun getResultObjecLessthanProbability(probability: Double): List<ApiObject>?
+    suspend fun getResultObjecEqualsProbability(probability: Double): List<ApiObject>?
+}

src/database/service/ResultObjectService.kt

@@ -11,9 +11,9 @@ import org.jetbrains.exposed.sql.transactions.transaction
 import java.time.LocalDate
 
 
-class ResultObjectService {
+class ResultObjectService : IResultObjectService {
 
-    fun addOne(apiObject: ApiObject) {
+    override fun addOne(apiObject: ApiObject) {
         transaction {
             ResultObject.new {
                 tag = apiObject.tag
@@ -22,48 +22,48 @@ class ResultObjectService {
         }
     }
 
-    suspend fun getAllResultObjects(): List<ApiObject> = dbQuery {
+    override suspend fun getAllResultObjects(): List<ApiObject> = dbQuery {
         ResultObjects.selectAll().map { toResultObject(it) }
     }
 
-    suspend fun getResultObjectbyTag(tag: String): ApiObject? = dbQuery {
+    override suspend fun getResultObjectbyTag(tag: String): ApiObject? = dbQuery {
         ResultObjects.select {
             (ResultObjects.tag eq tag)
         }.mapNotNull { toResultObject(it) }
             .singleOrNull()
     }
 
-    suspend fun getResultObjectbyDate(date: LocalDate): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjectbyDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date eq date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjectbeforeDate(date: LocalDate): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjectbeforeDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date less  date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjectafterDate(date: LocalDate): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjectafterDate(date: LocalDate): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.date greater  date)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjecGreaterthanProbability(probability: Double): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjecGreaterthanProbability(probability: Double): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.probability greater  probability)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjecLessthanProbability(probability: Double): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjecLessthanProbability(probability: Double): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.probability less  probability)
         }.mapNotNull { toResultObject(it) }
     }
 
-    suspend fun getResultObjecEqualsProbability(probability: Double): List<ApiObject>? = dbQuery {
+    override suspend fun getResultObjecEqualsProbability(probability: Double): List<ApiObject>? = dbQuery {
         ResultObjects.select {
             (ResultObjects.probability eq  probability)
         }.mapNotNull { toResultObject(it) }

src/di/InjectionModule.kt

@@ -0,0 +1,10 @@
+package com.kmalbz.di
+
+import com.kmalbz.database.service.IResultObjectService
+import com.kmalbz.database.service.ResultObjectService
+import org.koin.dsl.module
+import org.koin.experimental.builder.singleBy
+
+val injectionModule = module(createdAtStart = true) {
+    singleBy<IResultObjectService,ResultObjectService>()
+}