code 0.0: entities & services

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/MatchBean.kt

@@ -3,16 +3,17 @@ package fr.teamflash.fencerjudgeback.entities
 import jakarta.persistence.Entity
 import jakarta.persistence.Id
 import jakarta.persistence.Table
+import java.util.Date
 
 @Entity
 @Table(name="matchs")
 data class MatchBean(
     @Id
-    val  id:Long?=null,
+    val id:Long?=null,
     val player1ID:Long?=null,
     val player2ID:Long?=null,
     val refereeID: Long?=null,
     val score1:Int=0,
     val score2:Int=0,
-    val date:String?=null
+    val date: Date?=null
 )

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/PlayerBean.kt

@@ -1,6 +1,8 @@
 package fr.teamflash.fencerjudgeback.entities
 
 import jakarta.persistence.Entity
+import jakarta.persistence.GeneratedValue
+import jakarta.persistence.GenerationType
 import jakarta.persistence.Id
 import jakarta.persistence.Table
 

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/RefereeBean.kt

@@ -1,6 +1,8 @@
 package fr.teamflash.fencerjudgeback.entities
 
 import jakarta.persistence.Entity
+import jakarta.persistence.GeneratedValue
+import jakarta.persistence.GenerationType
 import jakarta.persistence.Id
 import jakarta.persistence.Table
 

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/MatchService.kt

@@ -3,38 +3,102 @@ package fr.teamflash.fencerjudgeback.services
 import fr.teamflash.fencerjudgeback.entities.MatchBean
 import fr.teamflash.fencerjudgeback.entities.PlayerBean
 import fr.teamflash.fencerjudgeback.repositories.MatchRepository
+import fr.teamflash.fencerjudgeback.websocket.controllers.MatchWebSocketController
+import fr.teamflash.fencerjudgeback.websocket.models.MatchUpdateMessage
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.annotation.Lazy
+import org.springframework.http.ResponseEntity
 import org.springframework.stereotype.Service
+import java.util.Date
 
 @Service
-class MatchService(private val matchRepository: MatchRepository) {
+class MatchService(
-
+    @Autowired private val matchRepository: MatchRepository,
-    fun getMatchById(id:Long): MatchBean {
+    @Lazy private val matchWebSocketController: MatchWebSocketController? = null
-        println("MatchService.getMatchById : $id")
+) {
-        return matchRepository.findById(id).get()
+    // Obtenir tous les matchs (public)
-    }
+    fun getAll() : List<MatchBean> {
-    fun getMatchByPlayer(playerBean: PlayerBean): List<MatchBean> {
-        println("MatchService.getMatchByPlayer : $playerBean")
-        return matchRepository.findAll().filter { it.player1ID == playerBean.id || it.player2ID == playerBean.id }
-    }
-    fun getMatchs() : List<MatchBean> {
         println("MatchService.getMatchs")
         return matchRepository.findAll()
     }
-    fun createMatch(match: MatchBean) : MatchBean {
+
-        println("MatchService.createMatch : $match")
+    // Obtenir un match par id (public)
-        matchRepository.save(match)
+    fun getById(id:Long): MatchBean? {
-        return match
+        println("MatchService.getMatchById : $id")
+        return matchRepository.findById(id).get()
     }
-    fun updateMatch(match: MatchBean) {
+
-        println("MatchService.updateMatch : $match")
+    // Obtenir un ou plusieurs match(s) par joueurs (id) (public)
-        matchRepository.save(match)
+    fun getByPlayers(player1ID: Long, player2ID: Long): List<MatchBean> {
+        println("MatchService.getMatchByPlayers : $player1ID - $player2ID")
+        return matchRepository.findAll().filter { it.player1ID == player1ID && it.player2ID == player2ID }
     }
-    fun updateMatchScore(score1:Int, score2:Int) : MatchBean {
+
-        println("MatchService.updateMatchScore : $score1 - $score2")
+    // Ajouter un match (admin)
-        return matchRepository.findAll().first()
+    fun createMatch(newMatch: MatchBean): MatchBean {
+        println("MatchService.createMatch : $newMatch")
+        // Broadcast the new match via WebSocket
+//        matchWebSocketController?.broadcastMatchUpdate(savedMatch, MatchUpdateMessage.UpdateType.MATCH_START)
+
+        return  matchRepository.save(newMatch)
     }
-    fun delMatch(match:MatchBean){
+
-        println("MatchService.delMatch : $match")
+    // Modifier un match (admin)
-        matchRepository.delete(match)
+    fun updateMatch(id: Long, date: Date, refereeID: Long, player1ID: Long, player2ID: Long, scorePlayer1:Int, scorePlayer2:Int) : Int {
+        println("MatchService.updateMatch : $id - $refereeID - $player1ID - $player2ID - $scorePlayer1 - $scorePlayer2")
+
+        if (getById(id) == null) {
+            println("MatchService.updateMatch : Match not found")
+            return -1
+        }
+
+        // Broadcast the update via WebSocket
+//        matchWebSocketController?.broadcastMatchUpdate(savedMatch, MatchUpdateMessage.UpdateType.SCORE_UPDATE)
+
+        // Créer nouveau MatchBean à l'id renseigné
+        val newMatch = MatchBean(
+            id = id,
+            date = date,
+            refereeID = refereeID,
+            player1ID = player1ID,
+            player2ID = player2ID,
+            score1 = scorePlayer1,
+            score2 = scorePlayer2
+        )
+
+//        if (
+//            // Supprimer le MatchBean à l'id en paramètre
+//            deleteMatch(id) == 1
+//            && createMatch(newMatch) == 1) {
+//
+//            // Insérer le nouveau MatchBean à l'id en paramètre
+//
+//
+//            return 1
+//        }
+
+        // Supprimer le MatchBean à l'id en paramètre
+        if (deleteMatch(id) == 1) {
+            // Insérer le nouveau MatchBean à l'id en paramètre
+            createMatch(newMatch)
+        }
+
+        return 1
     }
-}
+
+    // Supprimer un match (admin)
+    fun deleteMatch(id:Long) : Int {
+        println("MatchService.deleteMatch : $id")
+
+        try {
+            matchRepository.deleteById(id)
+        } catch (e: Exception) {
+            println("Error deleting match: ${e.message}")
+            return -1
+        }
+
+        // Broadcast the match cancellation via WebSocket before deleting
+//        matchWebSocketController?.broadcastMatchUpdate(matchID, MatchUpdateMessage.UpdateType.MATCH_CANCEL)
+        return 1
+    }
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/PlayerService.kt

@@ -2,35 +2,72 @@ package fr.teamflash.fencerjudgeback.services
 
 import fr.teamflash.fencerjudgeback.entities.PlayerBean
 import fr.teamflash.fencerjudgeback.repositories.PlayerRepository
+import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.stereotype.Service
 import java.util.Optional
 
 @Service
-class PlayerService(private val playerRepository: PlayerRepository) {
+class PlayerService(@Autowired private val playerRepository: PlayerRepository) {
-    fun getPlayerById(id:Long): Optional<PlayerBean?> {
+    // Obtenir tous les joueurs (public)
-        println("PlayerService.getPlayerById : $id")
+    fun getAll(): List<PlayerBean> {
+        println("RefereeService.getReferees")
+        return playerRepository.findAll()
+    }
+
+    // Obtenir un joueur par id (public)
+    fun getById(id:Long) : Optional<PlayerBean?> {
+        println("RefereeService.getRefereeById : $id")
         return playerRepository.findById(id)
     }
-    fun getPlayers(): List<PlayerBean> {
+
-        println("PlayerService.getPlayers")
+    // Obtenir un ou plusieurs joueur(s) par nom (public)
-        return playerRepository.findAll()
+    fun getByName(name:String): List<PlayerBean?>? {
+        println("RefereeService.getRefereeByName : $name")
+        return playerRepository.findAll().filter{ it.name == name }
     }
-    fun getPlayerByName(name:String) : List<PlayerBean> {
+
-        println("PlayerService.getPlayerByName : $name")
+    // Obtenir un ou plusieurs joueur(s) par prénom
-        return playerRepository.findAll()
+    fun getByFirstName(firstName:String): List<PlayerBean?>? {
+        println("RefereeService.getRefereeByFirstName : $firstName")
+        return playerRepository.findAll().filter{ it.firstName == firstName }
     }
-    fun createPlayer(player: PlayerBean): PlayerBean {
+
-        println("PlayerService.createPlayer : $player")
+    // Ajouter un joueur (admin)
-        playerRepository.save(player)
+    fun createPlayer(referee: PlayerBean) : PlayerBean {
-        return player
+        println("RefereeService.createReferee : $referee")
+        return playerRepository.save(referee)
     }
-    fun updatePlayer(player: PlayerBean) : PlayerBean{
+
-        println("PlayerService.updatePlayer : $player")
+    // Modifier un joueur (admin)
-        playerRepository.save(player)
+    fun updatePlayer(id:Long, name:String, firstName: String) : Int {
-        return player
+        // Vérifier si le joueur existe à l'id renseigné
+        if (getById(id) == null) {
+            println("RefereeService.updateReferee : Referee not found")
+            return -1
+        }
+
+        // Créer nouveau PlayerBean à l'id renseigné
+        val newPlayer = PlayerBean(id, name, firstName)
+
+        // Supprimer le PlayerBean à l'id en paramètre
+        deletePlayer(id)
+
+        // Insérer le nouveau PlayerBean
+        createPlayer(newPlayer)
+
+        return 1
     }
-    fun delPlayer(player: PlayerBean) {
+
-        println("PlayerService.delPlayer : $player")
+    // Supprimer un joueur (admin)
-        playerRepository.delete(player)
+    fun deletePlayer(id:Long): Int {
+        println("RefereeService.deleteReferee : $id")
+
+        if (getById(id) == null) {
+            println("RefereeService.deleteReferee : Referee not found")
+            return -1
+        }
+
+        playerRepository.deleteById(id)
+        return 1
     }
 }

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/RefereeService.kt

@@ -2,39 +2,73 @@ package fr.teamflash.fencerjudgeback.services
 
 import fr.teamflash.fencerjudgeback.entities.RefereeBean
 import fr.teamflash.fencerjudgeback.repositories.RefereeRepository
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.data.jpa.domain.AbstractPersistable_.id
 import org.springframework.stereotype.Service
 import java.util.Optional
 
 @Service
-class RefereeService(private val refereeRepository: RefereeRepository) {
+class RefereeService(@Autowired private val refereeRepository: RefereeRepository) {
-    fun getRefereeById(id:Long) : Optional<RefereeBean?> {
+    // Obtenir tous les arbitres (public)
-        println("RefereeService.getRefereeById : $id")
+    fun getAll(): List<RefereeBean> {
-        return refereeRepository.findById(id)
-    }
-    fun getReferees(): List<RefereeBean> {
         println("RefereeService.getReferees")
         return refereeRepository.findAll()
     }
-    fun getRefereeByName(name:String): RefereeBean {
+
-        println("RefereeService.getRefereeByName : $name")
+    // Obtenir un arbitre par id (public)
-        return refereeRepository.findAll().first { it.name == name }
+    fun getById(id:Long) : Optional<RefereeBean?> {
+        println("RefereeService.getRefereeById : $id")
+        return refereeRepository.findById(id)
     }
+
+    // Obtenir un ou plusieurs arbitre(s) par nom (public)
+    fun getByName(name:String): List<RefereeBean?>? {
+        println("RefereeService.getRefereeByName : $name")
+        return refereeRepository.findAll().filter{ it.name == name }
+    }
+
+    // Obtenir un ou plusieurs arbitre(s) par prénom
+    fun getByFirstName(firstName:String): List<RefereeBean?>? {
+        println("RefereeService.getRefereeByFirstName : $firstName")
+        return refereeRepository.findAll().filter{ it.firstName == firstName }
+    }
+
+    // Ajouter un arbitre (admin)
     fun createReferee(referee: RefereeBean) : RefereeBean {
         println("RefereeService.createReferee : $referee")
-        refereeRepository.save(referee)
+        return refereeRepository.save(referee)
-        return referee
     }
-    fun updateRefereePassword(referee: RefereeBean) {
+
-        println("RefereeService.updateRefereePassword : $referee")
+    // Modifier un arbitre (admin)
-        refereeRepository.save(referee)
+    fun updateReferee(id:Long, name:String, firstName: String) : Int {
+        // Vérifier si l'arbitre existe à l'id renseigné
+        if (getById(id) == null) {
+            println("RefereeService.updateReferee : Referee not found")
+            return -1
+        }
+
+        // Créer nouveau RefereeBean à l'id renseigné
+        val newReferee = RefereeBean(id, name, firstName)
+
+        // Supprimer le RefereeBean à l'id en paramètre
+        deleteReferee(id)
+
+        // Insérer le nouveau RefereeBean à l'id en paramètre
+        createReferee(newReferee)
+
+        return 1
     }
-    fun updateReferee(referee: RefereeBean) : RefereeBean {
+
-        println("RefereeService.updateReferee : $referee")
+    // Supprimer un arbitre (admin)
-        refereeRepository.save(referee)
+    fun deleteReferee(id:Long): Int {
-        return referee
+        println("RefereeService.deleteReferee : $id")
-    }
+
-    fun delReferee(referee: RefereeBean){
+        if (getById(id) == null) {
-        println("RefereeService.delReferee : $referee")
+            println("RefereeService.deleteReferee : Referee not found")
-        refereeRepository.delete(referee)
+            return -1
+        }
+
+        refereeRepository.deleteById(id)
+        return 1
     }
 }