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 a7d381046b6e669143b2b63a4b0651f3b4085609..58ee4b45e4f68a8556a1dc84bf610281d6a345fd 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
+
 
 }