add filter get bets (#11)

Co-authored-by: ludelanier <lucas.delanier@etu.uca.fr>
Co-authored-by: avalin <a.valin@openium.fr>
Co-authored-by: Lucas EVARD <lucas.evard@etu.uca.fr>
Reviewed-on: #11
Co-authored-by: Lucas DELANIER <lucas.delanier@etu.uca.fr>
Co-committed-by: Lucas DELANIER <lucas.delanier@etu.uca.fr>

README.md

@@ -89,5 +89,4 @@ Lien de l'API sur codefirst : [API All In](https://codefirst.iut.uca.fr/containe
 <div align = center>
 
 © AllDev - API
-
 </div>

Sources/src/main/kotlin/allin/Application.kt

@@ -87,6 +87,7 @@ private fun Application.extracted() {
     betDetailRouter()
     friendRouter()
 
+    
     kronJob(BET_VERIFY_DELAY) {
         dataSource.betDataSource.updateBetStatuses(ZonedDateTime.now())
     }

Sources/src/main/kotlin/allin/data/BetDataSource.kt

@@ -1,13 +1,10 @@
 package allin.data
 
-import allin.model.Bet
-import allin.model.BetDetail
-import allin.model.BetResultDetail
-import allin.model.UpdatedBetData
+import allin.model.*
 import java.time.ZonedDateTime
 
 interface BetDataSource {
-    fun getAllBets(): List<Bet>
+    fun getAllBets(filters: List<BetFilter>): List<Bet>
     fun getBetById(id: String): Bet?
     fun getBetDetailById(id: String, username: String): BetDetail?
     fun getBetsNotFinished(): List<Bet>

Sources/src/main/kotlin/allin/data/mock/MockBetDataSource.kt

@@ -15,7 +15,42 @@ class MockBetDataSource(private val mockData: MockDataSource.MockData) : BetData
     private val betInfos get() = mockData.betInfos
     private val answerInfos get() = mockData.answerInfos
 
-    override fun getAllBets(): List<Bet> = bets
+    override fun getAllBets(filters: List<BetFilter>): List<Bet> {
+        return when {
+            filters.isEmpty() -> bets
+
+            filters.size == 1 -> {
+                val filter = filters[0]
+
+                when (filter) {
+                    BetFilter.PUBLIC -> bets.filter { !it.isPrivate }
+                    BetFilter.INVITATION -> bets.filter { it.isPrivate }
+                    BetFilter.FINISHED -> bets.filter { it.status == FINISHED }
+                    BetFilter.IN_PROGRESS -> bets.filter {
+                        it.status in listOf(IN_PROGRESS, WAITING, CLOSING)
+                    }
+                }.map { it }
+            }
+
+            else -> {
+                bets.filter { bet ->
+                    val public = (BetFilter.PUBLIC in filters) && !bet.isPrivate
+                    val invitation = (BetFilter.INVITATION in filters) && bet.isPrivate
+                    val finished =
+                        (BetFilter.FINISHED in filters) and ((bet.status == FINISHED) or (bet.status == CANCELLED))
+                    val inProgress = (BetFilter.IN_PROGRESS in filters) and (bet.status in listOf(
+                        IN_PROGRESS,
+                        WAITING,
+                        CLOSING
+                    ))
+
+                    (public || invitation) && (finished or inProgress)
+                }.map { it }
+            }
+        }
+
+    }
+
     override fun getBetById(id: String): Bet? =
         bets.find { it.id == id }
 

Sources/src/main/kotlin/allin/data/postgres/PostgresBetDataSource.kt

@@ -11,8 +11,41 @@ import java.time.ZonedDateTime
 
 class PostgresBetDataSource(private val database: Database) : BetDataSource {
 
-    override fun getAllBets(): List<Bet> =
-        database.bets.map { it.toBet(database) }
+    override fun getAllBets(filters: List<BetFilter>): List<Bet> {
+        return when {
+            filters.isEmpty() -> database.bets.map { it.toBet(database) }
+
+            filters.size == 1 -> {
+                val filter = filters.first()
+
+                when (filter) {
+                    BetFilter.PUBLIC -> database.bets.filter { !it.isPrivate }
+                    BetFilter.INVITATION -> database.bets.filter { it.isPrivate }
+                    BetFilter.FINISHED -> database.bets.filter { it.status eq BetStatus.FINISHED }
+                    BetFilter.IN_PROGRESS -> database.bets.filter {
+                        it.status inList listOf(BetStatus.IN_PROGRESS, BetStatus.WAITING, BetStatus.CLOSING)
+                    }
+                }.map { it.toBet(database) }
+            }
+
+            else -> {
+                database.bets.filter { bet ->
+                    val public = (BetFilter.PUBLIC in filters) and !bet.isPrivate
+                    val invitation = (BetFilter.INVITATION in filters) and bet.isPrivate
+                    val finished =
+                        (BetFilter.FINISHED in filters) and ((bet.status eq BetStatus.FINISHED) or (bet.status eq BetStatus.CANCELLED))
+                    val inProgress = (BetFilter.IN_PROGRESS in filters) and (bet.status inList listOf(
+                        BetStatus.IN_PROGRESS,
+                        BetStatus.WAITING,
+                        BetStatus.CLOSING
+                    ))
+
+                    (public or invitation) and (finished or inProgress)
+                }.map { it.toBet(database) }
+            }
+        }
+    }
+
 
     override fun getBetById(id: String): Bet? =
         database.bets.find { it.id eq id }?.toBet(database)
@@ -21,7 +54,7 @@ class PostgresBetDataSource(private val database: Database) : BetDataSource {
         database.bets.find { it.id eq id }?.toBetDetail(database, username)
 
     override fun getBetsNotFinished(): List<Bet> {
-        val currentTime = ZonedDateTime.now(ZoneId.of("Europe/Paris"))
+        val currentTime = ZonedDateTime.now(ZoneId.of("+02:00"))
         return database.bets
             .filter { it.endBet greaterEq currentTime.toInstant() }
             .map { it.toBet(database) }

Sources/src/main/kotlin/allin/data/postgres/entities/BetResultNotificationEntity.kt

@@ -14,8 +14,8 @@ interface BetResultNotificationEntity : Entity<BetResultNotificationEntity> {
 }
 
 object BetResultNotificationsEntity : Table<BetResultNotificationEntity>("betresultnotification") {
-    val betId = varchar("betid").primaryKey()
-    val username = varchar("username").primaryKey()
+    val betId = varchar("betid").primaryKey().bindTo { it.betId }
+    val username = varchar("username").primaryKey().bindTo { it.username }
 }
 
 val Database.betResultNotifications get() = this.sequenceOf(BetResultNotificationsEntity)

Sources/src/main/kotlin/allin/model/BetFilter.kt

@@ -0,0 +1,15 @@
+package allin.model
+
+import kotlinx.serialization.Serializable
+
+enum class BetFilter {
+    PUBLIC,
+    INVITATION,
+    IN_PROGRESS,
+    FINISHED
+}
+
+@Serializable
+data class BetFiltersRequest(
+    val filters: List<BetFilter>
+)

Sources/src/main/kotlin/allin/routing/betRouter.kt

@@ -61,10 +61,13 @@ fun Application.betRouter() {
             }
         }
         authenticate {
-            get("/bets/gets", {
+            post("/bets/gets", {
                 description = "Allows you to recover all bets"
                 request {
                     headerParameter<JWTPrincipal>("JWT token of the logged user")
+                    body<List<BetFilter>> {
+                        description = "List of filters"
+                    }
                 }
                 response {
                     HttpStatusCode.Accepted to {
@@ -77,7 +80,11 @@ fun Application.betRouter() {
             }) {
                 hasToken { principal ->
                     verifyUserFromToken(userDataSource, principal) { _, _ ->
-                        call.respond(HttpStatusCode.Accepted, betDataSource.getAllBets())
+                        val filtersRequest =
+                            kotlin.runCatching { call.receiveNullable<BetFiltersRequest>() }.getOrNull()
+                        val filters =
+                            filtersRequest?.filters ?: emptyList() // Use provided filters or empty list if null
+                        call.respond(HttpStatusCode.Accepted, betDataSource.getAllBets(filters))
                     }
                 }
             }