first commit

src/main/kotlin/net/ipksindia/Application.kt

@@ -0,0 +1,16 @@
+package net.ipksindia
+
+import io.ktor.server.application.*
+import io.ktor.server.engine.*
+import io.ktor.server.netty.*
+import net.ipksindia.plugins.*
+
+fun main() {
+    embeddedServer(Netty, port = 8088, host = "0.0.0.0", module = Application::module)
+        .start(wait = true)
+}
+
+fun Application.module() {
+    configureSerialization()
+    configureRouting()
+}

src/main/kotlin/net/ipksindia/NeftRequestProcessor.kt

@@ -0,0 +1,80 @@
+package net.ipksindia
+
+import TransactionExecutor
+import TransactionFactory
+import dao.TellerDao
+import net.ipksindia.dao.TransactionDao
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import redis.clients.jedis.JedisPooled
+import response.TransactionSuccessResponse
+
+class NeftRequestProcessor {
+
+    companion object {
+        private val logger: Logger = LoggerFactory.getLogger(NeftRequestProcessor::class.java)
+        private const val PROCESSED_TRANSACTION_LIST = "ipks:processed_outward_transactions"
+        private val migratedDCCBCodes = listOf("0012")
+
+        fun process(transactionNumber: String): Pair<String, String>? {
+
+            val outwardTransaction = TransactionDao().getTransactionRequest(transactionNumber) ?: run {
+                logger.error("TXN: #{} FAILED REASON: Transaction not found", transactionNumber)
+                return null
+            }
+            logger.info("TXN: #{} FOUND", transactionNumber)
+            val jedis = JedisPooled("localhost", 6379)
+            val processedTransactionList = jedis.smembers(PROCESSED_TRANSACTION_LIST)
+            val dccbCode = outwardTransaction.dccbCode.padStart(4, '0')
+            if(dccbCode !in migratedDCCBCodes) {
+                logger.error("TXN: #{} FAILED REASON: DCCB Code not migrated", transactionNumber)
+                return null
+            }
+            val branchCode = outwardTransaction.branchCode.padStart(3, '0')
+            if (transactionNumber in processedTransactionList) {
+                logger.error("TXN: #{} FAILED REASON: Transaction already processed", transactionNumber)
+                return null
+            }
+            val makerTeller = TellerDao.getTeller(dccbCode, branchCode) ?: run {
+                logger.error("TXN: #{} FAILED REASON: Teller not found", transactionNumber)
+                return null
+            }
+            val transactionPair = TransactionFactory(outwardTransaction, makerTeller).createTransactionPair()
+            val (transferResponse, neftResponse) = try {
+                TransactionExecutor().executePair(transactionPair)
+            } catch (e: Exception) {
+                logger.error("TXN: #{} FAILED REASON: {}", transactionNumber, e.message)
+                return null
+            }
+
+            logger.info(
+                "TXN: #{} TRF_TXN: {} NEFT_TXN: {}",
+                transactionNumber,
+                transferResponse.status,
+                neftResponse.status
+            )
+
+            jedis.sadd(PROCESSED_TRANSACTION_LIST, outwardTransaction.transactionNumber)
+
+            if (transferResponse.status == "SUCCESS" && neftResponse.status == "SUCCESS") {
+                val transferQueueNumber = (transferResponse as TransactionSuccessResponse).response.queueId
+                val neftQueueNumber = (neftResponse as TransactionSuccessResponse).response.queueId
+                try {
+                    TransactionDao().updateSuccessTransaction(outwardTransaction, transferQueueNumber, neftQueueNumber)
+                    logger.info("TXN: #{} UPDATED RESULTS SUCCESSFULLY", transactionNumber)
+                } catch (e: Exception) {
+                    logger.error(
+                        "TXN: #{} QUEUE INITIATED BUT FAILED TO UPDATE RESULT: {}",
+                        transactionNumber,
+                        e.message
+                    )
+                }
+
+                return Pair(transferQueueNumber, neftQueueNumber)
+            } else {
+                logger.error("TXN: #{} QUEUE INITIATED BUT FAILED TO UPDATE RESULT", transactionNumber)
+                return null
+            }
+        }
+    }
+}

src/main/kotlin/net/ipksindia/TellerNotFoundException.kt

@@ -0,0 +1 @@
+class TellerNotFoundException(s: String) : Exception(s)

src/main/kotlin/net/ipksindia/TransactionExecutor.kt

@@ -0,0 +1,60 @@
+
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import model.NeftTransaction
+import model.TransferTransaction
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import response.TransactionFailureResponse
+import response.TransactionResponse
+import response.TransactionSuccessResponse
+import java.io.IOException
+
+
+class TransactionExecutor() {
+
+    private val protocol = "http"
+    private val host = "localhost"
+    private val port = "8080"
+    private val rootRoute = "WESTBANGAL/api"
+    private val remoteUrl = "$protocol://$host:$port/$rootRoute"
+
+    fun executePair(transactionPair: Pair<TransferTransaction, NeftTransaction>): Pair<TransactionResponse, TransactionResponse> {
+
+        val transferTransaction = transactionPair.first
+        val neftTransaction = transactionPair.second
+        val transferResponse = execute(Json.encodeToString(transferTransaction))
+        val neftResponse = execute(Json.encodeToString(neftTransaction))
+        return Pair(transferResponse, neftResponse)
+    }
+
+    private fun execute(postBody: String): TransactionResponse {
+        val transferRoute = "IPKSNeftRtgsApiTransfer"
+        val transferURL = "$remoteUrl/$transferRoute"
+        val jsonMediaType = "application/json; charset=utf-8".toMediaType()
+
+        val httpClient = OkHttpClient()
+
+        val request = Request.Builder()
+            .url(transferURL)
+            .post(postBody.toRequestBody(jsonMediaType))
+            .build()
+
+        val responseBody = httpClient.newCall(request).execute().use { response ->
+            if (!response.isSuccessful) {
+                throw IOException("Unexpected code $response")
+            }
+            response.body!!.string()
+        }
+
+        val response = if(responseBody.contains("SUCCESS")) {
+            Json.decodeFromString<TransactionSuccessResponse>(responseBody)
+        } else {
+            Json.decodeFromString<TransactionFailureResponse>(responseBody)
+        }
+        return response
+    }
+
+}

src/main/kotlin/net/ipksindia/TransactionFactory.kt

@@ -0,0 +1,67 @@
+
+import enums.TransactionType
+import model.NeftTransaction
+import model.Teller
+import model.TransactionRequest
+import model.TransferTransaction
+import java.time.format.DateTimeFormatter
+
+class TransactionFactory(private val transactionRequest: TransactionRequest, private val teller: Teller) {
+
+    private val date = transactionRequest.date.format(DateTimeFormatter.ofPattern("dd-MM-yyyy"))
+    private val rrn = transactionRequest.date.format(DateTimeFormatter.ofPattern("ddMM")) + transactionRequest.transactionNumber.takeLast(4)
+
+    private fun createTransferTransaction(): TransferTransaction {
+        return TransferTransaction(
+            bankCode = transactionRequest.dccbCode.padStart(4, '0'),
+            branchCode = transactionRequest.branchCode.padStart(3,'0'),
+            cbsTellerId = teller.tellerId,
+            cbsTellerUserIdType = teller.userType,
+            queIdType = "5",
+            description = "${TransactionType.TRANSFER.code}For Checking",
+            priority = "1",
+            cbsTellerCapability = teller.capability,
+            txnScreenNo = TransactionType.TRANSFER.code.padStart(6, '0'),
+            txnAmt = transactionRequest.amount,
+            txnDate = date,
+            sourceAcctNo = transactionRequest.pacsCurrentAccountNumber,
+            destinationAcctNo = transactionRequest.linkedCBSAccountNumber,
+            narration = "TRF to member A/C for NEFT RTGS",
+            sourceTxnNo = "1045",
+            sourceStat = "A/P",
+            apiType = "OUTWARD_QUEUE_POSTING",
+            remitterName = transactionRequest.remitterName,
+            rrn = rrn + "1"
+        )
+
+    }
+
+    private fun createNEFTTransaction(): NeftTransaction {
+        return NeftTransaction(
+            bankCode = transactionRequest.dccbCode,
+            branchCode = transactionRequest.branchCode.padStart(3,'0'),
+            cbsTellerId = teller.tellerId,
+            cbsTellerUserIdType = teller.userType,
+            queIdType = "5",
+            description = "${TransactionType.NEFT.code}For Checking",
+            priority = "1",
+            cbsTellerCapability = teller.capability,
+            txnScreenNo = TransactionType.NEFT.code.padStart(6, '0'),
+            txnAmt = transactionRequest.amount,
+            txnDate = date,
+            sourceAcctNo = transactionRequest.linkedCBSAccountNumber,
+            destinationAcctNo = transactionRequest.neftBeneficiaryAccountNumber,
+            narration = "TRF to member A/C for NEFT RTGS",
+            sourceTxnNo = TransactionType.NEFT.code,
+            sourceStat = "A/P",
+            apiType = "OUTWARD_QUEUE_POSTING",
+            remitterName = transactionRequest.remitterName,
+            ifscCode = transactionRequest.ifscCode,
+            rrn = rrn + "2"
+        )
+    }
+
+    fun createTransactionPair(): Pair<TransferTransaction, NeftTransaction> {
+        return Pair(createTransferTransaction(), createNEFTTransaction())
+    }
+}

src/main/kotlin/net/ipksindia/dao/TellerDao.kt

@@ -0,0 +1,46 @@
+package dao
+
+import model.Teller
+
+class TellerDao {
+    companion object {
+        private val tellerMap = mapOf(
+            "0016" to mapOf(
+                "008"  to "118"
+            ),
+            "0012" to mapOf(
+                "008" to "8",
+                "022" to "22",
+                "012" to "12",
+                "014" to "14",
+                "003" to "1003",
+                "015" to "15",
+                "013" to "13",
+                "018" to "18",
+                "001" to "1001",
+                "004" to "4",
+                "017" to "1234",
+                "005" to "5",
+                "011" to "11",
+                "020" to "1234",
+                "021" to "1234",
+                "016" to "016",
+                "009" to "9",
+                "010" to "10",
+                "007" to "7",
+                "006" to "6"
+            )
+
+        )
+        fun getTeller(dccbCode: String, branchCode: String): Teller? {
+            val branchList = tellerMap[dccbCode] ?: return null
+            val tellerId = branchList[branchCode] ?: return null
+            val teller = Teller(
+                tellerId,
+                dccbCode,
+                branchCode
+            )
+            return teller
+        }
+    }
+}

src/main/kotlin/net/ipksindia/dao/TransactionDao.kt

@@ -0,0 +1,216 @@
+package net.ipksindia.dao
+
+import model.TransactionRequest
+import java.sql.Date
+import java.sql.DriverManager
+import java.sql.ResultSet
+import java.util.*
+
+class TransactionDao {
+    private val transactionRequestQuery = """
+        SELECT 
+            txn_no,
+            TRIM(src_ac_no) AS src_ac_no,
+            TRIM(dest_ac_no) AS dest_ac_no,
+            ifsc_code,
+            txn_amt,
+            txn_date,
+            t.teller_id,
+            CASE
+                WHEN t.ifsc_code LIKE 'WBSC%' THEN 'FAILED'
+                ELSE 'RECEIVED'
+            END AS status,
+            SUBSTR(REGEXP_REPLACE(REGEXP_REPLACE(UPPER(beneficiary_name), '[^A-Z0-9 ]', ''), ' {2,}', ' '), 1, 35) AS beneficiary_name,
+            beneficiary_add,
+            t.pacs_id,
+            comm_txn_no,
+            comm_txn_amt,
+            dccb_code,
+            TO_NUMBER(cbs_br_code) AS br_code,
+            SUBSTR(REGEXP_REPLACE(REGEXP_REPLACE(UPPER(remm_name), '[^A-Z0-9 ]', ''), ' {2,}', ' '),1,35) AS remitter_name,
+            ipks_accno AS pacs_acc_no,
+            da.link_accno AS cbs_sb_acc_no,
+            'pacs_db' AS db_name
+        FROM neft_rtgs_txn t
+            JOIN dep_account da ON t.ipks_accno = da.key_1
+        WHERE 
+            t.txn_date = (SELECT system_date FROM system_date)
+            AND t.STATUS = 'A'
+            AND t.bank_channel = 'SCB'
+            AND da.link_accno IS NOT NULL
+    """.trimIndent()
+
+    private val singleTransactionRequestQuery = """
+       SELECT 
+            txn_no,
+            TRIM(src_ac_no) AS src_ac_no,
+            TRIM(dest_ac_no) AS dest_ac_no,
+            ifsc_code,
+            txn_amt,
+            txn_date,
+            t.teller_id,
+            CASE
+                WHEN t.ifsc_code LIKE 'WBSC%' THEN 'FAILED'
+                ELSE 'RECEIVED'
+            END AS status,
+            SUBSTR(REGEXP_REPLACE(REGEXP_REPLACE(UPPER(beneficiary_name), '[^A-Z0-9 ]', ''), ' {2,}', ' '), 1, 35) AS beneficiary_name,
+            beneficiary_add,
+            t.pacs_id,
+            comm_txn_no,
+            comm_txn_amt,
+            dccb_code,
+            TO_NUMBER(cbs_br_code) AS br_code,
+            SUBSTR(REGEXP_REPLACE(REGEXP_REPLACE(UPPER(remm_name), '[^A-Z0-9 ]', ''), ' {2,}', ' '),1,35) AS remitter_name,
+            ipks_accno AS pacs_acc_no,
+            da.link_accno AS cbs_sb_acc_no,
+            'pacs_db' AS db_name
+        FROM neft_rtgs_txn t
+            JOIN dep_account da ON t.ipks_accno = da.key_1
+        WHERE 
+            t.txn_no = ?
+    """.trimIndent()
+
+    private val transactionUpdateQuery = """
+        INSERT INTO neft_rtgs_txn_queue (
+            txn_no,
+            src_ac_no,
+            dest_ac_no,
+            ifsc_code,
+            txn_amt,
+            txn_date,
+            teller_id,
+            status,
+            beneficiary_name,
+            beneficiary_add,
+            pacs_id,
+            comm_txn_no,
+            comm_txn_amt,
+            dccb_code,
+            br_code,
+            remitter_name,
+            cbs_queue_no,
+            pacs_acc_no,
+            cbs_queue_no2
+        ) VALUES (
+            ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?
+        )
+    """.trimIndent()
+
+    fun updateSuccessTransaction(request: TransactionRequest, transferQueueNumber: String, neftQueueNumber: String) {
+        val dbUrl = getDatabaseUrl()
+        val (dbUser, dbPassword) = getUserCredentials()
+
+        DriverManager.getConnection(dbUrl, dbUser, dbPassword).use { connection ->
+            connection.prepareStatement(transactionUpdateQuery).also {
+                it.setString(1, request.transactionNumber)
+                it.setString(2, request.pacsCurrentAccountNumber)
+                it.setString(3, request.neftBeneficiaryAccountNumber)
+                it.setString(4, request.ifscCode)
+                it.setString(5, request.amount)
+                it.setDate(6, Date.valueOf(request.date))
+                it.setString(7, request.tellerId)
+                it.setString(8, "PROCESSED")
+                it.setString(9, request.beneficiaryName)
+                it.setString(10, request.beneficiaryAddress)
+                it.setString(11, request.pacsId)
+                it.setString(12, request.commissionTransactionNumber)
+                it.setString(13, request.commissionAmount)
+                it.setString(14, request.dccbCode)
+                it.setString(15, request.branchCode)
+                it.setString(16, request.remitterName)
+                it.setString(17, transferQueueNumber)
+                it.setString(18, request.pacsAccountNumber)
+                it.setString(19, neftQueueNumber)
+            }.use {
+                it.executeUpdate()
+            }
+
+        }
+    }
+    fun getTransactionRequests(): List<TransactionRequest> {
+
+        val transactionList: List<TransactionRequest>
+        val dbUrl = getDatabaseUrl()
+        val (dbUser, dbPassword) = getUserCredentials()
+
+        DriverManager.getConnection(dbUrl, dbUser, dbPassword).use { connection ->
+            connection.prepareStatement(transactionRequestQuery).executeQuery().use {
+                transactionList = mapToObject(it)
+            }
+        }
+
+        return transactionList
+    }
+    fun getTransactionRequest(transactionNumber: String): TransactionRequest? {
+        val dbUrl = getDatabaseUrl()
+        val (dbUser, dbPassword) = getUserCredentials()
+
+        return DriverManager.getConnection(dbUrl, dbUser, dbPassword).use { connection ->
+            connection.prepareStatement(singleTransactionRequestQuery).apply {
+                setString(1, transactionNumber)
+            }.executeQuery().use {
+                mapToObject(it).firstOrNull()
+            }
+        }
+    }
+    private fun getDatabaseUrl(): String {
+        val prop = loadProp()
+
+        val dbHost = getProp(prop, "DB_HOST")
+        val dbPort = getProp(prop, "DB_PORT")
+        val dbName = getProp(prop, "DB_NAME")
+
+        return "jdbc:oracle:thin:@$dbHost:$dbPort:$dbName"
+    }
+
+    private fun getUserCredentials(): Pair<String, String> {
+        val prop = loadProp()
+
+        val dbUser = getProp(prop, "DB_USER")
+        val dbPassword = getProp(prop, "DB_PASSWORD")
+
+        return Pair(dbUser, dbPassword)
+    }
+
+    private fun loadProp(): Properties {
+
+        val props = javaClass.classLoader.getResourceAsStream("application.properties").use {
+            Properties().apply { load(it) }
+        }
+        return props
+    }
+
+    private fun getProp(prop: Properties, key: String): String {
+        return prop.getProperty(key) ?: throw RuntimeException("property $prop not found")
+    }
+
+    private fun mapToObject(rs: ResultSet): List<TransactionRequest> {
+        val list = mutableListOf<TransactionRequest>()
+        while (rs.next()) {
+            val transactionRequest = TransactionRequest(
+                transactionNumber = rs.getString("txn_no"),
+                pacsCurrentAccountNumber = rs.getString("src_ac_no"),
+                neftBeneficiaryAccountNumber = rs.getString("dest_ac_no"),
+                ifscCode = rs.getString("ifsc_code"),
+                amount = rs.getString("txn_amt"),
+                date = rs.getDate("txn_date").toLocalDate(),
+                tellerId = rs.getString("teller_id"),
+                status = rs.getString("status"),
+                beneficiaryName = rs.getString("beneficiary_name"),
+                beneficiaryAddress = rs.getString("beneficiary_add"),
+                pacsId = rs.getString("pacs_id"),
+                commissionTransactionNumber = rs.getString("comm_txn_no"),
+                commissionAmount = rs.getString("comm_txn_amt"),
+                dccbCode = rs.getString("dccb_code"),
+                branchCode = rs.getString("br_Code"),
+                remitterName = rs.getString("remitter_name"),
+                pacsAccountNumber = rs.getString("pacs_acc_no"),
+                linkedCBSAccountNumber = rs.getString("cbs_sb_acc_no"),
+            )
+            list.add(transactionRequest)
+        }
+        return list
+    }
+
+
+}

src/main/kotlin/net/ipksindia/enums/TransactionType.kt

@@ -0,0 +1,7 @@
+package enums
+
+enum class TransactionType(val code: String) {
+    TRANSFER("01045"),
+    NEFT("20066"),
+    RTGS("20035")
+}

src/main/kotlin/net/ipksindia/model/NeftTransaction.kt

@@ -0,0 +1,30 @@
+package model
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
+import org.ipks.model.Transaction
+
+@Serializable
+class NeftTransaction(
+    override val bankCode: String,
+    override val branchCode: String,
+    override val cbsTellerId: String,
+    override val cbsTellerUserIdType: String,
+    override val queIdType: String,
+    override val description: String,
+    override val priority: String,
+    override val cbsTellerCapability: String,
+    override val txnScreenNo: String,
+    override val txnAmt: String,
+    override val txnDate: String,
+    override val sourceAcctNo: String,
+    override val destinationAcctNo: String,
+    override val narration: String,
+    override val sourceTxnNo: String,
+    override val sourceStat: String,
+    override val apiType: String,
+    override val remitterName: String,
+    val ifscCode: String,
+    override val rrn: String,
+    @Transient override var queueNo: String = ""
+) : Transaction

src/main/kotlin/net/ipksindia/model/OutwardNeftRequest.kt

@@ -0,0 +1,8 @@
+package net.ipksindia.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class OutwardNeftRequest(
+    val transactionNumber: String
+)

src/main/kotlin/net/ipksindia/model/Teller.kt

@@ -0,0 +1,10 @@
+package model
+
+data class Teller(
+    val tellerId: String,
+    val password: String,
+    val branch: String,
+    val dccbCode: String = "",
+    val userType: String = "50",
+    val capability: String = "9"
+)

src/main/kotlin/net/ipksindia/model/Transaction.kt

@@ -0,0 +1,24 @@
+package org.ipks.model
+
+interface Transaction {
+    val bankCode: String
+    val branchCode: String
+    val cbsTellerId: String
+    val cbsTellerUserIdType: String
+    val queIdType: String
+    val description: String
+    val priority: String
+    val cbsTellerCapability: String
+    val txnScreenNo: String
+    val txnAmt: String
+    val txnDate: String
+    val sourceAcctNo: String
+    val destinationAcctNo: String
+    val narration: String
+    val sourceTxnNo: String
+    val sourceStat: String
+    val apiType: String
+    val remitterName: String
+    val rrn: String
+    val queueNo: String?
+}

src/main/kotlin/net/ipksindia/model/TransactionRequest.kt

@@ -0,0 +1,26 @@
+package model
+
+import java.time.LocalDate
+
+
+data class TransactionRequest(
+    val transactionNumber: String,
+    val pacsCurrentAccountNumber: String,
+    val neftBeneficiaryAccountNumber: String,
+    val ifscCode: String,
+    val amount: String,
+    val date: LocalDate,
+    val tellerId: String,
+    val status: String,
+    val beneficiaryName: String,
+    val beneficiaryAddress: String?,
+    val pacsId: String,
+    val commissionTransactionNumber: String?,
+    val commissionAmount: String?,
+    val dccbCode: String,
+    val branchCode: String,
+    val remitterName: String,
+    val pacsAccountNumber: String,
+    val linkedCBSAccountNumber: String
+)
+

src/main/kotlin/net/ipksindia/model/TransferTransaction.kt

@@ -0,0 +1,29 @@
+package model
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
+import org.ipks.model.Transaction
+
+@Serializable
+class TransferTransaction(
+    override val bankCode: String,
+    override val branchCode: String,
+    override val cbsTellerId: String,
+    override val cbsTellerUserIdType: String,
+    override val queIdType: String,
+    override val description: String,
+    override val priority: String,
+    override val cbsTellerCapability: String,
+    override val txnScreenNo: String,
+    override val txnAmt: String,
+    override val txnDate: String,
+    override val sourceAcctNo: String,
+    override val destinationAcctNo: String,
+    override val narration: String,
+    override val sourceTxnNo: String,
+    override val sourceStat: String,
+    override val apiType: String,
+    override val remitterName: String,
+    override val rrn: String,
+    @Transient override var queueNo: String = ""
+) : Transaction

src/main/kotlin/net/ipksindia/plugins/Routing.kt

@@ -0,0 +1,19 @@
+package net.ipksindia.plugins
+
+import io.ktor.server.application.*
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import net.ipksindia.NeftRequestProcessor
+import net.ipksindia.model.OutwardNeftRequest
+
+fun Application.configureRouting() {
+    routing {
+        post("/neftOutward") {
+            val neftRequest = call.receive<OutwardNeftRequest>()
+            val transactionNumber = neftRequest.transactionNumber
+            val response = NeftRequestProcessor.process(transactionNumber) ?: Pair("500", "Error doing outward neft" )
+            call.respond("${response.first}\n${response.second}")
+        }
+    }
+}

src/main/kotlin/net/ipksindia/plugins/Serialization.kt

@@ -0,0 +1,18 @@
+package net.ipksindia.plugins
+
+import io.ktor.serialization.kotlinx.json.*
+import io.ktor.server.application.*
+import io.ktor.server.plugins.contentnegotiation.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+fun Application.configureSerialization() {
+    install(ContentNegotiation) {
+        json()
+    }
+    routing {
+        get("/json/kotlinx-serialization") {
+            call.respond(mapOf("hello" to "world"))
+        }
+    }
+}

src/main/kotlin/net/ipksindia/response/ResponseData.kt

@@ -0,0 +1,16 @@
+package response
+
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class ResponseData (
+    val transactionDate: Int,
+    val sourceStat: String,
+    val journalId: Int,
+    val queueId: String,
+    val error: Int,
+    val apiType: String,
+    val errorMsg: String,
+    val txnScreenNo: Int
+)

src/main/kotlin/net/ipksindia/response/TransactionFailureResponse.kt

@@ -0,0 +1,12 @@
+package response
+
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class TransactionFailureResponse(
+    override val status: String,
+    override val message: String,
+    val response: String,
+    override val error: Int
+): TransactionResponse

src/main/kotlin/net/ipksindia/response/TransactionResponse.kt

@@ -0,0 +1,7 @@
+package response
+
+interface TransactionResponse {
+    val status: String
+    val message: String
+    val error: Int
+}

src/main/kotlin/net/ipksindia/response/TransactionSuccessResponse.kt

@@ -0,0 +1,11 @@
+package response
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class TransactionSuccessResponse(
+    override val status: String,
+    override val message: String,
+    val response: ResponseData,
+    override val error: Int
+): TransactionResponse

src/main/resources/application.properties

@@ -0,0 +1,5 @@
+DB_NAME=IPKSDB
+DB_HOST=localhost
+DB_PORT=1521
+DB_USER=pacs_db
+DB_PASSWORD=pacs_db

src/main/resources/logback.xml

@@ -0,0 +1,12 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+    <root level="trace">
+        <appender-ref ref="STDOUT"/>
+    </root>
+    <logger name="org.eclipse.jetty" level="INFO"/>
+    <logger name="io.netty" level="INFO"/>
+</configuration>

src/test/kotlin/net/ipksindia/ApplicationTest.kt

@@ -0,0 +1,21 @@
+package net.ipksindia
+
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.server.testing.*
+import kotlin.test.*
+import net.ipksindia.plugins.*
+
+class ApplicationTest {
+    @Test
+    fun testRoot() = testApplication {
+        application {
+            configureRouting()
+        }
+        client.get("/").apply {
+            assertEquals(HttpStatusCode.OK, status)
+            assertEquals("Hello World!", bodyAsText())
+        }
+    }
+}