From ef3975ac2c4f40d2ff97833b4d40c2341db1e2da Mon Sep 17 00:00:00 2001
From: Jonas <jonas.fischer14@gmx.de>
Date: Mon, 8 Jan 2024 18:00:42 +0100
Subject: [PATCH] 08.01.2024 - modify service methods #24
---
.../sthbackend/service/TournamentService.java | 136 +++++++++++-------
1 file changed, 83 insertions(+), 53 deletions(-)
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 a7d3810..58ee4b4 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
@@ -1,110 +1,140 @@
package hdm.mi.sthbackend.service;
-import com.mongodb.client.MongoClient;
+import hdm.mi.sthbackend.dto.PlayerDTO;
+import hdm.mi.sthbackend.dto.TeamDTO;
import hdm.mi.sthbackend.exeptions.PlayerIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TeamIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
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 hdm.mi.sthbackend.repository.MongoManager;
import lombok.AllArgsConstructor;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.Optional;
+import java.util.Map;
import java.util.UUID;
@Service
@AllArgsConstructor
public class TournamentService {
+ private final Logger logger = 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));
- public Player addPlayerToTeam(UUID tournamentId,
- UUID teamId,
- String playerName) throws TournamentIdNotFoundException {
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
Player newPlayer = new Player(UUID.randomUUID(), playerName);
- tournament
- .getTeams()
- .get(teamId)
- .getTeamMembers()
- .put(newPlayer.getPlayerId(), newPlayer);
- tournamentRepository.save(tournament);
+ team.getTeamMembers()
+ .add(newPlayer.getPlayerId());
+
+ playerRepository.insert(newPlayer);
+ teamRepository.save(team);
+
return newPlayer;
}
- public Player removePlayerFromTeam(UUID tournamentId,
- UUID teamId,
- UUID playerId) throws TournamentIdNotFoundException {
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
+ public PlayerDTO findPlayerById(UUID playerId) throws PlayerIdNotFoundException {
+ Player player = playerRepository.findById(playerId)
+ .orElseThrow(() -> new PlayerIdNotFoundException(playerId));
- Player removedPlayer = tournament.getTeams()
- .get(teamId)
- .getTeamMembers()
- .remove(playerId);
+ return new PlayerDTO(player.getPlayerId(), player.getName());
+ }
- tournamentRepository.save(tournament);
- return removedPlayer;
+ 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);
+
+ return new PlayerDTO(playerToDelete.getPlayerId(), playerToDelete.getName());
}
- public UUID updatePlayerName(UUID tournamentId,
- UUID teamId,
- UUID playerId,
- String newPlayerName) throws TournamentIdNotFoundException, PlayerIdNotFoundException {
- Tournament tournament = tournamentRepository.findById(tournamentId)
- .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
+ 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;
+ }
- tournament.getTeams()
- .get(teamId)
- .getTeamMembers()
- .get(playerId)
- .setName(newPlayerName);
+ public TeamDTO findTeamById(UUID teamId) throws TeamIdNotFoundException {
+ Team team = teamRepository.findById(teamId)
+ .orElseThrow(() -> new TeamIdNotFoundException(teamId));
- tournamentRepository.save(tournament);
- return playerId;
+ 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 createTeamFromTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
+ public Team createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
- Team team = new Team(UUID.randomUUID(), teamName, new HashMap<>() {
- });
+ Team newTeam = new Team(UUID.randomUUID(), teamName, new ArrayList<>());
tournament.getTeams()
- .put(team.getId(), team);
+ .add(newTeam.getId());
+ teamRepository.insert(newTeam);
tournamentRepository.save(tournament);
- return team;
+ return newTeam;
}
- public UUID removeTeamFromTournament(UUID tournamentId,
- UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
+ public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId,
+ UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
- Optional.ofNullable(tournament.getTeams()
- .remove(teamId))
- .orElseThrow(() -> new TeamIdNotFoundException(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);
return teamId;
}
public Tournament createTournament(String tournamentName) {
- MongoManager manager = new MongoManager();
- MongoClient client = manager.getMongoClient();
- manager.getTestCollection(client);
-
- Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new HashMap<>());
+ Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new ArrayList<>());
tournamentRepository.insert(tournament);
return tournament;
}
+ // determineWinner and assignTeamToMatch
+
}
--
GitLab