Invallers

TODO

@@ -35,4 +35,6 @@ ALTER TABLE tournament_player
  ADD counts bigint;
 
 UPDATE tournament_player SET counting = false;
-UPDATE tournament_player SET counts = 0;
+UPDATE tournament_player SET counts = 0;
+
+tournament_player.substitute_id + constraint

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

@@ -196,10 +196,10 @@ public class TournamentController {
         return ResponseEntity.noContent().build();
     }
 
-    @PostMapping("/tournaments/{tournamentId}/players/{playerId}/substitute/{substituteId}")
+    @PostMapping("/tournaments/{tournamentId}/players/{playerId}/event/{eventId}/substitute/{substituteId}")
-    public ResponseEntity<TournamentDto> substitutePlayer(@PathVariable Long tournamentId, @PathVariable Long playerId, @PathVariable Long substituteId) {
+    public ResponseEntity<TournamentDto> substitutePlayer(@PathVariable Long tournamentId, @PathVariable Long playerId, @PathVariable Long eventId, @PathVariable Long substituteId) {
       var tournament = tournamentService.findTournamentById(tournamentId);
 
-      return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.substitutePlayer(tournament, playerId, substituteId)));
+      return ResponseEntity.ok(tournamentMapper.toDto(tournamentPlayService.substitutePlayer(tournament, eventId, playerId, substituteId)));
     }
 }

src/main/java/nl/connectedit/swiss/domain/entity/TournamentPlayer.java

@@ -33,6 +33,9 @@ public class TournamentPlayer extends AbstractEntity {
 
   private Long counts = 0L;
 
+  @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+  private List<TournamentPlayerSubstitution> substitutions;
+
   public void incrementCounts() {
     this.counts++;
   }

src/main/java/nl/connectedit/swiss/domain/entity/TournamentPlayerSubstitution.java

@@ -0,0 +1,28 @@
+package nl.connectedit.swiss.domain.entity;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Entity
+@Table
+@Getter
+@Setter
+public class TournamentPlayerSubstitution extends AbstractEntity {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  @ManyToOne
+  private TournamentPlayer tournamentPlayer;
+
+  @ManyToOne
+  private Event event;
+
+  @ManyToOne
+  private TournamentPlayer substitute;
+
+}

src/main/java/nl/connectedit/swiss/dto/TournamentDto.java

@@ -3,6 +3,7 @@ package nl.connectedit.swiss.dto;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Getter;
 import lombok.Setter;
+import nl.connectedit.swiss.domain.entity.TournamentPlayerSubstitution;
 
 import java.util.List;
 
@@ -31,4 +32,6 @@ public class TournamentDto extends AbstractDto {
 
     private Boolean active;
 
+    private List<TournamentPlayerSubstitutionDto> substitutions;
+
 }

src/main/java/nl/connectedit/swiss/dto/TournamentPlayerDto.java

@@ -24,4 +24,6 @@ public class TournamentPlayerDto extends AbstractDto {
 
     private Long counts;
 
+    private List<TournamentPlayerSubstitutionDto> substitutions;
+
 }

src/main/java/nl/connectedit/swiss/dto/TournamentPlayerSubstitutionDto.java

@@ -0,0 +1,15 @@
+package nl.connectedit.swiss.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class TournamentPlayerSubstitutionDto extends AbstractDto {
+
+  private Long substitutionId;
+
+  private String event;
+
+  private TournamentPlayerDto substitute;
+}

src/main/java/nl/connectedit/swiss/mapper/TournamentPlayerMapper.java

@@ -3,8 +3,10 @@ package nl.connectedit.swiss.mapper;
 import lombok.RequiredArgsConstructor;
 import nl.connectedit.swiss.domain.entity.Team;
 import nl.connectedit.swiss.domain.entity.TournamentPlayer;
+import nl.connectedit.swiss.domain.entity.TournamentPlayerSubstitution;
 import nl.connectedit.swiss.dto.TeamDto;
 import nl.connectedit.swiss.dto.TournamentPlayerDto;
+import nl.connectedit.swiss.dto.TournamentPlayerSubstitutionDto;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
@@ -23,7 +25,24 @@ public class TournamentPlayerMapper implements DtoMapper<TournamentPlayer, Tourn
     tournamentPlayerDto.setPresent(tournamentPlayer.isPresent());
     tournamentPlayerDto.setCounting(tournamentPlayer.isCounting());
     tournamentPlayerDto.setCounts(tournamentPlayer.getCounts());
+    if (tournamentPlayer.getSubstitutions() != null) {
+      tournamentPlayerDto.setSubstitutions(
+        tournamentPlayer.getSubstitutions()
+          .stream()
+          .map(this::mapSubstitution)
+          .toList());
+    }
 
     return tournamentPlayerDto;
   }
+
+  private TournamentPlayerSubstitutionDto mapSubstitution(TournamentPlayerSubstitution tournamentPlayerSubstitution) {
+    var tournamentPlayerSubstitutionDto = new TournamentPlayerSubstitutionDto();
+    tournamentPlayerSubstitutionDto.setEvent(tournamentPlayerSubstitution.getEvent().getType().name());
+    if (tournamentPlayerSubstitution.getSubstitute() != null) {
+      tournamentPlayerSubstitutionDto.setSubstitute(toDto(tournamentPlayerSubstitution.getSubstitute()));
+    }
+
+    return tournamentPlayerSubstitutionDto;
+  }
 }

src/main/java/nl/connectedit/swiss/service/RegistrationService.java

@@ -53,11 +53,19 @@ public class RegistrationService {
   private void removeEventFromTournamentPlayer(Tournament tournament, Player player, Event event) {
     var tournamentPlayer = findOrAddTournamentPlayer(tournament, player);
     tournamentPlayer.getEvents().removeIf(eventType -> eventType.equals(event.getType().name()));
+    tournamentPlayer.getSubstitutions().removeIf(substitution -> substitution.getEvent().equals(event));
   }
 
   private void addEventToTournamentPlayer(Tournament tournament, Player player, Event event) {
     var tournamentPlayer = findOrAddTournamentPlayer(tournament, player);
     tournamentPlayer.getEvents().add(event.getType().name());
+    if (tournamentPlayer.getSubstitutions() == null) {
+      tournamentPlayer.setSubstitutions(new ArrayList<>());
+    }
+    var substitution = new TournamentPlayerSubstitution();
+    substitution.setEvent(event);
+    substitution.setSubstitute(null);
+    tournamentPlayer.getSubstitutions().add(substitution);
   }
 
   private TournamentPlayer findOrAddTournamentPlayer(Tournament tournament, Player player) {

src/main/java/nl/connectedit/swiss/service/TournamentPlayService.java

@@ -183,10 +183,32 @@ public class TournamentPlayService {
     }
   }
 
-  public Tournament substitutePlayer(Tournament tournament, Long playerId, Long substituteId) {
+  public Tournament substitutePlayer(Tournament tournament, Long eventId, Long playerId, Long substituteId) {
+    var event = getEvent(tournament, eventId);
+    var tournamentPlayer = getTournamentPlayer(tournament, playerId);
+    var substitute = getTournamentPlayer(tournament, substituteId);
+
+    var substitution = new TournamentPlayerSubstitution();
+    substitution.setEvent(event);
+    substitution.setTournamentPlayer(tournamentPlayer);
+    substitution.setSubstitute(substitute);
+
+    tournamentPlayer.getSubstitutions().add(substitution); //TODO
+
+    tournamentRepository.save(tournament);
     return tournament;
   }
 
+  private Event getEvent(Tournament tournament, Long eventId) {
+    for (var event : tournament.getEvents()) {
+      if (event.getId().equals(eventId)) {
+        return event;
+      }
+    }
+    return null;
+  }
+
+
   private static class ConflictInDrawException extends RuntimeException {}
 
   private List<Match> tryMatches(List<Team> remainingTeams, Group group) {
@@ -251,7 +273,7 @@ public class TournamentPlayService {
     match.setStartTime(LocalDateTime.now());
     match.setCourt(court);
 
-    var countingPlayer = getPlayer(tournament, counter);
+    var countingPlayer = getTournamentPlayer(tournament, counter);
     countingPlayer.setCounting(true);
     match.setCounter(countingPlayer.getPlayer());
 
@@ -259,7 +281,7 @@ public class TournamentPlayService {
     return tournament;
   }
 
-  private TournamentPlayer getPlayer(Tournament tournament, Long playerId) {
+  private TournamentPlayer getTournamentPlayer(Tournament tournament, Long playerId) {
     for (var tournamentPlayer : tournament.getTournamentPlayers()) {
       if (playerId.equals(tournamentPlayer.getPlayer().getId())) {
         return tournamentPlayer;
@@ -274,7 +296,7 @@ public class TournamentPlayService {
     match.setStartTime(null);
     match.setCourt(null);
 
-    var countingPlayer = getPlayer(tournament, match.getCounter().getId());
+    var countingPlayer = getTournamentPlayer(tournament, match.getCounter().getId());
     countingPlayer.setCounting(false);
     match.setCounter(null);
 
@@ -294,7 +316,7 @@ public class TournamentPlayService {
 
     var counter = match.getCounter();
     if (counter != null) { // match was already saved, this is a correction
-      var countingPlayer = getPlayer(tournament, counter.getId());
+      var countingPlayer = getTournamentPlayer(tournament, counter.getId());
       countingPlayer.setCounting(false);
       countingPlayer.incrementCounts();
       match.setCounter(null);