.idea/misc.xml

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$/FencerJudgeBack" />
+  </component>
   <component name="ProjectRootManager">
     <output url="file://$PROJECT_DIR$/out" />
   </component>

.idea/modules.xml

@@ -2,7 +2,6 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/FencerJudgeBack/FencerJudgeBack.iml" filepath="$PROJECT_DIR$/FencerJudgeBack/FencerJudgeBack.iml" />
       <module fileurl="file://$PROJECT_DIR$/jpe-controle.iml" filepath="$PROJECT_DIR$/jpe-controle.iml" />
     </modules>
   </component>

FencerJudgeBack/README.md

@@ -0,0 +1,83 @@
+# Entités
+## MATCHES (MatchBean)
+- id -> Long
+- player1ID -> Long
+- player2ID -> Long 
+- refereeID (arbitre) -> Long
+- score1 (score du joueur 1) -> Integer
+- score2 (score du joueur 2) -> Integer
+- date -> Date
+- state (état du match : en cours, terminé, pas commencé) -> Integer (ENUM)
+
+## ETATS D'UN MATCH (MatchesStates)
+- ONGOING -> Integer (1)
+- OVER -> Integer (2)
+- NOT STARTED -> Integer (3)
+
+## ARBITRES (RefereeBean)
+- id -> Long
+- name (nom de famille) -> String
+- firstName (prénom) -> String
+
+## JOUEURS (PlayerBean)
+- id -> Long
+- name (nom de famille) -> String
+- firstName (prénom) -> String
+
+# Actions REST sur les entités
+## matches (MatchRestController, "/matches")
+- Lister tous les matches -> **GET "/matches/"** -> List<MatchBean>
+- Lister tous les matches à partir d'une certaine date -> **GET "/matches/date=&date"** -> List<MatchBean>
+- Lister les matches en cours (état : en cours) -> **GET "/matches/active"** -> List<MatchBean>
+- Lister les matches terminés (état : terminé) -> **GET "/matches/over"** -> List<MatchBean>
+- Lister les matches non commencés (état : non commencé) -> **GET "/matches/not-started"** -> List<MatchBean>
+- Afficher un match par id -> **GET "/matches/id=&id"** -> MatchBean
+- Mettre à jour les score d'un match récupéré par id -> **POST "/matches/update-match"**
+{
+	id=$id,
+	score1=$score1,
+	score2=$score2
+}
+-> MatchBean
+- Ajouter un match -> **POST "/matches/add-match"**
+{
+	date=$date,
+	refereeID=$refereeID,
+	player1ID=$player1ID,
+	player2ID=$player2ID
+}
+-> MatchBean
+- Supprimer un match (supprimer élément de MatchRepository en récupérant l'id) -> **POST "/matches/delete-match"**
+{
+	id=$id
+}
+
+## ARBITRES (RefereeRestController, "/referees") :
+- Lister tous les arbitres -> **GET "/referees/"** -> List<RefereeBean>
+- Afficher un arbitre par id -> **GET "/referees/id=$id"** -> RefereeBean
+- Afficher un arbitre par nom ->**GET "/referees/name=$name"** -> RefereeBean
+- Ajouter un arbitre ->**POST "/referees/add-referee"**
+{
+	name=$name,
+	firstName=$firstName
+}
+-> RefereeBean
+- Supprimer un arbitre ->**POST "/referees/delete-referee/"**
+{
+	id=$id
+}
+
+## JOUEURS (PlayerRestController, "/players") :
+- Lister tous les joueurs ->**GET "/players/"** -> List<PlayerBean>
+- Afficher un joueur par id ->**GET "/players/id=$id"** -> PlayerBean
+- Afficher un joueur par nom ->**GET "/players/name=$name"** -> PlayerBean
+- Ajouter un joueur ->**POST "/players/add-player"**
+{
+	name=$name,
+	firstName=$firstName
+}
+-> PlayerBean
+- Supprimer un joueur ->**POST "/players/delete-player"**
+{
+	id=$id
+}

FencerJudgeBack/TODO.txt

@@ -0,0 +1,4 @@
+corriger les services - ~
+tester les restcontrollers via des requêtes http - ~
+créer la bdd avec toutes les tables (repositories)
+tester le websocket

FencerJudgeBack/build.gradle.kts

@@ -22,10 +22,18 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
     implementation("org.jetbrains.kotlin:kotlin-reflect")
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
     developmentOnly("org.springframework.boot:spring-boot-devtools")
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+    // WEBSOCKET
+    implementation("org.springframework.boot:spring-boot-starter-websocket")
+
+    // SECURITY
+    implementation("org.springframework.boot:spring-boot-starter-security")
+
 }
 
 kotlin {

FencerJudgeBack/conception.txt

@@ -0,0 +1,269 @@
+## Websocket
+// Ouvrir channel websocket sur port 8500 --> DONE
+function startWebsocket(var integer port) -> Websocket:
+	var Websocket websocket = start Websocket at port [port]
+	return websocket
+
+## Entités
+MATCHS -> MatchBean, MatchRepository
+MatchBean:
+	- id:Long
+	- player1:PlayerBean
+	- player2:PlayerBean
+	- referee:RefereeBean
+	- score1:Int (score du player1)
+	- score2:Int (score du player2)
+	- date:String (date du match)
+	- state:String (état du match : terminé, en cours, pas commencé)
+
+REFEREES (arbitres) -> RefereeBean, RefereeRepository
+RefereeBean:
+	- id:Long
+	- name:Long (nom)
+	- firstName:String (prénom)
+
+PLAYERS -> PlayerBean, PlayerRepository
+PlayerBean:
+	- id:Long
+	- name:String (nom)
+	- firstName:String (prénom)
+	
+## Services
+MatchService --> DONE:
+	// Obtenir tous les matchs (public) --> DONE
+	function getAll() -> array<MatchBean> :
+		return MatchRepository.getAll()
+		
+	// Obtenir un match par id (public) --> DONE
+	function getById(var long id) -> MatchBean :
+		return MatchRepository.findById(id)
+		
+	// Obtenir un ou plusieurs match(s) par joueurs (id) (public) --> DONE
+	function getByPlayers(var long player1ID, var long player2ID) -> array<MatchBean> {
+		return MatchRepository.getAll().filterBy(player1ID or player2ID)
+	}
+		
+	// Ajouter un match (admin) --> DONE
+	function createMatch(var MatchBean newMatch) -> MatchBean :
+		MatchRepository.add(newMatch)
+		return newMatch
+	
+	// Modifier un match (admin) --> DONE
+	function updateMatch(var long id, var Date date, var long refereeID, var long player1ID, var long player2ID, var integer scorePlayer1, var integer scorePlayer2, var Date date, var string matchState) -> integr (success or not):
+		// Vérifier si le match existe à l'id renseigné
+		if MatchRepository.getById(id) doesn't exist {
+			return FAILED
+		}
+	
+		// Créer nouveau MatchBean à l'id renseigné
+		var MatchBean newMatch = new MatchBean(id, player1ID, player2ID, refereeID, score1, score2, date, state)
+		
+		// Supprimer le MatchBean à l'id en paramètre
+		MatchRepository.deleteById(id)
+		
+		// Insérer le nouveau MatchBean à l'id en paramètre
+		MatchRepository.add(newMatch)
+		
+		return SUCCESS
+
+	
+	// Supprimer un match (admin) --> DONE
+	function deleteMatch(var long id) -> integer (success or failure) :
+		try:
+			MatchRepository.deleteById(id)
+		catch error:
+			return FAILED
+			
+		return SUCCESS
+
+RefereeService --> DONE:
+	// Obtenir tous les arbitres (public) --> DONE
+	function getAll() -> array<RefereeBean> :
+		return RefereeRepository.getAll()
+		
+	// Obtenir un arbitre par id (public) --> DONE
+	function getById(var long id) -> RefereeBean :
+		return RefereeRepository.findById(id)
+		
+	// Obtenir un ou plusieurs arbitre(s) par nom (public) --> DONE
+	function getByName(var string name) -> array<RefereeBean> :		
+		return RefereeRepository.getAll().filterBy(name)
+		
+	// Obtenir un ou plusieurs arbitre(s) par prénom (public) 
+	function getByFirstName(var string firstName) -> array<RefereeBean> :
+		return RefereeRepository.getAll().filterBy(firstName)
+		
+	// Ajouter un arbitre (admin) --> DONE
+	function createReferee(var RefereeBean newReferee) -> RefereeBean:
+		RefereeRepository.add(newReferee)
+		return newReferee
+		
+	// Modifier un arbitre (admin) --> DONE
+	function updateReferee(var long id, var string name, var string firstName) -> integer (success or not):
+		
+		// Vérifier si l'arbitre existe à l'id renseigné
+		if RefereeRepository.getById(id) doesn't exist {
+			return FAILED
+		}
+	
+		// Créer nouveau RefereeBean à l'id renseigné
+		var RefereeBean newReferee = new RefereeBean(id, name, firstName)
+		
+		// Supprimer le RefereeBean à l'id en paramètre
+		RefereeRepository.deleteById(id)
+		
+		// Insérer le nouveau RefereeBean à l'id en paramètre
+		RefereeRepository.add(newReferee)
+		
+		return SUCCESS
+		
+		
+	// Supprimer un arbitre (admin) --> DONE
+	function delete(var long id) -> integer (success or failure) :
+		try:
+			RefereeRepository.deleteById(id)
+		catch error:
+			return FAILED
+			
+		return SUCCESS
+
+PlayerService --> DONE:
+	// Obtenir tous les joueurs (public) --> DONE
+	function getAll() -> array<PlayerBean> :
+		return PlayerRepository.getAll()
+		
+	// Obtenir un joueur par id (public) --> DONE
+	function getById(var long id) -> PlayerBean :
+		return PlayerRepository.findById(id)
+		
+	// Obtenir un ou plusieurs joueur(s) par nom (public) --> DONE
+	function getByName(var string name) -> array<PlayerBean> :
+		return PlayerRepository.getAll().filterBy(name)
+		
+	// Obtenir un ou plusieurs joueur(s) par prénom (public) --> DONE
+	function getByFirstName(var string firstName) -> array<PlayerBean> :
+		return PlayerRepository.getAll().filterBy(firstName)
+		
+	// Ajouter un joueur (admin) --> DONE
+	function add(var PlayerBean newPlayer) -> PlayerBean:
+		PlayerRepository.add(newPlayer)
+		return newPlayer
+		
+	// Modifier un joueur (admin) --> DONE
+	function update(var long id, var string name, var string firstName) -> PlayerBean :
+		// Créer nouveau PlayerBean
+		var PlayerBean newPlayer = new PlayerBean(id, name, firstName)
+		
+		// Supprimer le PlayerBean à l'id en paramètre
+		deleteById(id)
+		
+		// Insérer le nouveau PlayerBean à l'id en paramètre
+		PlayerRepository.add(newPlayer)
+		
+		return newPlayer
+
+	// Supprimer un joueur (admin) --> DONE
+	function delete(var long id) -> integer (success or failure) :
+		try:
+			PlayerRepository.deleteById(id)
+		catch error:
+			return FAILED
+		
+		return SUCCESS
+	
+## RestControllers
+MatchRestController --> TODO:
+	// Lister tous les matchs --> DONE
+	function getAll() -> array<MatchBean> :
+		return MatchService.getAll()
+		
+	// Lister tous les matchs à partir d'une certaine date
+	function getAllFromDate(var Date dateToFilter) -> array<MatchBean> : 
+		return MatchService.getAll().filter(date == dateToFilter)
+		
+	// Lister les matchs en cours (état : en cours)
+	function getAllActive() -> array<MatchBean> : 
+		return MatchService.getAll().filter(state == "ONGOING")
+		
+	// Lister les matchs terminés (état : terminé)
+	function getAllOver() -> array<MatchBean> :
+		return MatchService.getAll().filter(state == "FINISHED")
+		
+	// Lister les matchs non commencés (état : non commencé)
+	function getAllNotStarted() -> array<MatchBean> : 
+		// MatchService : 
+		return MatchService.getAll().filter(state == "NOT STARTED")
+		
+	// Afficher un match par id
+	function get(var long id) -> MatchBean :
+		return MatchService.get(id)
+		
+	// Mettre à jour le score1 d'un match récupéré par id --> TODO
+	function updateScore1Of(var long id, var integer newScore) -> integer (success or failure) :
+		return MatchService.update(
+		
+	// Mettre à jour le score2 d'un match récupéré par id --> TODO
+	function updateScore2Of(var long id, var integer newScore) -> integer (success or failure) :
+		return MatchService.update(
+		
+	// Ajouter un match (créer nouveau MatchBean dans MatchRepository)
+	function add(var MatchBean newMatch) -> integer (success or failure):
+		return MatchService.add(newMatch)
+		
+	// Supprimer un match (supprimer élément de MatchRepository en récupérant l'id)
+	function deleteById(var long id) -> integer (success or failure) : 
+		return MatchService.deleteById(id)
+
+RefereeRestController --> DONE:
+	// Lister tous les arbitres
+	function getAll() -> array<RefereeBean> : 
+		return RefereeService.getAll()
+		
+	// Afficher un arbitre par id
+	function get(var long id) -> RefereeBean : 
+		return RefereeService.get(id)
+		
+	// Afficher un arbitre par nom
+	function get(var string name) -> RefereeBean:
+		return RefereeService.get(name)
+		
+	// Ajouter un arbitre (créer nouveau RefereeBean dans RefereeRepository)
+	function add(var RefereeBean newReferee) -> integer (success or failure) :
+		return RefereeService.add(newReferee)
+		
+	// Supprimer un arbitre (supprimer élément de RefereeRepository en récupérant l'id)
+	function deleteById(var long id) -> integer (success or failure) :
+		return RefereeService.deleteById(id)
+
+PlayerRestController --> DONE:
+	// Lister tous les joueurs
+	function getAll() -> array<PlayerBean> : 
+		return PlayerService.getAll()
+		
+	// Afficher un joueur par id
+	function get(var long id) -> PlayerBean : 
+		return PlayerService.get(id)
+		
+	// Afficher un joueur par nom
+	function get(var string name) -> PlayerBean :
+		return PlayerService.get(name) 
+		
+	// Ajouter un joueur (créer nouveau PlayerBean dans PlayerRepository)
+	function add(var PlayerBean newPlayer) -> integer (success or failure) : 
+		return PlayerService.add(newPlayer)
+		
+	// Supprimer un joueur (supprimer élément de PlayerRepository en récupérant l'id)
+	function deleteById(var long id) -> integer (success or failure) : 
+		return PlayerService.deleteById(id)
+
+## Pages
+Page des matchs (publique) : 
+	à définir (partie front sur Angular ?)
+
+Page de connexion à l'administration (publique) :
+	formulaire :
+	- nom d'utilisateur
+	- mot de passe
+
+Page d'administration (privée) :
+	à définir (partie front sur Angular ?)

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

@@ -0,0 +1,19 @@
+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 player1ID:Long?=null,
+    val player2ID:Long?=null,
+    val refereeID: Long?=null,
+    val score1:Int=0,
+    val score2:Int=0,
+    val date: Date?=null
+)

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

@@ -0,0 +1,16 @@
+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
+
+@Entity
+@Table(name="players")
+data class PlayerBean(
+    @Id
+    val id:Long?=null,
+    val name:String?="",
+    val firstName:String?=""
+)

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

@@ -0,0 +1,16 @@
+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
+
+@Entity
+@Table(name="referees")
+data class RefereeBean(
+    @Id
+    val id:Long?=null,
+    val name:String?=null,
+    val firstName:String?=null
+)

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/MatchRepository.kt

@@ -0,0 +1,9 @@
+package fr.teamflash.fencerjudgeback.repositories
+
+import fr.teamflash.fencerjudgeback.entities.MatchBean
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface MatchRepository: JpaRepository<MatchBean, Long> {
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/PlayerRepository.kt

@@ -0,0 +1,9 @@
+package fr.teamflash.fencerjudgeback.repositories
+
+import fr.teamflash.fencerjudgeback.entities.PlayerBean
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface PlayerRepository: JpaRepository<PlayerBean, Long> {
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/RefereeRepository.kt

@@ -0,0 +1,10 @@
+package fr.teamflash.fencerjudgeback.repositories
+
+import fr.teamflash.fencerjudgeback.entities.RefereeBean
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface RefereeRepository : JpaRepository<RefereeBean, Long> {
+
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/MatchRestController.kt

@@ -0,0 +1,67 @@
+package fr.teamflash.fencerjudgeback.restControllers
+
+import fr.teamflash.fencerjudgeback.entities.MatchBean
+import fr.teamflash.fencerjudgeback.services.MatchService
+import org.springframework.http.HttpStatus
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import kotlin.random.Random
+
+@RestController
+@RequestMapping("/matches")
+class MatchRestController(private val matchService: MatchService) {
+
+    // Lister tous les matchs
+    @GetMapping("/")
+    fun getAll(): ResponseEntity<List<MatchBean>> {
+        return ResponseEntity.ok(matchService.getAll())
+    }
+
+    // Lister tous les matchs à partir d'une certaine date
+    @GetMapping("/{date}")
+    fun getAllFromDate(date:Date): ResponseEntity<List<MatchBean>?> {
+        return ResponseEntity.ok(matchService.getAll().filter { it.date == date })
+    }
+
+    // Lister les matchs en cours
+    @GetMapping("/active")
+    fun getAllActive(): ResponseEntity<List<MatchBean>?> {
+        return ResponseEntity.ok(matchService.getAll().filter { it.state == ACTIVE })
+    }
+
+    // Lister les matchs terminés
+    @GetMapping("/over")
+    fun getAllFinished(): ResponseEntity<List<MatchBean>?> {
+        return ResponseEntity.ok(matchService.getAll().filter {  })
+    }
+
+    // Lister les matchs non commencés
+    @GetMapping("/not-started")
+    fun getAllNotStarted(): ResponseEntity<List<MatchBean>?> {
+
+    }
+
+    // Afficher un match par id
+    @GetMapping("/{id}")
+    fun getMatchById(@PathVariable id: Long): ResponseEntity<MatchBean?> {
+        return ResponseEntity.ok(matchService.getById(id))
+    }
+
+    // Ajouter un match
+    @PostMapping("/create-match")
+    fun createMatch(@RequestBody match: MatchBean): ResponseEntity<MatchBean> {
+        return ResponseEntity.status(HttpStatus.CREATED).body(matchService.createMatch(match))
+    }
+
+    // Mettre à jour un match
+    @PutMapping("/update-match/{id}")
+    fun updateMatch(@PathVariable id: Long, @RequestBody refereeID: Long, @RequestBody): ResponseEntity<MatchBean?> {
+        return ResponseEntity.ok(matchService.updateMatch(match))
+    }
+
+    // Supprimer un match
+    @DeleteMapping("/delete-match/{id}")
+    fun deleteMatch(@PathVariable id: Long): ResponseEntity<Int> {
+        return ResponseEntity.ok(matchService.deleteMatch(id))
+    }
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/PlayerRestController.kt

@@ -0,0 +1,59 @@
+package fr.teamflash.fencerjudgeback.restControllers
+
+import fr.teamflash.fencerjudgeback.entities.PlayerBean
+import fr.teamflash.fencerjudgeback.services.PlayerService
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import java.util.Optional
+
+@RestController
+@RequestMapping("/players")
+class PlayerRestController(private val playerService: PlayerService) {
+
+    // Lister tous les joueurs
+    @GetMapping
+    fun getAll(): ResponseEntity<List<PlayerBean>> {
+        return ResponseEntity.ok(playerService.getAll())
+    }
+
+    // Afficher un joueur par id
+    @GetMapping("/{id}")
+    fun getById(id: Long): ResponseEntity<Optional<PlayerBean?>?> {
+        return ResponseEntity.ok(playerService.getById(id))
+    }
+
+    // Afficher un joueur par nom
+    @GetMapping("/{name}")
+    fun getByName(name: String): ResponseEntity<List<PlayerBean?>?> {
+        return ResponseEntity.ok(playerService.getByName(name))
+    }
+
+    // Afficher un joueur par prénom
+    @GetMapping("/{firstName}")
+    fun getByFirstName(firstName: String): ResponseEntity<List<PlayerBean?>?> {
+        return ResponseEntity.ok(playerService.getByFirstName(firstName))
+    }
+
+    // Ajouter un joueur
+    @PostMapping("/add-player")
+    fun createPlayer(player: PlayerBean): ResponseEntity<PlayerBean> {
+        return ResponseEntity.ok(playerService.createPlayer(player))
+    }
+
+    // Modifier un joueur
+    @PutMapping("/update-player")
+    fun updatePlayer(id: Long, name: String, firstName: String): ResponseEntity<Int> {
+        return ResponseEntity.ok(playerService.updatePlayer(id, name, firstName))
+    }
+
+    // Supprimer un joueur
+    @DeleteMapping("/delete-player")
+    fun deletePlayer(id: Long): ResponseEntity<Int> {
+        return ResponseEntity.ok(playerService.deletePlayer(id))
+    }
+}

FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/RefereeRestController.kt

@@ -0,0 +1,61 @@
+package fr.teamflash.fencerjudgeback.restControllers
+
+import fr.teamflash.fencerjudgeback.entities.RefereeBean
+import fr.teamflash.fencerjudgeback.services.RefereeService
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import java.util.Optional
+
+@RestController
+@RequestMapping("/referees")
+class RefereeRestController(private val refereeService: RefereeService) {
+
+    // Lister tous les arbitres
+    @GetMapping("/")
+    fun getAll() : ResponseEntity<List<RefereeBean>> {
+        return ResponseEntity.ok(refereeService.getAll())
+    }
+
+    // Afficher un arbitre par id
+    @GetMapping("/{id}")
+    fun getById(id: Long): ResponseEntity<Optional<RefereeBean?>?> {
+        return ResponseEntity.ok(refereeService.getById(id))
+    }
+
+    // Afficher un ou plusieurs arbitre(s) par nom
+    @GetMapping("/name/{name}")
+    fun getByName(name:String): ResponseEntity<List<RefereeBean?>?> {
+        return ResponseEntity.ok(refereeService.getByName(name))
+    }
+
+    // Afficher ou plusieurs arbitre(s) par prénom
+    @GetMapping("/first-name/{firstName}")
+    fun getByFirstName(firstName:String): ResponseEntity<List<RefereeBean?>?> {
+        return ResponseEntity.ok(refereeService.getByFirstName(firstName))
+    }
+
+    // Ajouter un arbitre
+    @PostMapping("/create-referee")
+    fun createReferee(referee: RefereeBean): ResponseEntity<RefereeBean> {
+        return ResponseEntity.ok(refereeService.createReferee(referee))
+    }
+
+    // Modifier un arbitre
+    @PutMapping("/update-referee/{id}")
+    fun updateReferee(@PathVariable id: Long, name: String, firstName: String) : ResponseEntity<Int> {
+        return ResponseEntity.ok(refereeService.updateReferee(id, name, firstName))
+    }
+
+    // Supprimer un arbitre
+    @DeleteMapping("/delete-referee/{id}")
+    fun deleteReferee(id:Long): ResponseEntity<Int> {
+        return ResponseEntity.ok(refereeService.deleteReferee(id))
+    }
+
+}

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

@@ -0,0 +1,104 @@
+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(
+    @Autowired private val matchRepository: MatchRepository,
+    @Lazy private val matchWebSocketController: MatchWebSocketController? = null
+) {
+    // Obtenir tous les matchs (public)
+    fun getAll() : List<MatchBean> {
+        println("MatchService.getMatchs")
+        return matchRepository.findAll()
+    }
+
+    // Obtenir un match par id (public)
+    fun getById(id:Long): MatchBean? {
+        println("MatchService.getMatchById : $id")
+        return matchRepository.findById(id).get()
+    }
+
+    // Obtenir un ou plusieurs match(s) par joueurs (id) (public)
+    fun getByPlayers(player1ID: Long, player2ID: Long): List<MatchBean> {
+        println("MatchService.getMatchByPlayers : $player1ID - $player2ID")
+        return matchRepository.findAll().filter { it.player1ID == player1ID && it.player2ID == player2ID }
+    }
+
+    // Ajouter un match (admin)
+    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)
+    }
+
+    // Modifier un match (admin)
+    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

@@ -0,0 +1,73 @@
+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(@Autowired private val playerRepository: PlayerRepository) {
+    // Obtenir tous les joueurs (public)
+    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)
+    }
+
+    // Obtenir un ou plusieurs joueur(s) par nom (public)
+    fun getByName(name:String): List<PlayerBean?>? {
+        println("RefereeService.getRefereeByName : $name")
+        return playerRepository.findAll().filter{ it.name == name }
+    }
+
+    // Obtenir un ou plusieurs joueur(s) par prénom
+    fun getByFirstName(firstName:String): List<PlayerBean?>? {
+        println("RefereeService.getRefereeByFirstName : $firstName")
+        return playerRepository.findAll().filter{ it.firstName == firstName }
+    }
+
+    // Ajouter un joueur (admin)
+    fun createPlayer(referee: PlayerBean) : PlayerBean {
+        println("RefereeService.createReferee : $referee")
+        return playerRepository.save(referee)
+    }
+
+    // Modifier un joueur (admin)
+    fun updatePlayer(id:Long, name:String, firstName: String) : Int {
+        // 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
+    }
+
+    // Supprimer un joueur (admin)
+    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

@@ -0,0 +1,74 @@
+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(@Autowired private val refereeRepository: RefereeRepository) {
+    // Obtenir tous les arbitres (public)
+    fun getAll(): List<RefereeBean> {
+        println("RefereeService.getReferees")
+        return refereeRepository.findAll()
+    }
+
+    // Obtenir un arbitre par id (public)
+    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")
+        return refereeRepository.save(referee)
+    }
+
+    // Modifier un arbitre (admin)
+    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
+    }
+
+    // Supprimer un arbitre (admin)
+    fun deleteReferee(id:Long): Int {
+        println("RefereeService.deleteReferee : $id")
+
+        if (getById(id) == null) {
+            println("RefereeService.deleteReferee : Referee not found")
+            return -1
+        }
+
+        refereeRepository.deleteById(id)
+        return 1
+    }
+}