Merge pull request 'BetEntity_implementation' (#4) from BetEntity_implementation into master

Reviewed-on: #4

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

@@ -1,5 +1,8 @@
 package allin
 
+import allin.entities.BetEntity
+import allin.entities.BetsEntity
+import allin.entities.ResponsesEntity
 import allin.entities.UsersEntity
 import allin.routing.BasicRouting
 import allin.routing.BetRouter
@@ -52,4 +55,6 @@ private fun Application.extracted() {
     BetRouter()
     ParticipationRouter()
     UsersEntity.createUserTable()
+    BetsEntity.createBetsTable()
+    ResponsesEntity.createResponseTable()
 }

Sources/src/main/kotlin/allin/dto/UserDTO.kt

@@ -1,4 +1,4 @@
 package allin.dto
 import kotlinx.serialization.Serializable
 @Serializable
-data class UserDTO(val username: String, val email: String, val nbCoins: Double, var token:String?)
+data class UserDTO(val id: String, val username: String, val email: String, val nbCoins: Double, var token:String?)

Sources/src/main/kotlin/allin/entities/BetEntity.kt

@@ -0,0 +1,65 @@
+package allin.entities
+
+import allin.database
+import allin.entities.ResponsesEntity.getResponse
+import allin.model.Bet
+import allin.utils.Execute
+import org.ktorm.dsl.*
+import org.ktorm.entity.Entity
+import org.ktorm.schema.*
+import java.time.ZoneId
+import java.time.ZonedDateTime
+import java.util.UUID.fromString
+
+
+interface BetEntity : Entity<BetEntity> {
+    val theme: String
+    val sentenceBet: String
+    val endRegistration: ZonedDateTime
+    val endBet: ZonedDateTime
+    val isPrivate: Boolean
+    val createdBy: String
+}
+
+object BetsEntity : Table<BetEntity>("bet") {
+    val id = uuid("id").primaryKey()
+    val theme = varchar("theme")
+    val sentenceBet = varchar("sentencebet")
+    val endRegistration = timestamp("endregistration")
+    val endBet = timestamp("endbet")
+    val isPrivate = boolean("isprivate")
+    val createdBy = varchar("createdby")
+
+    fun getBets(): MutableList<Bet> {
+        return database.from(BetsEntity).select().map {
+            row -> Bet(
+            row[id].toString(),
+            row[theme].toString(),
+            row[sentenceBet].toString(),
+            row[endRegistration]!!.atZone(ZoneId.of("Europe/Paris")),
+            row[endBet]!!.atZone(ZoneId.of("Europe/Paris")),
+            row[isPrivate]?: false,
+            getResponse(fromString(row[id].toString())),
+            row[createdBy].toString()
+        )
+        }.toMutableList()
+    }
+
+    fun createBetsTable(){
+        val request="CREATE TABLE IF not exists bet ( id uuid PRIMARY KEY, theme VARCHAR(255), endregistration timestamp,endbet timestamp,sentencebet varchar(500),isprivate boolean, createdby varchar(250))"
+        database.Execute(request)
+    }
+
+    fun addBetEntity(bet : Bet) {
+        database.insert(BetsEntity) {
+            set(it.id, fromString(bet.id))
+            set(it.endBet,bet.endBet.toInstant())
+            set(it.endRegistration,bet.endRegistration.toInstant())
+            set(it.sentenceBet,bet.sentenceBet)
+            set(it.theme, bet.theme)
+            set(it.isPrivate, bet.isPrivate)
+            set(it.createdBy, bet.createdBy)
+        }
+        ResponsesEntity.addResponse(bet.response,fromString(bet.id))
+    }
+}

Sources/src/main/kotlin/allin/entities/ResponseEntity.kt

@@ -0,0 +1,41 @@
+package allin.entities
+
+import allin.database
+import allin.utils.Execute
+import org.ktorm.dsl.*
+import org.ktorm.entity.Entity
+import org.ktorm.schema.Table
+import org.ktorm.schema.uuid
+import org.ktorm.schema.varchar
+import java.util.*
+
+
+interface ResponseEntity : Entity<ResponseEntity> {
+    val betId: UUID
+    val response: String
+}
+
+object ResponsesEntity : Table<ResponseEntity>("response") {
+    val id = uuid("id").primaryKey()
+    val response = varchar("response").primaryKey()
+    fun createResponseTable(){
+        val request="CREATE TABLE IF NOT EXISTS response (id UUID,response VARCHAR(250),CONSTRAINT pk_response_id PRIMARY KEY (id,response));"
+        database.Execute(request)
+    }
+
+    fun getResponse(idBet: UUID): MutableList<String> {
+        return database.from(ResponsesEntity)
+            .select(response)
+            .where { id eq idBet }
+            .map { it[response].toString() }.toMutableList()
+    }
+
+    fun addResponse(responses : MutableList<String>, idBet : UUID ) {
+        responses.forEach {selected ->
+            database.insert(ResponsesEntity) {
+                set(it.id, idBet)
+                set(it.response,selected)
+            }
+        }
+    }
+}

Sources/src/main/kotlin/allin/entities/UserEntity.kt

@@ -6,10 +6,9 @@ import allin.model.User
 import allin.utils.Execute
 import org.ktorm.dsl.*
 import org.ktorm.entity.*
-import org.ktorm.schema.Table
-import org.ktorm.schema.double
-import org.ktorm.schema.int
-import org.ktorm.schema.varchar
+import org.ktorm.schema.*
+import java.util.*
+import java.util.UUID.fromString
 
 interface UserEntity : Entity<UserEntity> {
     val username: String
@@ -18,7 +17,7 @@ interface UserEntity : Entity<UserEntity> {
     var nbCoins: Double
 }
 object UsersEntity : Table<UserEntity>("utilisateur") {
-    val id = int("id").primaryKey()
+    val id = uuid("id").primaryKey()
     val username = varchar("username")
     val password = varchar("password")
     val nbCoins = double("coins")
@@ -27,6 +26,7 @@ object UsersEntity : Table<UserEntity>("utilisateur") {
     fun getUserToUserDTO(): MutableList<UserDTO> {
         return database.from(UsersEntity).select().map {
             row -> UserDTO(
+                row[id].toString(),
                 row[username].toString(),
                 row[email].toString(),
                 row[nbCoins]?:0.0,
@@ -36,7 +36,7 @@ object UsersEntity : Table<UserEntity>("utilisateur") {
     }
 
     fun createUserTable(){
-        val request="CREATE TABLE IF not exists utilisateur ( id SERIAL PRIMARY KEY, username VARCHAR(255), password VARCHAR(255),coins double precision,email VARCHAR(255))"
+        val request="CREATE TABLE IF not exists utilisateur ( id uuid PRIMARY KEY, username VARCHAR(255), password VARCHAR(255),coins double precision,email VARCHAR(255))"
         database.Execute(request)
     }
 
@@ -48,6 +48,7 @@ object UsersEntity : Table<UserEntity>("utilisateur") {
             .map { row ->
                 Pair(
                     UserDTO(
+                        row[id].toString(),
                         row[username].toString(),
                         row[email].toString(),
                         row[nbCoins] ?: 0.0,
@@ -61,6 +62,7 @@ object UsersEntity : Table<UserEntity>("utilisateur") {
 
     fun addUserEntity(user : User){
         database.insert(UsersEntity){
+            set(it.id,fromString(user.id))
             set(it.nbCoins,user.nbCoins)
             set(it.username,user.username)
             set(it.password,user.password)

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

@@ -1,19 +1,21 @@
 package allin.model
 
+import allin.serializer.UUIDSerializer
 import allin.serializer.ZonedDateTimeSerializer
 import kotlinx.serialization.Serializable
 import java.time.ZonedDateTime
+import java.util.*
 
 @Serializable
 data class Bet(
-    val id: String,
+    val id: String = "",
     val theme: String,
     val sentenceBet: String,
     @Serializable(ZonedDateTimeSerializer::class) val endRegistration: ZonedDateTime,
     @Serializable(ZonedDateTimeSerializer::class) var endBet: ZonedDateTime,
     var isPrivate: Boolean,
     var response: MutableList<String>,
-    val createdBy: String
+    val createdBy: String = ""
 )
 
 @Serializable
@@ -23,14 +25,3 @@ data class UpdatedBetData(
     val isPrivate: Boolean,
     val response: MutableList<String>
 )
-
-@Serializable
-data class BetWithoutId(
-    val theme: String,
-    val sentenceBet: String,
-    @Serializable(ZonedDateTimeSerializer::class) val endRegistration: ZonedDateTime,
-    @Serializable(ZonedDateTimeSerializer::class) var endBet: ZonedDateTime,
-    var isPrivate: Boolean,
-    var response: MutableList<String>,
-    val createdBy: String
-)

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

@@ -1,4 +1,4 @@
-package allin.model
+    package allin.model
 
 import kotlinx.serialization.Serializable
 

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

@@ -1,5 +1,7 @@
 package allin.routing
 
+import allin.entities.BetsEntity.addBetEntity
+import allin.entities.BetsEntity.getBets
 import allin.ext.hasToken
 import allin.ext.verifyUserFromToken
 import allin.model.ApiMessage
@@ -14,16 +16,19 @@ import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import java.util.*
 
-val bets = mutableListOf<Bet>()
+//val bets = mutableListOf<Bet>()
 val tokenManagerBet = AppConfig.tokenManager
 
 fun Application.BetRouter() {
     routing {
         route("/bets/add") {
+            authenticate {
             post {
+                hasToken { principal ->
                 val bet = call.receive<Bet>()
                 val id = UUID.randomUUID().toString()
-                val username = tokenManagerBet.getUsernameFromToken(bet.createdBy)
+                val username = tokenManagerBet.getUsernameFromToken(principal)
+                val bets = getBets()
                 bets.find { it.id == id }?.let {
                     call.respond(HttpStatusCode.Conflict, ApiMessage.BetAlreadyExist)
                 } ?: run {
@@ -37,15 +42,21 @@ fun Application.BetRouter() {
                         bet.response,
                         username
                     )
-                    bets.add(betWithId)
+                    //bets.add(betWithId)
+                    addBetEntity(betWithId)
                     call.respond(HttpStatusCode.Created, betWithId)
                 }
+                }
+
+            }
+
             }
         }
 
         route("/bets/gets") {
             get {
                 // if(bets.size>0)
+                val bets= getBets()
                 call.respond(HttpStatusCode.Accepted, bets.toList())
                 // else call.respond(HttpStatusCode.NoContent)
             }
@@ -53,6 +64,7 @@ fun Application.BetRouter() {
 
         route("/bets/get/{id}") {
             get {
+                val bets= getBets()
                 val id = call.parameters["id"] ?: ""
                 bets.find { it.id == id }?.let { bet ->
                     call.respond(HttpStatusCode.Accepted, bet)
@@ -63,6 +75,7 @@ fun Application.BetRouter() {
         route("/bets/delete") {
             post {
                 val idbet = call.receive<Map<String, String>>()["id"]
+                val bets= getBets()
                 bets.find { it.id == idbet }?.let { findbet ->
                     bets.remove(findbet)
                     call.respond(HttpStatusCode.Accepted, findbet)
@@ -72,6 +85,7 @@ fun Application.BetRouter() {
         route("bets/update") {
             post {
                 val updatedBetData = call.receive<UpdatedBetData>()
+                val bets= getBets()
                 bets.find { it.id == updatedBetData.id }?.let { findbet ->
                     findbet.endBet = updatedBetData.endBet
                     findbet.isPrivate = updatedBetData.isPrivate
@@ -83,6 +97,7 @@ fun Application.BetRouter() {
 
         authenticate {
             get("/bets/current") {
+                val bets= getBets()
                 hasToken { principal ->
                     verifyUserFromToken(principal) { user, _ ->
                         val bets = participations

Sources/src/main/kotlin/allin/serializer/DateSerializer.kt

@@ -1,17 +1,22 @@
 package allin.serializer
 
-import kotlinx.serialization.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
+import java.sql.Timestamp
+import java.time.Instant
+import java.time.ZoneId
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
 
+
 @Serializer(ZonedDateTime::class)
 object ZonedDateTimeSerializer : KSerializer<ZonedDateTime> {
-    private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_ZONED_DATE_TIME
+    private val formatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z")
 
     override val descriptor: SerialDescriptor =
         PrimitiveSerialDescriptor("ZonedDateTime", PrimitiveKind.STRING)

Sources/src/main/kotlin/allin/serializer/UUIDSerializer.kt

@@ -0,0 +1,20 @@
+package allin.serializer
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import java.util.*
+
+object UUIDSerializer : KSerializer<UUID> {
+    override val descriptor = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): UUID {
+        return UUID.fromString(decoder.decodeString())
+    }
+
+    override fun serialize(encoder: Encoder, value: UUID) {
+        encoder.encodeString(value.toString())
+    }
+}

Sources/src/main/kotlin/allin/utils/CryptManager.kt

@@ -18,7 +18,6 @@ class CryptManager {
         return BCrypt.hashpw(password,salt)
     }
     fun passwordCrypt(user: User){
-        println(salt)
         user.password=BCrypt.hashpw(user.password,salt)
     }
     fun passwordDecrypt(password: String, passwordClear: String): Boolean{

Sources/src/main/kotlin/allin/utils/TokenManager.kt

@@ -6,6 +6,7 @@ import com.auth0.jwt.JWT
 import com.auth0.jwt.JWTVerifier
 import com.auth0.jwt.algorithms.Algorithm
 import com.auth0.jwt.interfaces.DecodedJWT
+import io.ktor.server.auth.jwt.*
 import io.ktor.server.config.*
 import java.util.*
 
@@ -70,9 +71,8 @@ class TokenManager private constructor(val config: HoconApplicationConfig) {
     fun getUserToken(user: User): String? = user.token
     fun getUserToken(user: UserDTO): String? = user.token
 
-    fun getUsernameFromToken(token: String): String {
-        val decodedJWT: DecodedJWT = JWT.decode(token)
-        return decodedJWT.getClaim("username").asString()
+    fun getUsernameFromToken(principal: JWTPrincipal): String {
+        return principal.payload.getClaim("username").asString()
     }
 
     companion object {