Moved logic to backend

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

@@ -34,4 +34,10 @@ public class TournamentDto extends AbstractDto {
 
     private List<TournamentPlayerSubstitutionDto> substitutions;
 
+    private List<Long> playersPlaying;
+
+    private List<Long> playersCounting;
+
+    private List<Long> playersAvailable;
+
 }

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

@@ -1,86 +1,174 @@
 package nl.connectedit.swiss.mapper;
 
 import lombok.RequiredArgsConstructor;
+import nl.connectedit.swiss.domain.EventType;
+import nl.connectedit.swiss.domain.Status;
 import nl.connectedit.swiss.domain.TournamentStatus;
-import nl.connectedit.swiss.domain.entity.Event;
+import nl.connectedit.swiss.domain.entity.*;
-import nl.connectedit.swiss.domain.entity.Tournament;
-import nl.connectedit.swiss.domain.entity.TournamentPlayer;
 import nl.connectedit.swiss.dto.TournamentDto;
 import org.springframework.stereotype.Component;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
+import java.util.stream.Collectors;
 
 @Component
 @RequiredArgsConstructor
 public class TournamentMapper implements DtoMapper<Tournament, TournamentDto>, EntityMapper<TournamentDto, Tournament> {
 
-    private final EventMapper eventMapper;
+  private final EventMapper eventMapper;
 
-    private final TournamentPlayerMapper tournamentPlayerMapper;
+  private final TournamentPlayerMapper tournamentPlayerMapper;
 
-    @Override
+  @Override
-    public Tournament toEntity(TournamentDto tournamentDto) {
+  public Tournament toEntity(TournamentDto tournamentDto) {
-        Tournament tournament = new Tournament();
+    Tournament tournament = new Tournament();
-        tournament.setId(tournamentDto.getId());
+    tournament.setId(tournamentDto.getId());
-        tournament.setName(tournamentDto.getName());
+    tournament.setName(tournamentDto.getName());
-        tournament.setDate(LocalDate.parse(tournamentDto.getDate(), DateTimeFormatter.ofPattern("dd-MM-yyyy")));
+    tournament.setDate(LocalDate.parse(tournamentDto.getDate(), DateTimeFormatter.ofPattern("dd-MM-yyyy")));
-        tournament.setStatus(
+    tournament.setStatus(
-          Arrays.stream(TournamentStatus.values())
+      Arrays.stream(TournamentStatus.values())
-            .filter(ts -> ts.getText().equals(tournamentDto.getStatus()))
+        .filter(ts -> ts.getText().equals(tournamentDto.getStatus()))
-            .findFirst()
+        .findFirst()
-            .orElse(TournamentStatus.UPCOMING)
+        .orElse(TournamentStatus.UPCOMING)
-        );
+    );
-        tournament.setActive(tournamentDto.getActive());
+    tournament.setActive(tournamentDto.getActive());
-        tournament.setMaxEvents(tournamentDto.getMaxEvents());
+    tournament.setMaxEvents(tournamentDto.getMaxEvents());
-        tournament.setCostsPerEvent(tournamentDto.getCostsPerEvent());
+    tournament.setCostsPerEvent(tournamentDto.getCostsPerEvent());
-        tournament.setCourts(tournamentDto.getCourts());
+    tournament.setCourts(tournamentDto.getCourts());
 
-        return tournament;
+    return tournament;
+  }
+
+  @Override
+  public TournamentDto toDto(Tournament tournament) {
+    TournamentDto tournamentDto = new TournamentDto();
+    tournamentDto.setId(tournament.getId());
+    tournamentDto.setName(tournament.getName());
+    tournamentDto.setDate(tournament.getDate().format(DateTimeFormatter.ofPattern("dd-MM-yyyy")));
+    tournamentDto.setStatus(tournament.getStatus().name());
+    tournamentDto.setActive(tournament.getActive());
+    tournamentDto.setEvents(
+      tournament.getEvents()
+        .stream()
+        .sorted(Comparator.comparing(Event::getType))
+        .map(eventMapper::toDto)
+        .toList()
+    );
+
+    if (tournament.getTournamentPlayers() != null) {
+      var tournamentPlayers = tournament.getTournamentPlayers();
+
+      tournamentPlayers.sort(Comparator.comparing((TournamentPlayer tournamentPlayer) -> tournamentPlayer.getPlayer().getLastName())
+        .thenComparing((TournamentPlayer tournamentPlayer) -> tournamentPlayer.getPlayer().getFirstName()));
+
+      tournamentDto.setTournamentPlayers(tournamentPlayers
+        .stream()
+        .map(tournamentPlayerMapper::toDto)
+        .toList()
+      );
     }
 
-    @Override
+    tournamentDto.setMaxEvents(tournament.getMaxEvents() == null ? 2L : tournament.getMaxEvents());
-    public TournamentDto toDto(Tournament tournament) {
-        TournamentDto tournamentDto = new TournamentDto();
-        tournamentDto.setId(tournament.getId());
-        tournamentDto.setName(tournament.getName());
-        tournamentDto.setDate(tournament.getDate().format(DateTimeFormatter.ofPattern("dd-MM-yyyy")));
-        tournamentDto.setStatus(tournament.getStatus().name());
-        tournamentDto.setActive(tournament.getActive());
-        tournamentDto.setEvents(
-          tournament.getEvents()
-            .stream()
-            .sorted(Comparator.comparing(Event::getType))
-            .map(eventMapper::toDto)
-            .toList()
-        );
 
-        if (tournament.getTournamentPlayers() != null) {
+    if (tournament.getCostsPerEvent() == null || tournament.getCostsPerEvent().isEmpty()) {
-            var tournamentPlayers = tournament.getTournamentPlayers();
+      tournamentDto.setCostsPerEvent(List.of(0f, 0f, 0f));
-
+    } else {
-            tournamentPlayers.sort(Comparator.comparing((TournamentPlayer tournamentPlayer) -> tournamentPlayer.getPlayer().getLastName())
+      tournamentDto.setCostsPerEvent(tournament.getCostsPerEvent());
-              .thenComparing((TournamentPlayer tournamentPlayer) -> tournamentPlayer.getPlayer().getFirstName()));
-
-            tournamentDto.setTournamentPlayers(tournamentPlayers
-              .stream()
-              .map(tournamentPlayerMapper::toDto)
-              .toList()
-            );
-        }
-
-        tournamentDto.setMaxEvents(tournament.getMaxEvents() == null ? 2L : tournament.getMaxEvents());
-
-        if (tournament.getCostsPerEvent() == null || tournament.getCostsPerEvent().isEmpty()) {
-            tournamentDto.setCostsPerEvent(List.of(0f, 0f, 0f));
-        } else {
-            tournamentDto.setCostsPerEvent(tournament.getCostsPerEvent());
-        }
-
-        tournamentDto.setCourts(tournament.getCourts() == null ? 1L : tournament.getCourts());
-
-        return tournamentDto;
     }
+
+    tournamentDto.setCourts(tournament.getCourts() == null ? 1L : tournament.getCourts());
+
+    tournamentDto.setPlayersCounting(getPlayersCounting(tournament));
+    tournamentDto.setPlayersPlaying(getPlayersPlaying(tournament));
+    tournamentDto.setPlayersAvailable(getPlayersAvailable(tournament));
+
+    return tournamentDto;
+  }
+
+  private List<Long> getPlayersCounting(Tournament tournament) {
+    var playersCounting = new ArrayList<Long>();
+
+    for (var event : tournament.getEvents()) {
+      for (var group : event.getGroups()) {
+        for (var round : group.getRounds()) {
+          for (var match : round.getMatches()) {
+            if (match.getStatus() == Status.IN_PROGRESS) {
+              var counter = getTournamentPlayerFromPlayerId(tournament, match.getCounter().getId());
+              if (counter != null) {
+                playersCounting.add(counter.getId());
+              }
+            }
+          }
+        }
+      }
+    }
+    return playersCounting;
+  }
+
+  private List<Long> getPlayersPlaying(Tournament tournament) {
+    var playersPlaying = new ArrayList<Long>();
+
+    for (var event : tournament.getEvents()) {
+      for (var group : event.getGroups()) {
+        for (var round : group.getRounds()) {
+          for (var match : round.getMatches()) {
+            if (match.getStatus() == Status.IN_PROGRESS) {
+              playersPlaying.addAll(getPlayersInMatch(tournament, match));
+            }
+          }
+        }
+      }
+    }
+
+    return playersPlaying;
+  }
+
+  private List<Long> getPlayersAvailable(Tournament tournament) {
+    var playersAvailable = tournament.getTournamentPlayers()
+      .stream()
+      .map(TournamentPlayer::getId)
+      .collect(Collectors.toCollection(ArrayList::new));
+
+    playersAvailable.removeAll(getPlayersCounting(tournament));
+    playersAvailable.removeAll(getPlayersPlaying(tournament));
+
+    return playersAvailable;
+  }
+
+  private List<Long> getPlayersInMatch(Tournament tournament, Match match) {
+    var playersInMatch = new ArrayList<Long>();
+    playersInMatch.add(getPlayerOrSubstitute(tournament, match.getTeam1().getPlayer1(), match.getType()).getId());
+    playersInMatch.add(getPlayerOrSubstitute(tournament, match.getTeam2().getPlayer1(), match.getType()).getId());
+    if (match.getType().isDoublesEvent()) {
+      playersInMatch.add(getPlayerOrSubstitute(tournament, match.getTeam1().getPlayer2(), match.getType()).getId());
+      playersInMatch.add(getPlayerOrSubstitute(tournament, match.getTeam2().getPlayer2(), match.getType()).getId());
+    }
+
+    return playersInMatch;
+  }
+
+  private TournamentPlayer getPlayerOrSubstitute(Tournament tournament, Player player, EventType type) {
+    var tournamentPlayer = getTournamentPlayerFromPlayerId(tournament, player.getId());
+    for (var substitution : tournamentPlayer.getSubstitutions()) {
+      if (substitution.getEvent().getType() == type && substitution.getSubstitute() != null) {
+        return substitution.getSubstitute();
+      }
+    }
+    return tournamentPlayer;
+  }
+
+  private TournamentPlayer getTournamentPlayerFromPlayerId(Tournament tournament, Long playerId) {
+    for (var tournamentPlayer : tournament.getTournamentPlayers()) {
+      if (tournamentPlayer.getPlayer().getId().equals(playerId)) {
+        return tournamentPlayer;
+      }
+    }
+    return null;
+  }
+
 }