/movimenti

implementazione endpoint per il recupero dei movimenti legati ad una tessera

settings.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
     id("org.gradle.toolchains.foojay-resolver-convention") version "0.5.0"
 }
-rootProject.name = "Backend_API"
+rootProject.name = "Backend_API_DSU"
 

src/main/kotlin/eu/maiora/db/Mapping.kt

@@ -1,15 +1,22 @@
 package eu.maiora.db
 
-import com.fasterxml.jackson.databind.deser.impl.CreatorCandidate.Param
 import eu.maiora.model.Accounts
+import eu.maiora.model.Movimenti
 import eu.maiora.model.Parametri
+import eu.maiora.model.Tessere
 import kotlinx.coroutines.Dispatchers
 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.LongEntity
+import org.jetbrains.exposed.dao.LongEntityClass
 import org.jetbrains.exposed.dao.id.EntityID
 import org.jetbrains.exposed.dao.id.IdTable
 import org.jetbrains.exposed.sql.Transaction
+import org.jetbrains.exposed.sql.javatime.datetime
 import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
+import java.time.format.DateTimeFormatter
+
+
 
 object AccountsTable : IdTable<Int>("accounts"){
     override val id = integer("id").entityId()
@@ -27,6 +34,34 @@ object ParametriTable : IdTable<Int>("parametri"){
     override val primaryKey = PrimaryKey(id)
 }
 
+object TessereTable : IdTable<Long>("view_tessere_api"){
+    override val id = long("id").entityId()
+    val idUtente = long("id_utente")
+    val codiceFiscale = varchar("codice_fiscale", 255)
+    val numero = varchar("numero", 255)
+    val saldo = double("saldo")
+    val punti = integer("punti")
+
+    override val primaryKey = PrimaryKey(id)
+}
+
+object MovimentiTable : IdTable<Long>("view_movimenti_api"){
+    override val id = long("id").entityId()
+    val idTessera = long("id_tessera")
+    val numero = varchar("numero_tessera", 255)
+    val operazione = varchar("operazione", 255)
+    val dataMovimento = datetime("data_movimento")
+    val transazione = varchar("transazione", 255)
+    val dispositivo = varchar("dispositivo", 255)
+    val riferimento= varchar("riferimento", 255)
+    val saldoPre = double("saldo_pre")
+    val importo = double("importo")
+    val saldoPost = double("saldo_post")
+    val puntiPre = integer("punti_pre")
+    val punti = integer("punti")
+    val puntiPost = integer("punti_post")
+}
+
 class AccountsDAO(id: EntityID<Int>) :IntEntity(id) {
     companion object : IntEntityClass<AccountsDAO>(AccountsTable)
 
@@ -41,6 +76,34 @@ class ParametriDAO(id: EntityID<Int>) :IntEntity(id) {
     var valore by ParametriTable.valore
 }
 
+class TessereDao(id: EntityID<Long>) :LongEntity(id) {
+    companion object : LongEntityClass<TessereDao>(TessereTable)
+
+    var idUtente by TessereTable.idUtente
+    var codiceFiscale by TessereTable.codiceFiscale
+    var numero by TessereTable.numero
+    var saldo by TessereTable.saldo
+    var punti by TessereTable.punti
+}
+
+class MovimentiDao(id: EntityID<Long>) :LongEntity(id) {
+    companion object : LongEntityClass<MovimentiDao>(MovimentiTable)
+
+    var idTessera by MovimentiTable.idTessera
+    var numero by MovimentiTable.numero
+    var operazione by MovimentiTable.operazione
+    var dataMovimento by MovimentiTable.dataMovimento
+    var transazione by MovimentiTable.transazione
+    var dispositivo by MovimentiTable.dispositivo
+    var riferimento by MovimentiTable.riferimento
+    var saldoPre by MovimentiTable.saldoPre
+    var importo by MovimentiTable.importo
+    var saldoPost by MovimentiTable.saldoPost
+    var puntiPre by MovimentiTable.puntiPre
+    var punti by MovimentiTable.punti
+    var puntiPost by MovimentiTable.puntiPost
+}
+
 
 fun accountsDaoToModel(dao: AccountsDAO) = Accounts(
     dao.id.value,
@@ -54,6 +117,40 @@ fun parametriDaoToModel(dao: ParametriDAO) = Parametri(
     dao.valore
 )
 
+fun tessereDaoToModel(dao: TessereDao) = Tessere(
+    dao.id.value,
+    dao.idUtente,
+    dao.codiceFiscale,
+    dao.numero,
+    dao.saldo,
+    dao.punti
+)
+
+fun movimentiDaoToModel(dao: MovimentiDao) :Movimenti{
+    val formatter = DateTimeFormatter.ofPattern("ddMMyyyy HH:mm")
+    val formattedDate = dao.dataMovimento.format(formatter)
+
+    return Movimenti(
+        dao.id.value,
+        dao.idTessera,
+        dao.numero,
+        dao.operazione,
+        formattedDate,
+        dao.transazione,
+        dao.dispositivo,
+        dao.riferimento,
+        dao.saldoPre,
+        dao.importo,
+        dao.saldoPost,
+        dao.puntiPre,
+        dao.punti,
+        dao.puntiPost
+    )
+}
+
+
+
+
 
 suspend fun <T> suspendTransaction(block: Transaction.() -> T): T =
     newSuspendedTransaction(Dispatchers.IO, statement = block)

src/main/kotlin/eu/maiora/model/Movimenti.kt

@@ -0,0 +1,22 @@
+package eu.maiora.model
+
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class Movimenti(
+    val id: Long,
+    val idTessera: Long,
+    val numero: String,
+    val operazione: String,
+    val dataMovimento: String,
+    val transazione: String,
+    val dispositivo: String,
+    val riferimento: String,
+    val saldoPre: Double,
+    val importo: Double,
+    val saldoPost: Double,
+    val puntiPre: Int,
+    val punti: Int,
+    val puntiPost: Int
+)

src/main/kotlin/eu/maiora/model/MovimentiRepository.kt

@@ -0,0 +1,5 @@
+package eu.maiora.model
+
+interface MovimentiRepository {
+    suspend fun movimentiByIdTessera(idTessera : Long): List<Movimenti>?
+}

src/main/kotlin/eu/maiora/model/MovimentiRepositoryImpl.kt

@@ -0,0 +1,15 @@
+package eu.maiora.model
+
+import eu.maiora.db.*
+import org.jetbrains.exposed.sql.SortOrder
+
+class MovimentiRepositoryImpl : MovimentiRepository {
+    override suspend fun movimentiByIdTessera(idTessera : Long): List<Movimenti> = suspendTransaction {
+        // Cerca la lista di movimenti
+        MovimentiDao.find { MovimentiTable.idTessera eq idTessera }
+            .orderBy(MovimentiTable.dataMovimento to SortOrder.DESC)
+            .toList() // Restituisce la lista dei movimenti
+            .map { movimentiDaoToModel(it) } // Converte il DAO in un oggetto Movimenti
+
+    }
+}

src/main/kotlin/eu/maiora/model/Tessere.kt

@@ -0,0 +1,13 @@
+package eu.maiora.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Tessere(
+    val id: Long,
+    val idUtente : Long,
+    val codiceFiscale : String,
+    val numero : String,
+    val saldo : Double,
+    val punti : Int
+)

src/main/kotlin/eu/maiora/model/TessereRepository.kt

@@ -0,0 +1,5 @@
+package eu.maiora.model
+
+interface TessereRepository {
+    suspend fun tesseraByCodiceFiscale(cf : String): Tessere?
+}

src/main/kotlin/eu/maiora/model/TessereRepositoryImpl.kt

@@ -0,0 +1,13 @@
+package eu.maiora.model
+
+import eu.maiora.db.*
+
+class TessereRepositoryImpl : TessereRepository {
+    override suspend fun tesseraByCodiceFiscale(cf: String): Tessere? = suspendTransaction {
+        // Cerca tessere in base al codice fiscale
+        TessereDao.find { TessereTable.codiceFiscale eq cf }
+            .singleOrNull() // Restituisce un singolo risultato o null se non trovato
+            ?.let { tessereDaoToModel(it) } // Converte il DAO in un oggetto Tessere
+
+    }
+}

src/main/kotlin/eu/maiora/plugins/Routing.kt

@@ -5,8 +5,12 @@ package eu.maiora.plugins
 //import eu.maiora.routes.eseguiScriptSQLRoute
 //import eu.maiora.routes.logScriptRouting
 import eu.maiora.model.AccountsRepositoryImpl
+import eu.maiora.model.MovimentiRepositoryImpl
 import eu.maiora.model.ParametriRepositoryImpl
+import eu.maiora.model.TessereRepositoryImpl
 import eu.maiora.routes.auth
+import eu.maiora.routes.movimenti
+import eu.maiora.routes.tessere
 import io.ktor.server.application.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
@@ -19,5 +23,7 @@ fun Application.configureRouting(dbUrl : String, username : String, password : S
         }
 
         auth(AccountsRepositoryImpl())
+        tessere(TessereRepositoryImpl())
+        movimenti(MovimentiRepositoryImpl())
     }
 }

src/main/kotlin/eu/maiora/routes/Movimenti.kt

@@ -0,0 +1,36 @@
+package eu.maiora.routes
+
+import eu.maiora.model.MovimentiRepositoryImpl
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+
+fun Route.movimenti(movimentiRepository: MovimentiRepositoryImpl){
+    route("/api/movimenti"){
+        authenticate("auth-jwt") {
+            get("{idTessera}"){
+                // Ottieni l'id della tessera dal percorso
+                val idTessera = call.parameters["idTessera"]
+
+                if (idTessera == null) {
+                    call.respondText("ID tessera non valido", status = HttpStatusCode.BadRequest)
+                    return@get
+                }
+
+                // Cerca la tessera per codice fiscale
+                val listaMovimenti = movimentiRepository.movimentiByIdTessera(idTessera.toLong())
+
+
+                if (listaMovimenti != null) {
+                    call.respond(listaMovimenti)
+                } else {
+                    call.respondText("Movimenti non trovati", status = HttpStatusCode.NotFound)
+                }
+            }
+        }
+
+    }
+}

src/main/kotlin/eu/maiora/routes/Tessere.kt

@@ -0,0 +1,35 @@
+package eu.maiora.routes
+
+import eu.maiora.model.TessereRepositoryImpl
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+
+fun Route.tessere(tessereRepository: TessereRepositoryImpl){
+    route("/api/tessere"){
+        authenticate("auth-jwt") {
+            get("{cf}"){
+                // Ottieni il codice fiscale dal percorso
+                val cf = call.parameters["cf"]
+
+                if (cf == null) {
+                    call.respondText("Codice fiscale non valido", status = HttpStatusCode.BadRequest)
+                    return@get
+                }
+
+                // Cerca la tessera per codice fiscale
+                val tessera = tessereRepository.tesseraByCodiceFiscale(cf)
+
+                if (tessera != null) {
+                    call.respond(tessera)
+                } else {
+                    call.respondText("Tessera non trovata", status = HttpStatusCode.NotFound)
+                }
+            }
+        }
+
+    }
+}