diff --git a/.idea/misc.xml b/.idea/misc.xml index 639900d..a7e1300 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,5 +1,9 @@ + + + + diff --git a/.idea/modules.xml b/.idea/modules.xml index 2db4f39..6ad2b6b 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,6 @@ - diff --git a/FencerJudgeBack/README.md b/FencerJudgeBack/README.md new file mode 100644 index 0000000..b1fb3c6 --- /dev/null +++ b/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 +- Lister tous les matches à partir d'une certaine date -> **GET "/matches/date=&date"** -> List +- Lister les matches en cours (état : en cours) -> **GET "/matches/active"** -> List +- Lister les matches terminés (état : terminé) -> **GET "/matches/over"** -> List +- Lister les matches non commencés (état : non commencé) -> **GET "/matches/not-started"** -> List +- 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 +- 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 +- 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 +} diff --git a/FencerJudgeBack/TODO.txt b/FencerJudgeBack/TODO.txt new file mode 100644 index 0000000..d5b5baa --- /dev/null +++ b/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 \ No newline at end of file diff --git a/FencerJudgeBack/build.gradle.kts b/FencerJudgeBack/build.gradle.kts index 729b120..4962b18 100644 --- a/FencerJudgeBack/build.gradle.kts +++ b/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 { diff --git a/FencerJudgeBack/conception.txt b/FencerJudgeBack/conception.txt new file mode 100644 index 0000000..02a822b --- /dev/null +++ b/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 : + 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 { + 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 : + 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 : + return RefereeRepository.getAll().filterBy(name) + + // Obtenir un ou plusieurs arbitre(s) par prénom (public) + function getByFirstName(var string firstName) -> array : + 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 : + 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 : + return PlayerRepository.getAll().filterBy(name) + + // Obtenir un ou plusieurs joueur(s) par prénom (public) --> DONE + function getByFirstName(var string firstName) -> array : + 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 : + return MatchService.getAll() + + // Lister tous les matchs à partir d'une certaine date + function getAllFromDate(var Date dateToFilter) -> array : + return MatchService.getAll().filter(date == dateToFilter) + + // Lister les matchs en cours (état : en cours) + function getAllActive() -> array : + return MatchService.getAll().filter(state == "ONGOING") + + // Lister les matchs terminés (état : terminé) + function getAllOver() -> array : + return MatchService.getAll().filter(state == "FINISHED") + + // Lister les matchs non commencés (état : non commencé) + function getAllNotStarted() -> array : + // 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 : + 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 : + 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 ?) \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/MatchBean.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/MatchBean.kt new file mode 100644 index 0000000..3955ef5 --- /dev/null +++ b/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 +) diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/PlayerBean.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/PlayerBean.kt new file mode 100644 index 0000000..f349348 --- /dev/null +++ b/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?="" +) \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/RefereeBean.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/entities/RefereeBean.kt new file mode 100644 index 0000000..5511a69 --- /dev/null +++ b/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 +) \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/MatchRepository.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/MatchRepository.kt new file mode 100644 index 0000000..728d059 --- /dev/null +++ b/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 { +} \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/PlayerRepository.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/PlayerRepository.kt new file mode 100644 index 0000000..ee1eefe --- /dev/null +++ b/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 { +} \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/RefereeRepository.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/repositories/RefereeRepository.kt new file mode 100644 index 0000000..102c985 --- /dev/null +++ b/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 { + +} \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/MatchRestController.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/MatchRestController.kt new file mode 100644 index 0000000..1775fc4 --- /dev/null +++ b/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> { + return ResponseEntity.ok(matchService.getAll()) + } + + // Lister tous les matchs à partir d'une certaine date + @GetMapping("/{date}") + fun getAllFromDate(date:Date): ResponseEntity?> { + return ResponseEntity.ok(matchService.getAll().filter { it.date == date }) + } + + // Lister les matchs en cours + @GetMapping("/active") + fun getAllActive(): ResponseEntity?> { + return ResponseEntity.ok(matchService.getAll().filter { it.state == ACTIVE }) + } + + // Lister les matchs terminés + @GetMapping("/over") + fun getAllFinished(): ResponseEntity?> { + return ResponseEntity.ok(matchService.getAll().filter { }) + } + + // Lister les matchs non commencés + @GetMapping("/not-started") + fun getAllNotStarted(): ResponseEntity?> { + + } + + // Afficher un match par id + @GetMapping("/{id}") + fun getMatchById(@PathVariable id: Long): ResponseEntity { + return ResponseEntity.ok(matchService.getById(id)) + } + + // Ajouter un match + @PostMapping("/create-match") + fun createMatch(@RequestBody match: MatchBean): ResponseEntity { + 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 { + return ResponseEntity.ok(matchService.updateMatch(match)) + } + + // Supprimer un match + @DeleteMapping("/delete-match/{id}") + fun deleteMatch(@PathVariable id: Long): ResponseEntity { + return ResponseEntity.ok(matchService.deleteMatch(id)) + } +} diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/PlayerRestController.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/PlayerRestController.kt new file mode 100644 index 0000000..a32d39b --- /dev/null +++ b/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> { + return ResponseEntity.ok(playerService.getAll()) + } + + // Afficher un joueur par id + @GetMapping("/{id}") + fun getById(id: Long): ResponseEntity?> { + return ResponseEntity.ok(playerService.getById(id)) + } + + // Afficher un joueur par nom + @GetMapping("/{name}") + fun getByName(name: String): ResponseEntity?> { + return ResponseEntity.ok(playerService.getByName(name)) + } + + // Afficher un joueur par prénom + @GetMapping("/{firstName}") + fun getByFirstName(firstName: String): ResponseEntity?> { + return ResponseEntity.ok(playerService.getByFirstName(firstName)) + } + + // Ajouter un joueur + @PostMapping("/add-player") + fun createPlayer(player: PlayerBean): ResponseEntity { + return ResponseEntity.ok(playerService.createPlayer(player)) + } + + // Modifier un joueur + @PutMapping("/update-player") + fun updatePlayer(id: Long, name: String, firstName: String): ResponseEntity { + return ResponseEntity.ok(playerService.updatePlayer(id, name, firstName)) + } + + // Supprimer un joueur + @DeleteMapping("/delete-player") + fun deletePlayer(id: Long): ResponseEntity { + return ResponseEntity.ok(playerService.deletePlayer(id)) + } +} diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/RefereeRestController.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/restControllers/RefereeRestController.kt new file mode 100644 index 0000000..01216cc --- /dev/null +++ b/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> { + return ResponseEntity.ok(refereeService.getAll()) + } + + // Afficher un arbitre par id + @GetMapping("/{id}") + fun getById(id: Long): ResponseEntity?> { + return ResponseEntity.ok(refereeService.getById(id)) + } + + // Afficher un ou plusieurs arbitre(s) par nom + @GetMapping("/name/{name}") + fun getByName(name:String): ResponseEntity?> { + return ResponseEntity.ok(refereeService.getByName(name)) + } + + // Afficher ou plusieurs arbitre(s) par prénom + @GetMapping("/first-name/{firstName}") + fun getByFirstName(firstName:String): ResponseEntity?> { + return ResponseEntity.ok(refereeService.getByFirstName(firstName)) + } + + // Ajouter un arbitre + @PostMapping("/create-referee") + fun createReferee(referee: RefereeBean): ResponseEntity { + return ResponseEntity.ok(refereeService.createReferee(referee)) + } + + // Modifier un arbitre + @PutMapping("/update-referee/{id}") + fun updateReferee(@PathVariable id: Long, name: String, firstName: String) : ResponseEntity { + return ResponseEntity.ok(refereeService.updateReferee(id, name, firstName)) + } + + // Supprimer un arbitre + @DeleteMapping("/delete-referee/{id}") + fun deleteReferee(id:Long): ResponseEntity { + return ResponseEntity.ok(refereeService.deleteReferee(id)) + } + +} diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/MatchService.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/MatchService.kt new file mode 100644 index 0000000..0257fa7 --- /dev/null +++ b/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 { + 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 { + 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 + } +} diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/PlayerService.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/PlayerService.kt new file mode 100644 index 0000000..2d5858a --- /dev/null +++ b/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 { + println("RefereeService.getReferees") + return playerRepository.findAll() + } + + // Obtenir un joueur par id (public) + fun getById(id:Long) : Optional { + println("RefereeService.getRefereeById : $id") + return playerRepository.findById(id) + } + + // Obtenir un ou plusieurs joueur(s) par nom (public) + fun getByName(name:String): List? { + 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? { + 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 + } +} \ No newline at end of file diff --git a/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/RefereeService.kt b/FencerJudgeBack/src/main/kotlin/fr/teamflash/fencerjudgeback/services/RefereeService.kt new file mode 100644 index 0000000..8d169ad --- /dev/null +++ b/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 { + println("RefereeService.getReferees") + return refereeRepository.findAll() + } + + // Obtenir un arbitre par id (public) + fun getById(id:Long) : Optional { + println("RefereeService.getRefereeById : $id") + return refereeRepository.findById(id) + } + + // Obtenir un ou plusieurs arbitre(s) par nom (public) + fun getByName(name:String): List? { + 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? { + 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 + } +} \ No newline at end of file