✨ Local Database link

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

@@ -1,15 +1,4 @@
 package allin.dto
-
-import allin.model.User
 import kotlinx.serialization.Serializable
-
 @Serializable
-data class UserDTO(val username: String,val email: String, val nbCoins: Int)
+data class UserDTO(val username: String, val email: String, val nbCoins: Double, var token:String?)
-@Serializable
-data class UserDTOWithToken(val username: String,val email: String, val nbCoins: Int, val token:String?)
-fun convertUserToUserDTO(user: User): UserDTO {
-    return UserDTO(user.username, user.email, user.nbCoins)
-}
-fun convertUserToUserDTOToken(user: User): UserDTOWithToken {
-    return UserDTOWithToken(user.username, user.email, user.nbCoins,user.token)
-}

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

@@ -1,12 +1,71 @@
 package allin.entities
 
+import allin.dto.UserDTO
+import allin.model.User
+import allin.routing.database
+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
-object UserEntity : Table<Nothing>("utilisateur") {
+
+interface UserEntity : Entity<UserEntity> {
+    val username: String
+    var email: String
+    var password: String
+    var nbCoins: Double
+}
+object UsersEntity : Table<UserEntity>("utilisateur") {
     val id = int("id").primaryKey()
     val username = varchar("username")
     val password = varchar("password")
     val nbCoins = double("nbCoins")
+    val email = varchar("email")
+
+    fun getUserToUserDTO(): MutableList<UserDTO> {
+        return database.from(UsersEntity).select().map {
+            row -> UserDTO(
+                row[username].toString(),
+                row[email].toString(),
+                row[nbCoins]?:0.0,
+                null
+            )
+        }.toMutableList()
+    }
+
+    fun getUserByUsernameAndPassword(login: String): Pair<UserDTO?, String?> {
+        return database.from(UsersEntity)
+            .select()
+            .where { (username eq login) /*and (password eq passwordParam)*/ }
+            .map { row ->
+                Pair(
+                    UserDTO(
+                        row[username].toString(),
+                        row[email].toString(),
+                        row[nbCoins] ?: 0.0,
+                        null
+                    ),
+                    row[password].toString()
+                )
+            }
+            .firstOrNull() ?: Pair(null, null)
+    }
+
+    fun addUserEntity(user : User){
+        database.insert(UsersEntity){
+            set(it.nbCoins,user.nbCoins)
+            set(it.username,user.username)
+            set(it.password,user.password)
+            set(it.email,user.email)
+        }
+    }
+    fun deleteUserByUsername(username: String): Boolean {
+        val deletedCount = database.delete(UsersEntity) {
+            it.username eq username
+        }
+        return deletedCount > 0
+    }
 }
+
+

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

@@ -8,7 +8,7 @@ data class User(
     val username: String,
     val email: String,
     var password: String,
-    var nbCoins: Int = 1000,
+    var nbCoins: Int = 500,
     var token: String? = null
 )
 

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

@@ -1,11 +1,8 @@
 package allin.routing
-
+import io.ktor.server.application.*
-import allin.ext.hasToken
+import io.ktor.server.request.*
-import allin.ext.verifyUserFromToken
+import io.ktor.server.routing.*
-import allin.model.ApiMessage
+import allin.model.*
-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.*

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

@@ -16,6 +16,7 @@ import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import java.util.*
+import org.ktorm.database.Database
 
 val users = mutableListOf<User>()
 val RegexCheckerUser = AppConfig.regexChecker
@@ -23,6 +24,11 @@ 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() {
 
     routing {

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

@@ -4,12 +4,18 @@ import allin.model.User
 import org.mindrot.jbcrypt.BCrypt
 
 class CryptManager {
-    val salt=BCrypt.gensalt()
+    //val salt=BCrypt.gensalt()
+    fun passwordCrypt(password : String): String {
+        return BCrypt.hashpw(password,"\$2a\$10\$42wsdBeoLKaF6SM9oADONe")
+    }
     fun passwordCrypt(user: User){
-        user.password=BCrypt.hashpw(user.password,salt)
+        user.password=BCrypt.hashpw(user.password,"\$2a\$10\$42wsdBeoLKaF6SM9oADONe")
-
     }
-    fun passwordDecrypt(user: User, password: String): Boolean{
+    fun passwordDecrypt(password: String, passwordClear: String): Boolean{
-        return BCrypt.hashpw(password,salt)==user.password
+        return BCrypt.hashpw(passwordClear,"\$2a\$10\$42wsdBeoLKaF6SM9oADONe")==password
+    }
+
+    fun CheckPassword(hashed: String, clear: String): Boolean{
+        return BCrypt.checkpw(hashed,clear)
     }
 }

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

@@ -40,6 +40,26 @@ class TokenManager private constructor(val config: HoconApplicationConfig) {
         }
     }
 
+    fun generateOrReplaceJWTToken(user: UserDTO): String {
+        val userToken = getUserToken(user)
+        if (userToken != null && !isTokenExpired(userToken)) {
+            return userToken
+        } else {
+            return generateJWTToken(user)
+        }
+    }
+
+    fun generateJWTToken(user : UserDTO): String {
+        val expirationDate = System.currentTimeMillis() + 604800000 // une semaine en miliseconde
+        val token = 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
@@ -49,7 +69,7 @@ class TokenManager private constructor(val config: HoconApplicationConfig) {
         return user.token
     }
 
-    fun getUsernameFromToken(token: String): String {
+    fun getUsernameFromToken(token: String) : String{
         val decodedJWT: DecodedJWT = JWT.decode(token)
         return decodedJWT.getClaim("username").asString()
     }