diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java b/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java
index e9503e4b8e1c1d865818325748fbaee88b218898..3fae9fce518c2e5c75186311b41234477be6347c 100644
--- a/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java
@@ -2,7 +2,9 @@ package hdm.mi.sthbackend.service;
import hdm.mi.sthbackend.dto.PlayerDTO;
import hdm.mi.sthbackend.dto.TeamDTO;
+import hdm.mi.sthbackend.dto.TournamentDTO;
import hdm.mi.sthbackend.exeptions.*;
+import hdm.mi.sthbackend.mapper.ModelToDTOMapper;
import hdm.mi.sthbackend.model.Match;
import hdm.mi.sthbackend.model.Player;
import hdm.mi.sthbackend.model.Team;
@@ -14,6 +16,7 @@ import hdm.mi.sthbackend.repository.ITournamentRepository;
import lombok.AllArgsConstructor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
@@ -22,14 +25,17 @@ import java.util.*;
@AllArgsConstructor
public class TournamentService {
- private final static Logger log = LogManager.getLogger(TournamentService.class);
+ private final Logger log = LogManager.getLogger(TournamentService.class);
ITournamentRepository tournamentRepository;
IPlayerRepository playerRepository;
ITeamRepository teamRepository;
IMatchRepository matchRepository;
- public Player addPlayerToTeam(UUID teamId,
+ @Autowired
+ ModelToDTOMapper mapper;
+
+ public PlayerDTO addPlayerToTeam(UUID teamId,
String playerName) throws TeamIdNotFoundException {
Team team = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
@@ -41,14 +47,14 @@ public class TournamentService {
playerRepository.insert(newPlayer);
teamRepository.save(team);
log.debug("Player " + newPlayer.getPlayerId() + " added to Team " + teamId);
- return newPlayer;
+ return mapper.mapToPlayerDTO(newPlayer);
}
public PlayerDTO findPlayerById(UUID playerId) throws PlayerIdNotFoundException {
Player player = playerRepository.findById(playerId)
.orElseThrow(() -> new PlayerIdNotFoundException(playerId));
- return new PlayerDTO(player.getPlayerId(), player.getName());
+ return mapper.mapToPlayerDTO(player);
}
/*
@@ -74,7 +80,7 @@ public class TournamentService {
teamRepository.save(team);
log.debug("Player " + playerId + " removed from Team " + teamId);
- return new PlayerDTO(playerToDelete.getPlayerId(), playerToDelete.getName());
+ return mapper.mapToPlayerDTO(playerToDelete);
}
/*
@@ -101,10 +107,10 @@ public class TournamentService {
forEach(pId -> playerRepository.findById(pId)
.ifPresent(p -> teamMembers.put(p.getPlayerId(), new PlayerDTO(p.getPlayerId(), p.getName()))));
- return new TeamDTO(team.getId(), team.getTeamName(), teamMembers);
+ return mapper.mapToTeamDTO(team);
}
- public Team createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
+ public TeamDTO createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -115,7 +121,7 @@ public class TournamentService {
teamRepository.insert(newTeam);
tournamentRepository.save(tournament);
- return newTeam;
+ return mapper.mapToTeamDTO(newTeam);
}
public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId,
@@ -137,64 +143,44 @@ public class TournamentService {
return teamId;
}
- public Tournament createTournament(String tournamentName) {
+ public TournamentDTO createTournament(String tournamentName) {
Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new ArrayList<>());
tournamentRepository.insert(tournament);
log.debug("created Tournament " + tournament.getTournamentId());
- return tournament;
+ return mapper.mapToTournamentDTO(tournament);
}
- public UUID determineWinner (UUID tournamentId, UUID matchId) throws TournamentIdNotFoundException, MatchIdNotFoundException, WinnerNotDeterminedException {
-
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
-
- Match match = tournament.getMatches().stream()
- .filter(m -> m.getMatchId().equals(matchId))
- .findFirst()
- .orElseThrow(() -> new MatchIdNotFoundException(matchId));
+ public UUID determineWinner (UUID matchId) throws MatchIdNotFoundException, WinnerNotDeterminedException {
+ Match match = matchRepository.findById(matchId).orElseThrow(() -> new MatchIdNotFoundException(matchId));
UUID winnerTeamId = match.getTeamScores().entrySet().stream()
.max(Comparator.comparing(Map.Entry::getKey))
.map(Map.Entry::getKey)
- .orElseThrow(() -> new WinnerNotDeterminedException(matchId,tournamentId));
+ .orElseThrow(() -> new WinnerNotDeterminedException(matchId));
match.setWinnerTeamId(winnerTeamId);
- tournamentRepository.save(tournament);
- log.debug("The Winner " + winnerTeamId + " is determined for Match " + matchId + " in Tournament " + tournamentId);
+ matchRepository.save(match);
+ log.debug("The Winner " + winnerTeamId + " is determined for Match " + matchId);
return winnerTeamId;
}
public void assignTeamToMatch(UUID tournamentId, UUID matchId, UUID teamId, int score) throws TournamentIdNotFoundException, MatchIdNotFoundException {
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
-
- Match match = tournament.getMatches().stream()
- .filter(m -> m.getMatchId().equals(matchId))
- .findFirst()
- .orElseThrow(() -> new MatchIdNotFoundException(matchId));
-
+ Match match = matchRepository.findById(matchId).orElseThrow(() -> new MatchIdNotFoundException(matchId));
match.getTeamScores().put(teamId,score);
- tournamentRepository.save(tournament);
+ matchRepository.save(match);
log.debug("Team " + teamId + " assign to Match " + matchId + " in Tournament " + tournamentId);
}
public void updateTeamScore(UUID tournamentId, UUID matchId, UUID teamId, int newScore)throws TournamentIdNotFoundException, MatchIdNotFoundException, TeamIdNotFoundException{
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
-
- Match match = tournament.getMatches().stream()
- .filter(m -> m.getMatchId().equals(matchId))
- .findFirst()
- .orElseThrow(() -> new MatchIdNotFoundException(matchId));
+ Match match = matchRepository.findById(matchId).orElseThrow(() -> new MatchIdNotFoundException(matchId));
if (!match.getTeamScores().containsKey(teamId)) {
throw new TeamIdNotFoundException(teamId);
}
match.getTeamScores().put(teamId, newScore);
- tournamentRepository.save(tournament);
+ matchRepository.save(match);
log.debug("Score of Team " + teamId + " updated to " + newScore);
}
@@ -217,12 +203,12 @@ public class TournamentService {
log.debug("Tournament Name for TournamentID " + tournamentId + " updated to " + newTournamentName);
return tournamentId;
}
- public Tournament getTournament(UUID tournamentId) throws TournamentIdNotFoundException {
+ public TournamentDTO getTournament(UUID tournamentId) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
log.debug(tournament + "is found");
- return tournament;
+ return mapper.mapToTournamentDTO(tournament);
}
public void deleteTournament(UUID tournamentId) throws TournamentIdNotFoundException {