Start bet participations and refactoring

.gitignore

@@ -34,3 +34,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+**/src/target/**

Sources/src/main/kotlin/allin/ext/PipelineContextExt.kt

@@ -0,0 +1,24 @@
+package allin.ext
+
+import allin.dto.UserDTO
+import allin.entities.UsersEntity
+import allin.model.ApiMessage
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.auth.jwt.*
+import io.ktor.server.response.*
+import io.ktor.util.pipeline.*
+
+suspend fun PipelineContext<*, ApplicationCall>.hasToken(content: suspend (principal: JWTPrincipal) -> Unit) =
+    call.principal<JWTPrincipal>()?.let { content(it) } ?: call.respond(HttpStatusCode.Unauthorized)
+
+suspend fun PipelineContext<*, ApplicationCall>.verifyUserFromToken(
+    principal: JWTPrincipal,
+    content: suspend (user: UserDTO, password: String) -> Unit
+) {
+    val username = principal.payload.getClaim("username").asString()
+    val userPassword = UsersEntity.getUserByUsernameAndPassword(username)
+    userPassword.first?.let { content(it, userPassword.second ?: "") }
+        ?: call.respond(HttpStatusCode.NotFound, ApiMessage.TokenUserNotFound)
+}

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

@@ -0,0 +1,14 @@
+package allin.model
+
+object ApiMessage {
+    const val Welcome = "Welcome on AllIn's API !"
+    const val TokenUserNotFound = "User not found with the valid token !"
+    const val UserNotFound = "User not found."
+    const val BetNotFound = "Bet not found."
+    const val BetAlreadyExist = "Bet already exists."
+    const val IncorrectLoginPassword = "Login and/or password incorrect."
+    const val UserAlreadyExist = "Mail and/or username already exists."
+    const val InvalidMail = "Invalid mail."
+    const val ParticipationNotFound = "Participation not found."
+    const val NotEnoughCoins = "Not enough coins."
+}

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

@@ -1,65 +1,96 @@
 package allin.routing
-import io.ktor.server.application.*
-import io.ktor.server.request.*
-import io.ktor.server.routing.*
-import allin.model.*
+
+import allin.ext.hasToken
+import allin.ext.verifyUserFromToken
+import allin.model.ApiMessage
+import allin.model.Bet
+import allin.model.BetWithoutId
+import allin.model.UpdatedBetData
 import allin.utils.AppConfig
 import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.request.*
 import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import java.util.*
 
 val bets = mutableListOf<Bet>()
-val tokenManagerBet= AppConfig.tokenManager
+val tokenManagerBet = AppConfig.tokenManager
 
-fun CreateId() : Int{
-    return bets.size
-}
-
-fun Application.BetRouter(){
-    routing{
-        route("/bets/add"){
-            post{
+fun Application.BetRouter() {
+    routing {
+        route("/bets/add") {
+            post {
                 val bet = call.receive<BetWithoutId>()
-                val id = CreateId()
+                val id = UUID.randomUUID().toString()
                 val username = tokenManagerBet.getUsernameFromToken(bet.createdBy)
-                val findbet = bets.find { it.id == id }
-                if(findbet==null){
-                    val betWithId = convertBetWithoutIdToBet(bet,id,username)
+                bets.find { it.id == id }?.let {
+                    call.respond(HttpStatusCode.Conflict, ApiMessage.BetAlreadyExist)
+                } ?: run {
+                    val betWithId = Bet(
+                        id,
+                        bet.theme,
+                        bet.sentenceBet,
+                        bet.endRegistration,
+                        bet.endBet,
+                        bet.isPrivate,
+                        bet.response,
+                        username
+                    )
                     bets.add(betWithId)
                     call.respond(HttpStatusCode.Created, betWithId)
                 }
-                call.respond(HttpStatusCode.Conflict,"Bet already exist")
             }
         }
-        route("/bets/gets"){
-            get{
-               // if(bets.size>0)
-                    call.respond(HttpStatusCode.Accepted, bets.toList())
-               // else call.respond(HttpStatusCode.NoContent)
+
+        route("/bets/gets") {
+            get {
+                // if(bets.size>0)
+                call.respond(HttpStatusCode.Accepted, bets.toList())
+                // else call.respond(HttpStatusCode.NoContent)
             }
         }
-        route("/bets/delete"){
-            post{
-                val idbet = call.receive<Map<String, Int>>()["id"]
-                val findbet = bets.find { it.id == idbet }
-                if(findbet==null){
-                    call.respond(HttpStatusCode.NotFound, "Bet doesnt find")
-                }
-                bets.remove(findbet)
-                findbet as Bet
-                call.respond(HttpStatusCode.Accepted, findbet)
+
+        route("/bets/get/{id}") {
+            get {
+                val id = call.parameters["id"] ?: ""
+                bets.find { it.id == id }?.let { bet ->
+                    call.respond(HttpStatusCode.Accepted, bet)
+                } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.BetNotFound)
             }
         }
-        route("bets/update"){
-            post{
+
+        route("/bets/delete") {
+            post {
+                val idbet = call.receive<Map<String, String>>()["id"]
+                bets.find { it.id == idbet }?.let { findbet ->
+                    bets.remove(findbet)
+                    call.respond(HttpStatusCode.Accepted, findbet)
+                } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.BetNotFound)
+            }
+        }
+        route("bets/update") {
+            post {
                 val updatedBetData = call.receive<UpdatedBetData>()
-                val findbet = bets.find { it.id == updatedBetData.id }
-                if (findbet == null) {
-                    call.respond(HttpStatusCode.NotFound, "Bet not found")
-                } else {
+                bets.find { it.id == updatedBetData.id }?.let { findbet ->
                     findbet.endBet = updatedBetData.endBet
                     findbet.isPrivate = updatedBetData.isPrivate
                     findbet.response = updatedBetData.response
                     call.respond(HttpStatusCode.Accepted, findbet)
+                } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.BetNotFound)
+            }
+        }
+
+        authenticate {
+            get("/bets/current") {
+                hasToken { principal ->
+                    verifyUserFromToken(principal) { user, _ ->
+                        val bets = participations
+                            .filter { it.username == user.username }
+                            .mapNotNull { itParticipation -> bets.find { it.id == itParticipation.betId } }
+                        call.respond(HttpStatusCode.OK, bets)
+                    }
                 }
             }
         }

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

@@ -0,0 +1,56 @@
+package allin.routing
+
+import allin.ext.hasToken
+import allin.ext.verifyUserFromToken
+import allin.model.ApiMessage
+import allin.model.Participation
+import allin.model.ParticipationRequest
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import java.util.*
+
+val participations = mutableListOf<Participation>()
+
+fun Application.ParticipationRouter() {
+    routing {
+        authenticate {
+            post("/participations/add") {
+                hasToken { principal ->
+                    val participation = call.receive<ParticipationRequest>()
+                    verifyUserFromToken(principal) { user, _ ->
+                        if (user.nbCoins >= participation.stake) {
+                            participations.add(
+                                Participation(
+                                    id = UUID.randomUUID().toString(),
+                                    betId = participation.betId,
+                                    username = user.username,
+                                    answer = participation.answer,
+                                    stake = participation.stake
+                                )
+                            )
+                            call.respond(HttpStatusCode.Created)
+                        } else {
+                            call.respond(HttpStatusCode.Forbidden, ApiMessage.NotEnoughCoins)
+                        }
+                    }
+                }
+            }
+            delete("/participations/delete") {
+                hasToken { principal ->
+                    val participationId = call.receive<String>()
+                    participations.find { it.id == participationId }?.let { participation ->
+                        verifyUserFromToken(principal) { user, _ ->
+                            // user.nbCoins += participation.stake
+                            participations.remove(participation)
+                            call.respond(HttpStatusCode.NoContent)
+                        }
+                    } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.ParticipationNotFound)
+                }
+            }
+        }
+    }
+}

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

@@ -1,7 +1,9 @@
 package allin.routing
 
-import allin.dto.convertUserToUserDTO
-import allin.dto.convertUserToUserDTOToken
+import allin.entities.UsersEntity.addUserEntity
+import allin.entities.UsersEntity.deleteUserByUsername
+import allin.entities.UsersEntity.getUserByUsernameAndPassword
+import allin.entities.UsersEntity.getUserToUserDTO
 import allin.ext.hasToken
 import allin.ext.verifyUserFromToken
 import allin.model.ApiMessage
@@ -15,18 +17,13 @@ import io.ktor.server.auth.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
-import java.util.*
 import org.ktorm.database.Database
+import java.util.*
 
-val users = mutableListOf<User>()
 val RegexCheckerUser = AppConfig.regexChecker
 val CryptManagerUser = AppConfig.cryptManager
 val tokenManagerUser = AppConfig.tokenManager
 const val DEFAULT_COINS = 500
-
-val RegexCheckerUser= AppConfig.regexChecker
-val CryptManagerUser= AppConfig.cryptManager
-val tokenManagerUser=AppConfig.tokenManager
 val database = Database.connect("jdbc:postgresql://localhost:5432/Allin", user = "postgres", password = "lulu")
 
 fun Application.UserRouter() {
@@ -38,6 +35,7 @@ fun Application.UserRouter() {
                 if (RegexCheckerUser.isEmailInvalid(tempUser.email)) {
                     call.respond(HttpStatusCode.Forbidden, ApiMessage.InvalidMail)
                 }
+                val users = getUserToUserDTO()
                 users.find { it.username == tempUser.username || it.email == tempUser.email }?.let { user ->
                     call.respond(HttpStatusCode.Conflict, ApiMessage.UserAlreadyExist)
                 } ?: run {
@@ -51,7 +49,7 @@ fun Application.UserRouter() {
                     )
                     CryptManagerUser.passwordCrypt(user)
                     user.token = tokenManagerUser.generateOrReplaceJWTToken(user)
-                    users.add(user)
+                    addUserEntity(user)
                     call.respond(HttpStatusCode.Created, user)
                 }
             }
@@ -60,36 +58,41 @@ fun Application.UserRouter() {
         route("/users/login") {
             post {
                 val checkUser = call.receive<CheckUser>()
-                users.find { it.username == checkUser.login || it.email == checkUser.login }?.let { user ->
-                    if (CryptManagerUser.passwordDecrypt(user, checkUser.password)) {
-                        user.token = tokenManagerUser.generateOrReplaceJWTToken(user)
-                        call.respond(HttpStatusCode.OK, convertUserToUserDTOToken(user))
-                    } else {
-                        call.respond(HttpStatusCode.NotFound, ApiMessage.IncorrectLoginPassword)
-                    }
-                } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.IncorrectLoginPassword)
+                val user = getUserByUsernameAndPassword(checkUser.login)
+                if (CryptManagerUser.passwordDecrypt(user.second ?: "", checkUser.password)) {
+                    user.first?.let { userDtoWithToken ->
+                        userDtoWithToken.token = tokenManagerUser.generateOrReplaceJWTToken(userDtoWithToken)
+                        call.respond(HttpStatusCode.OK, userDtoWithToken)
+                    } ?: call.respond(HttpStatusCode.NotFound, ApiMessage.UserNotFound)
+                } else {
+                    call.respond(HttpStatusCode.NotFound, ApiMessage.IncorrectLoginPassword)
+                }
             }
         }
 
         authenticate {
             post("/users/delete") {
                 hasToken { principal ->
-                    verifyUserFromToken(principal) { user ->
+                    verifyUserFromToken(principal) { _, password ->
                         val checkUser = call.receive<CheckUser>()
-                        if (user.username == checkUser.login && user.password == checkUser.password) {
-                            users.remove(user)
-                            call.respond(HttpStatusCode.Accepted, convertUserToUserDTO(user))
+
+                        if (CryptManagerUser.passwordDecrypt(password, checkUser.password)) {
+                            if (!deleteUserByUsername(checkUser.login)) {
+                                call.respond(HttpStatusCode.InternalServerError, "This user can't be delete now !")
+                            }
+                            call.respond(HttpStatusCode.Accepted, password)
                         } else {
-                            call.respond(HttpStatusCode.NotFound, ApiMessage.IncorrectLoginPassword)
+                            call.respond(HttpStatusCode.NotFound, "Login and/or password incorrect.")
                         }
+
                     }
                 }
             }
 
             get("/users/token") {
                 hasToken { principal ->
-                    verifyUserFromToken(principal) { user ->
-                        call.respond(HttpStatusCode.OK, convertUserToUserDTO(user))
+                    verifyUserFromToken(principal) { userDto, _ ->
+                        call.respond(HttpStatusCode.OK, userDto)
                     }
                 }
             }

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

@@ -1,5 +1,6 @@
 package allin.utils
 
+import allin.dto.UserDTO
 import allin.model.User
 import com.auth0.jwt.JWT
 import com.auth0.jwt.JWTVerifier
@@ -41,36 +42,36 @@ class TokenManager private constructor(val config: HoconApplicationConfig) {
         }
     }
 
+
     fun generateOrReplaceJWTToken(user: UserDTO): String {
         val userToken = getUserToken(user)
-        if (userToken != null && !isTokenExpired(userToken)) {
-            return userToken
+        return if (userToken != null && !isTokenExpired(userToken)) {
+            userToken
         } else {
-            return generateJWTToken(user)
+            generateJWTToken(user)
         }
     }
 
-    fun generateJWTToken(user : UserDTO): String {
+    fun generateJWTToken(user: UserDTO): String {
         val expirationDate = System.currentTimeMillis() + 604800000 // une semaine en miliseconde
-        val token = JWT.create()
+        return JWT.create()
             .withAudience(audience)
             .withIssuer(issuer)
             .withClaim("username", user.username)
             .withExpiresAt(Date(expirationDate))
             .sign(Algorithm.HMAC256(secret))
-        return token
     }
 
+
     fun isTokenExpired(token: String): Boolean {
         val expirationTime = JWT.decode(token).expiresAt.time
         return System.currentTimeMillis() > expirationTime
     }
 
-    fun getUserToken(user: User): String? {
-        return user.token
-    }
+    fun getUserToken(user: User): String? = user.token
+    fun getUserToken(user: UserDTO): String? = user.token
 
-    fun getUsernameFromToken(token: String) : String{
+    fun getUsernameFromToken(token: String): String {
         val decodedJWT: DecodedJWT = JWT.decode(token)
         return decodedJWT.getClaim("username").asString()
     }

Sources/target/classes/application.conf

@@ -1,4 +0,0 @@
-secret="secret"
-issuer="http://0.0.0.0:8080/"
-audience="http://0.0.0.0:8080/"
-realm="Access to main page"

Sources/target/classes/logback.xml

@@ -1,12 +0,0 @@
-<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>