Translate App into German

backend_splatournament_manager/dist/csv/teams.csv

@@ -1,7 +1,7 @@
 name,tag,description
-Team Alpha,ALP,A competitive esports team
-Team Beta,BET,New challengers on the scene
-Team Gamma,GAM,Veteran tournament winners
-Team Delta,DEL,Rising stars in the community
-Team Epsilon,EPS,Strategic gameplay specialists
-Team Zeta,ZET,Fast-paced aggressive players
+Team Alpha,ALP,Ein wettbewerbsorientiertes E-Sport-Team
+Team Beta,BET,Neue Herausforderer in der Szene
+Team Gamma,GAM,Erfahrene Turniersieger
+Team Delta,DEL,Aufstrebende Stars der Community
+Team Epsilon,EPS,Spezialisten für strategisches Gameplay
+Team Zeta,ZET,Schnelle und aggressive Spieler

backend_splatournament_manager/dist/csv/tournaments.csv

@@ -1,4 +1,4 @@
 name,description,maxTeamAmount,currentTeamAmount,registrationStartDate,registrationEndDate
-Demo Tournament  ,This is a demo tournament, 2, 0, 2026-02-01, 2026-02-28
-Demo Tournament 2,This is a second demo tournament, 4, 5, 2026-03-01, 2026-03-15
-Demo Tournament 3,This is a third demo tournament, 8, 8, 2026-03-15, 2026-03-20
+Demo-Turnier,Dies ist ein Demo-Turnier, 2, 0, 2026-02-01, 2026-02-28
+Demo-Turnier 2,Dies ist ein zweites Demo-Turnier, 4, 5, 2026-03-01, 2026-03-15
+Demo-Turnier 3,Dies ist ein drittes Demo-Turnier, 8, 8, 2026-03-15, 2026-03-20

backend_splatournament_manager/src/app.ts

@@ -37,7 +37,7 @@ app.get('/tournaments', async (req: Request, res: Response) => {
 app.get('/tournaments/:id', async (req: Request, res: Response) => {
     const tournament = await tournamentService.getTournamentById(+req.params.id);
     if (!tournament) {
-        return res.status(404).send({error: 'Tournament not found'});
+        return res.status(404).send({error: 'Turnier nicht gefunden'});
     }
     res.send(tournament);
 });
@@ -48,7 +48,7 @@ app.post('/tournaments', authMiddleware, async (req: Request, res: Response) =>
         res.status(201).send();
     } catch (err){
         console.log(err);
-        res.status(400).send({error: 'Failed to create tournament'});
+        res.status(400).send({error: 'Turnier konnte nicht erstellt werden'});
     }
 });
 
@@ -56,18 +56,18 @@ app.put('/tournaments/:id', authMiddleware, async (req: Request, res: Response)
     try {
         await tournamentService.updateTournament(+req.params.id, req.body);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to update Tournament'});
+        return res.status(400).send({error: 'Turnier konnte nicht aktualisiert werden'});
     }
-    res.status(200).send({message: 'Tournament updated successfully'});
+    res.status(200).send({message: 'Turnier erfolgreich aktualisiert'});
 });
 
 app.delete('/tournaments/:id', authMiddleware, async (req: Request, res: Response) => {
     try {
         await tournamentService.deleteTournament(+req.params.id);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to delete Tournament'});
+        return res.status(400).send({error: 'Turnier konnte nicht gelöscht werden'});
     }
-    res.status(200).send({message: 'Tournament deleted successfully'});
+    res.status(200).send({message: 'Turnier erfolgreich gelöscht'});
 });
 
 app.post('/tournaments/:id/bracket', authMiddleware, async (req: Request, res: Response) => {
@@ -77,14 +77,14 @@ app.post('/tournaments/:id/bracket', authMiddleware, async (req: Request, res: R
         const teamIds = teams.map(team => team.id);
         
         if (teamIds.length < 2) {
-            return res.status(400).send({error: 'At least 2 teams are required to initialize bracket'});
+            return res.status(400).send({error: 'Mindestens 2 Teams sind erforderlich, um den Turnierbaum zu initialisieren'});
         }
         
         await matchService.initializeBracket(tournamentId, teamIds);
-        res.status(201).send({message: 'Bracket initialized successfully'});
+        res.status(201).send({message: 'Turnierbaum erfolgreich initialisiert'});
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to initialize bracket'});
+        res.status(400).send({error: 'Turnierbaum konnte nicht initialisiert werden'});
     }
 });
 
@@ -94,7 +94,7 @@ app.get('/tournaments/:id/matches', async (req: Request, res: Response) => {
         res.send(matches);
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to get matches'});
+        res.status(400).send({error: 'Matches konnten nicht geladen werden'});
     }
 });
 
@@ -102,23 +102,23 @@ app.put('/matches/:id/winner', authMiddleware, async (req: Request, res: Respons
     try {
         const {winnerId} = req.body;
         if (!winnerId) {
-            return res.status(400).send({error: 'winnerId is required'});
+            return res.status(400).send({error: 'winnerId ist erforderlich'});
         }
         await matchService.setMatchWinner(+req.params.id, +winnerId);
-        res.status(200).send({message: 'Winner set successfully'});
+        res.status(200).send({message: 'Sieger erfolgreich festgelegt'});
     } catch (err: any) {
         console.log(err);
-        res.status(400).send({error: err.message || 'Failed to set winner'});
+        res.status(400).send({error: err.message || 'Sieger konnte nicht festgelegt werden'});
     }
 });
 
 app.delete('/matches/:id/winner', authMiddleware, async (req: Request, res: Response) => {
     try {
         await matchService.resetMatch(+req.params.id);
-        res.status(200).send({message: 'Match reset successfully'});
+        res.status(200).send({message: 'Match erfolgreich zurückgesetzt'});
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to reset match'});
+        res.status(400).send({error: 'Match konnte nicht zurückgesetzt werden'});
     }
 });
 
@@ -130,7 +130,7 @@ app.get('/teams', async (req: Request, res: Response) => {
 app.get('/teams/:id', async (req: Request, res: Response) => {
     const team = await teamService.getTeamById(+req.params.id);
     if (!team) {
-        return res.status(404).send({error: 'Team not found'});
+        return res.status(404).send({error: 'Team nicht gefunden'});
     }
     res.send(team);
 });
@@ -138,10 +138,10 @@ app.get('/teams/:id', async (req: Request, res: Response) => {
 app.post('/teams', authMiddleware, async (req: Request, res: Response) => {
     const {name, tag, description} = req.body;
     if (!name || !tag) {
-        return res.status(400).send({error: 'name and tag are required'});
+        return res.status(400).send({error: 'Name und Kürzel sind erforderlich'});
     }
     if (tag.length > 3) {
-        return res.status(400).send({error: 'tag must be at most 3 characters'});
+        return res.status(400).send({error: 'Das Kürzel darf höchstens 3 Zeichen lang sein'});
     }
     try {
         const team = await teamService.addTeam({name, tag, description: description ?? ''});
@@ -151,30 +151,30 @@ app.post('/teams', authMiddleware, async (req: Request, res: Response) => {
         res.status(201).send(team);
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to create team'});
+        res.status(400).send({error: 'Team konnte nicht erstellt werden'});
     }
 });
 
 app.put('/teams/:id', authMiddleware, async (req: Request, res: Response) => {
     const {tag} = req.body;
     if (tag && tag.length > 3) {
-        return res.status(400).send({error: 'tag must be at most 3 characters'});
+        return res.status(400).send({error: 'Das Kürzel darf höchstens 3 Zeichen lang sein'});
     }
     try {
         await teamService.updateTeam(+req.params.id, req.body);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to update team'});
+        return res.status(400).send({error: 'Team konnte nicht aktualisiert werden'});
     }
-    res.status(200).send({message: 'Team updated successfully'});
+    res.status(200).send({message: 'Team erfolgreich aktualisiert'});
 });
 
 app.delete('/teams/:id', authMiddleware, async (req: Request, res: Response) => {
     try {
         await teamService.deleteTeam(+req.params.id);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to delete team'});
+        return res.status(400).send({error: 'Team konnte nicht gelöscht werden'});
     }
-    res.status(200).send({message: 'Team deleted successfully'});
+    res.status(200).send({message: 'Team erfolgreich gelöscht'});
 });
 
 app.get('/tournaments/:id/teams', async (req: Request, res: Response) => {
@@ -185,16 +185,16 @@ app.get('/tournaments/:id/teams', async (req: Request, res: Response) => {
 app.post('/tournaments/:id/teams', authMiddleware, async (req: Request, res: Response) => {
     const {teamId} = req.body;
     if (!teamId) {
-        return res.status(400).send({error: 'teamId is required'});
+        return res.status(400).send({error: 'teamId ist erforderlich'});
     }
     try {
         const entry = await teamService.registerTeamForTournament(+req.params.id, +teamId);
         res.status(201).send(entry);
     } catch (err: any) {
         if (err.message?.includes('UNIQUE constraint failed')) {
-            return res.status(409).send({error: 'Team is already registered for this tournament'});
+            return res.status(409).send({error: 'Das Team ist bereits für dieses Turnier angemeldet'});
         }
-        res.status(400).send({error: 'Failed to register team'});
+        res.status(400).send({error: 'Team konnte nicht für das Turnier angemeldet werden'});
     }
 });
 
@@ -202,9 +202,9 @@ app.delete('/tournaments/:id/teams/:teamId', authMiddleware, async (req: Request
     try {
         await teamService.removeTeamFromTournament(+req.params.id, +req.params.teamId);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to remove team from tournament'});
+        return res.status(400).send({error: 'Team konnte nicht aus dem Turnier entfernt werden'});
     }
-    res.status(200).send({message: 'Team removed from tournament'});
+    res.status(200).send({message: 'Team aus dem Turnier entfernt'});
 });
 
 app.get('/teams/:id/tournaments', async (req: Request, res: Response) => {
@@ -220,7 +220,7 @@ app.get('/users/me/teams', authMiddleware, async (req: Request, res: Response) =
         res.send(teams);
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to get user teams'});
+        res.status(400).send({error: 'Eigene Teams konnten nicht geladen werden'});
     }
 });
 
@@ -232,14 +232,14 @@ app.post('/teams/:id/members', authMiddleware, async (req: Request, res: Respons
         
         const isInTeam = await teamService.isUserInTeam(teamId, userId);
         if (isInTeam) {
-            return res.status(409).send({error: 'User is already a member of this team'});
+            return res.status(409).send({error: 'Du bist bereits Mitglied dieses Teams'});
         }
         
         const member = await teamService.addTeamMember(teamId, userId, 'member');
         res.status(201).send(member);
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to join team'});
+        res.status(400).send({error: 'Beitritt zum Team fehlgeschlagen'});
     }
 });
 
@@ -249,10 +249,10 @@ app.delete('/teams/:id/members/me', authMiddleware, async (req: Request, res: Re
         const userId = req.user.id;
         const teamId = +req.params.id;
         await teamService.removeTeamMember(teamId, userId);
-        res.status(200).send({message: 'Left team successfully'});
+        res.status(200).send({message: 'Team erfolgreich verlassen'});
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to leave team'});
+        res.status(400).send({error: 'Team konnte nicht verlassen werden'});
     }
 });
 
@@ -262,36 +262,36 @@ app.get('/teams/:id/members', async (req: Request, res: Response) => {
         res.send(members);
     } catch (err) {
         console.log(err);
-        res.status(400).send({error: 'Failed to get team members'});
+        res.status(400).send({error: 'Teammitglieder konnten nicht geladen werden'});
     }
 });
 
 app.post('/register', async (req: Request, res: Response) => {
     const { username, password } = req.body;
     if (!username || !password) {
-        return res.status(400).send({ error: 'Username and password are required' });
+        return res.status(400).send({ error: 'Benutzername und Passwort sind erforderlich' });
     }
     try {
         const user = await userService.register(username, password);
         res.status(201).send(user);
     } catch (err: any) {
         if (err.message?.includes('UNIQUE constraint failed')) {
-            return res.status(409).send({ error: 'Username already exists' });
+            return res.status(409).send({ error: 'Benutzername existiert bereits' });
         }
-        res.status(500).send({ error: 'Registration failed' });
+        res.status(500).send({ error: 'Registrierung fehlgeschlagen' });
     }
 });
 
 app.post('/login', async (req: Request, res: Response) => {
     const { username, password } = req.body;
     if (!username || !password) {
-        return res.status(400).send({ error: 'Username and password are required' });
+        return res.status(400).send({ error: 'Benutzername und Passwort sind erforderlich' });
     }
     try {
         const user = await userService.login(username, password);
         res.status(200).send(user);
     } catch (err: any) {
-        res.status(401).send({ error: err.message || 'Login failed' });
+        res.status(401).send({ error: err.message || 'Anmeldung fehlgeschlagen' });
     }
 });
 

backend_splatournament_manager/src/middlewares/auth-middleware.ts

@@ -6,7 +6,7 @@ const JWT_SECRET = process.env.JWT_SECRET || "key"
 export const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
     const authHeader = req.headers.authorization;
     if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        return res.status(401).send({ error: 'Unauthorized: No token provided' });
+        return res.status(401).send({ error: 'Nicht autorisiert: Kein Token angegeben' });
     }
     const token = authHeader.split(' ')[1];
     try {
@@ -17,6 +17,6 @@ export const authMiddleware = (req: Request, res: Response, next: NextFunction)
 
         next();
     } catch (err) {
-        return res.status(401).send({ error: 'Unauthorized: Invalid token' });
+        return res.status(401).send({ error: 'Nicht autorisiert: Ungültiger Token' });
     }
 };

backend_splatournament_manager/src/services/match-service.ts

@@ -120,11 +120,11 @@ export class MatchService {
                 [matchId],
                 (err, match: any) => {
                     if (err) return reject(err);
-                    if (!match) return reject(new Error('Match not found'));
+                    if (!match) return reject(new Error('Match nicht gefunden'));
 
                     // Validate that the winnerId is one of the participants
                     if (match.team1Id !== winnerId && match.team2Id !== winnerId) {
-                        return reject(new Error('Winner must be one of the match participants'));
+                        return reject(new Error('Der Sieger muss eines der Teams dieses Matches sein'));
                     }
 
                     // Update the match with winner
@@ -182,7 +182,7 @@ export class MatchService {
                 [matchId],
                 (err, match: any) => {
                     if (err) return reject(err);
-                    if (!match) return reject(new Error('Match not found'));
+                    if (!match) return reject(new Error('Match nicht gefunden'));
 
                     const previousWinnerId = match.winnerId;
 

backend_splatournament_manager/src/services/team-service.ts

@@ -183,7 +183,7 @@ export class TeamService {
         (err: Error | null, row: any) => {
           if (err) return reject(err);
           if (row.count >= 4) {
-            return reject(new Error('Team already has maximum of 4 members'));
+            return reject(new Error('Das Team hat bereits die maximale Anzahl von 4 Mitgliedern'));
           }
           
           const stmt = this.db.prepare(`INSERT INTO TeamMembers (teamId, userId, role) VALUES (?, ?, ?)`);

backend_splatournament_manager/src/services/user-service.ts

@@ -74,12 +74,12 @@ export class UserService {
                         return reject(err);
                     }
                     if (!user) {
-                        return reject(new Error('User not found'));
+                        return reject(new Error('Benutzer nicht gefunden'));
                     }
                     try {
                         const valid = await argon2.verify(user.password, password);
                         if (!valid) {
-                            return reject(new Error('Invalid password'));
+                            return reject(new Error('Ungültiges Passwort'));
                         }
                         const token = jwt.sign({ id: user.id, username: user.username }, JWT_SECRET, { expiresIn: '7d' });
                         resolve({ id: user.id, username: user.username, token });