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,18 +1,20 @@
 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
@@ -81,6 +83,92 @@ public class TournamentMapper implements DtoMapper<Tournament, TournamentDto>, E
 
     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;
+  }
+
 }