Move to new server

src/main/java/nl/connectedit/swiss/controller/TournamentController.java

@@ -0,0 +1,184 @@
+package nl.connectedit.swiss.controller;
+
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import nl.connectedit.swiss.domain.TournamentStatus;
+import nl.connectedit.swiss.domain.entity.Tournament;
+import nl.connectedit.swiss.dto.ResultDto;
+import nl.connectedit.swiss.dto.TournamentDto;
+import nl.connectedit.swiss.dto.TournamentValidationDto;
+import nl.connectedit.swiss.mapper.TournamentMapper;
+import nl.connectedit.swiss.mapper.TournamentValidationMapper;
+import nl.connectedit.swiss.service.*;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Objects;
+
+@RestController
+@CrossOrigin
+@RequiredArgsConstructor
+public class TournamentController {
+
+    private final TournamentService tournamentService;
+
+    private final TournamentMapper tournamentMapper;
+
+    private final TournamentValidationService tournamentValidationService;
+
+    private final TournamentValidationMapper tournamentValidationMapper;
+
+    private final TournamentDivideService tournamentDivideService;
+
+    private final TournamentDrawService tournamentDrawService;
+
+    private final TournamentPlayService tournamentPlayService;
+
+    @GetMapping("/tournaments")
+    public ResponseEntity<List<TournamentDto>> getTournaments(@RequestParam(value = "status", required = false) TournamentStatus status) {
+        List<Tournament> tournaments;
+
+        if (Objects.nonNull(status)) {
+            tournaments = tournamentService.findAllTournamentsWithStatus(status);
+        } else {
+            tournaments = tournamentService.findAllTournaments();
+        }
+
+        return ResponseEntity.ok(tournaments
+            .stream()
+            .map(tournamentMapper::toDto)
+            .toList());
+    }
+
+    @GetMapping("/tournaments/{id}")
+    @Transactional
+    public ResponseEntity<TournamentDto> getTournament(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        if (tournament == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournament));
+    }
+
+    @PostMapping("/tournaments")
+    public ResponseEntity<TournamentDto> createTournament(@RequestBody TournamentDto tournamentDto) {
+        var tournament = tournamentMapper.toEntity(tournamentDto);
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentService.saveTournament(tournament)));
+    }
+
+    @PutMapping("/tournaments/{id}")
+    public ResponseEntity<TournamentDto> updateTournament(@PathVariable Long id, @RequestBody TournamentDto tournamentDto) {
+        var newTournament = tournamentMapper.toEntity(tournamentDto);
+        var tournament = tournamentService.updateTournament(id, newTournament);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournament));
+    }
+
+    @GetMapping("/tournaments/{id}/validate")
+    public ResponseEntity<TournamentValidationDto> validateTournament(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        var tournamentValidation = tournamentValidationService.validate(tournament);
+
+        return ResponseEntity.ok(tournamentValidationMapper.toDto(tournamentValidation));
+    }
+
+    @PostMapping("/tournaments/{id}/divide")
+    public ResponseEntity<TournamentDto> divideTournamentNew(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentDivideService.divide(tournament)));
+    }
+
+
+    @PostMapping("/tournaments/{id}/divide/clear")
+    public ResponseEntity<TournamentDto> clearTournamentDivision(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentDivideService.clear(tournament)));
+    }
+
+    @PostMapping("/tournaments/{id}/draw")
+    public ResponseEntity<TournamentDto> drawTournament(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentDrawService.draw(tournament)));
+    }
+
+    @PostMapping("/tournaments/{id}/draw/clear")
+    public ResponseEntity<TournamentDto> clearTournamentDraw(@PathVariable Long id) {
+        var tournament = tournamentService.findTournamentById(id);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentDrawService.clear(tournament)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/rounds/{roundId}/start")
+    public ResponseEntity<TournamentDto> startRound(@PathVariable Long tournamentId, @PathVariable Long roundId) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.startRound(tournament, roundId)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/rounds/{roundId}/finish")
+    public ResponseEntity<TournamentDto> finishRound(@PathVariable Long tournamentId, @PathVariable Long roundId) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.finishRound(tournament, roundId)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/groups/{groupId}/finish")
+    public ResponseEntity<TournamentDto> finishGroup(@PathVariable Long tournamentId, @PathVariable Long groupId) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.finishGroup(tournament, groupId)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/groups/{groupId}/new")
+    public ResponseEntity<TournamentDto> newRound(@PathVariable Long tournamentId, @PathVariable Long groupId) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.newRound(tournament, groupId)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/matches/{matchId}/start/{court}")
+    public ResponseEntity<TournamentDto> startMatch(@PathVariable Long tournamentId, @PathVariable Long matchId, @PathVariable Long court) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.startMatch(tournament, matchId, court)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/matches/{matchId}/stop")
+    public ResponseEntity<TournamentDto> stopMatch(@PathVariable Long tournamentId, @PathVariable Long matchId) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.stopMatch(tournament, matchId)));
+    }
+
+    @PostMapping("/tournaments/{tournamentId}/matches/{matchId}")
+    public ResponseEntity<TournamentDto> saveResult(@PathVariable Long tournamentId, @PathVariable Long matchId, @RequestBody ResultDto resultDto) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.saveResult(tournament, matchId, resultDto)));
+    }
+
+    @PatchMapping("/tournaments/{tournamentId}/players/{playerId}/paid/{paid}")
+    public ResponseEntity<Void> updatePaid(@PathVariable Long tournamentId, @PathVariable Long playerId, @PathVariable Boolean paid) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        tournamentPlayService.updatePaid(tournament, playerId, paid);
+
+        return ResponseEntity.noContent().build();
+    }
+
+    @PatchMapping("/tournaments/{tournamentId}/players/{playerId}/present/{present}")
+    public ResponseEntity<Void> updatePresent(@PathVariable Long tournamentId, @PathVariable Long playerId, @PathVariable Boolean present) {
+        var tournament = tournamentService.findTournamentById(tournamentId);
+
+        tournamentPlayService.updatePresent(tournament, playerId, present);
+
+        return ResponseEntity.noContent().build();
+    }
+}