Newer
Older
package hdm.mi.sthbackend.service;
import hdm.mi.sthbackend.dto.PlayerDTO;
import hdm.mi.sthbackend.dto.TeamDTO;

Schneider Stefan
committed
import hdm.mi.sthbackend.exeptions.*;
import hdm.mi.sthbackend.model.Player;
import hdm.mi.sthbackend.model.Team;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.IMatchRepository;
import hdm.mi.sthbackend.repository.IPlayerRepository;
import hdm.mi.sthbackend.repository.ITeamRepository;
import hdm.mi.sthbackend.repository.ITournamentRepository;
import lombok.AllArgsConstructor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;
import java.util.*;
@Service
@AllArgsConstructor
public class TournamentService {
Häderle Marius
committed
private final static Logger log = LogManager.getLogger(TournamentService.class);
ITournamentRepository tournamentRepository;
IPlayerRepository playerRepository;
ITeamRepository teamRepository;
IMatchRepository matchRepository;
public Player addPlayerToTeam(UUID teamId,
String playerName) throws TeamIdNotFoundException {
Team team = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
Player newPlayer = new Player(UUID.randomUUID(), playerName);
team.getTeamMembers()
.add(newPlayer.getPlayerId());
playerRepository.insert(newPlayer);
teamRepository.save(team);
log.debug("Player " + newPlayer.getPlayerId() + " added to Team " + teamId);
public PlayerDTO findPlayerById(UUID playerId) throws PlayerIdNotFoundException {
Player player = playerRepository.findById(playerId)
.orElseThrow(() -> new PlayerIdNotFoundException(playerId));
return new PlayerDTO(player.getPlayerId(), player.getName());
}
Häderle Marius
committed
/*
Wie gehen wir damit um, wenn zwei Player denselben Namen haben? Also: Stefan vs Stefan = Stefan gewinnt
Sollte man hier in den Methoden das ausschließen und dann geben die Spieler ihren ersten Buchstaben vom Nachnamen an? z.B. Stefan S. vs Stefan w.
oder geben wir die UUID auch mit an zum PlayerName
*/
public PlayerDTO removePlayerFromTeam(UUID teamId,
UUID playerId) throws PlayerIdNotFoundException, TeamIdNotFoundException {
Team team = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
Player playerToDelete = playerRepository.findById(playerId)
.orElseThrow(() -> new PlayerIdNotFoundException(playerId));
try {
team.getTeamMembers()
.remove(playerToDelete.getPlayerId());
} catch (NullPointerException e) {
throw new PlayerIdNotFoundException(playerId);
}
playerRepository.delete(playerToDelete);
teamRepository.save(team);
log.debug("Player " + playerId + " removed from Team " + teamId);
return new PlayerDTO(playerToDelete.getPlayerId(), playerToDelete.getName());
Häderle Marius
committed
/*
Kann es passieren, dass hier bei der Methode removePlayerFromTeam() es den Player gar nicht gibt?
und dann eine PlayerIdNotFoundException geworfen werden muss? oder ist durch die Übergabe von UUID playerId schon safe die playerId vorhanden
*/
public UUID updatePlayerName(UUID playerId,
String newPlayerName) throws PlayerIdNotFoundException {
Player player = playerRepository.findById(playerId)
.orElseThrow(() -> new PlayerIdNotFoundException(playerId));
player.setName(newPlayerName);
playerRepository.save(player);
return playerId;
}
public TeamDTO findTeamById(UUID teamId) throws TeamIdNotFoundException {
Team team = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
Map<UUID, PlayerDTO> teamMembers = new HashMap<>();
team.getTeamMembers().
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);
public Team createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
Team newTeam = new Team(UUID.randomUUID(), teamName, new ArrayList<>());
tournamentRepository.save(tournament);
public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId,
UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
Team teamToDelete = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
try {
tournament.getTeams()
.remove(teamToDelete.getId());
} catch (NullPointerException e) {
throw new TeamIdNotFoundException(tournamentId);
}
teamRepository.delete(teamToDelete);
tournamentRepository.save(tournament);
Häderle Marius
committed
log.debug("Team " + teamId + " added to Tournament " + tournamentId);
return teamId;
}
public Tournament createTournament(String tournamentName) {
Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new ArrayList<>());
tournamentRepository.insert(tournament);
Häderle Marius
committed
log.debug("created Tournament " + tournament.getTournamentId());

Schneider Stefan
committed
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));
UUID winnerTeamId = match.getTeamScores().entrySet().stream()

Schneider Stefan
committed
.max(Comparator.comparing(Map.Entry::getKey))
.map(Map.Entry::getKey)

Schneider Stefan
committed
.orElseThrow(() -> new WinnerNotDeterminedException(matchId,tournamentId));
match.setWinnerTeamId(winnerTeamId);
tournamentRepository.save(tournament);
log.debug("The Winner " + winnerTeamId + " is determined for Match " + matchId + " in Tournament " + tournamentId);
return winnerTeamId;
}

Schneider Stefan
committed
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.getTeamScores().put(teamId,score);
tournamentRepository.save(tournament);
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));
if (!match.getTeamScores().containsKey(teamId)) {
throw new TeamIdNotFoundException(teamId);
}
match.getTeamScores().put(teamId, newScore);
tournamentRepository.save(tournament);
log.debug("Score of Team " + teamId + " updated to " + newScore);
}
public UUID updateTeamName(UUID teamId, String newTeamName) throws TeamIdNotFoundException {
Team team = teamRepository.findById(teamId)
.orElseThrow(() -> new TeamIdNotFoundException(teamId));
team.setTeamName(newTeamName);
teamRepository.save(team);
log.debug("Teamname of " + teamId + " updated to " + newTeamName);
return teamId;
Häderle Marius
committed
/*
Weitere Methoden:
UpdateTeamScore Marius
Tunier beenden
GetTournament Leon
DeleteTournament Leon
Häderle Marius
committed
*/