Enhance member training participation tracking and UI feedback

This commit adds functionality to track training participations for members in the backend, updating the MemberService to include a count of training participations. The frontend components, DiaryView and MembersView, have been updated to display warning icons based on the number of training participations, providing visual feedback for members with significant participation. CSS styles for warning icons have also been refined to improve visibility and user experience.

.gitignore

@@ -6,3 +6,5 @@ frontend/.env
 backend/.env
 
 backend/images/*
+backend/backend-debug.log
+backend/*.log

PERMISSIONS_GUIDE.md

@@ -0,0 +1,210 @@
+# Berechtigungssystem - Dokumentation
+
+## Übersicht
+
+Das Trainingstagebuch verfügt nun über ein vollständiges rollenbasiertes Berechtigungssystem (RBAC - Role-Based Access Control). Der Club-Ersteller hat automatisch Admin-Rechte und kann anderen Mitgliedern Rollen und spezifische Berechtigungen zuweisen.
+
+## Rollen
+
+### 1. Administrator (admin)
+- **Vollzugriff** auf alle Funktionen
+- Kann Berechtigungen anderer Benutzer verwalten
+- Der Club-Ersteller ist automatisch Administrator und kann nicht degradiert werden
+
+### 2. Trainer (trainer)
+- Kann Trainingseinheiten planen und verwalten
+- Kann Mitglieder anlegen und bearbeiten
+- Kann Spielpläne einsehen und bearbeiten
+- Kann Turniere organisieren
+- **Kann nicht**: Einstellungen ändern, Berechtigungen verwalten
+
+### 3. Mannschaftsführer (team_manager)
+- Kann Teams und Spielpläne verwalten
+- Kann Spieler für Matches einteilen
+- Kann Spielergebnisse eintragen
+- **Kann nicht**: Trainingseinheiten planen, Mitglieder verwalten
+
+### 4. Mitglied (member)
+- Nur Lesezugriff auf alle Bereiche
+- Kann eigene Daten einsehen
+- **Kann nicht**: Daten ändern oder löschen
+
+## Berechtigungsbereiche
+
+- **diary**: Trainingstagebuch
+- **members**: Mitgliederverwaltung
+- **teams**: Team-Management
+- **schedule**: Spielpläne
+- **tournaments**: Turniere
+- **statistics**: Statistiken
+- **settings**: Einstellungen
+- **permissions**: Berechtigungsverwaltung
+- **mytischtennis**: MyTischtennis-Integration (für alle zugänglich)
+
+## Backend-Integration
+
+### Migration ausführen
+
+```sql
+mysql -u username -p database_name < backend/migrations/add_permissions_to_user_club.sql
+```
+
+### Authorization Middleware verwenden
+
+```javascript
+import { authorize, requireAdmin, requireOwner } from '../middleware/authorizationMiddleware.js';
+
+// Beispiel: Nur Lesezugriff erforderlich
+router.get('/diary/:clubId', authenticate, authorize('diary', 'read'), getDiary);
+
+// Beispiel: Schreibzugriff erforderlich
+router.post('/diary/:clubId', authenticate, authorize('diary', 'write'), createDiary);
+
+// Beispiel: Admin-Rechte erforderlich
+router.put('/settings/:clubId', authenticate, requireAdmin(), updateSettings);
+
+// Beispiel: Nur Owner
+router.delete('/club/:clubId', authenticate, requireOwner(), deleteClub);
+```
+
+### Permission Service verwenden
+
+```javascript
+import permissionService from '../services/permissionService.js';
+
+// Berechtigungen prüfen
+const hasPermission = await permissionService.hasPermission(userId, clubId, 'diary', 'write');
+
+// Rolle setzen
+await permissionService.setUserRole(userId, clubId, 'trainer', adminUserId);
+
+// Custom Permissions setzen
+await permissionService.setCustomPermissions(
+  userId, 
+  clubId, 
+  { diary: { write: false }, members: { write: true } },
+  adminUserId
+);
+```
+
+## Frontend-Integration
+
+### Composable verwenden
+
+```vue
+<script setup>
+import { usePermissions } from '@/composables/usePermissions.js';
+
+const { can, canWrite, canDelete, isAdmin, isOwner, userRole } = usePermissions();
+
+// Beispiel
+if (can('diary', 'write')) {
+  // Zeige Bearbeitungsbutton
+}
+</script>
+```
+
+### Direktiven verwenden
+
+```vue
+<template>
+  <!-- Nur anzeigen, wenn Schreibrechte für diary vorhanden -->
+  <button v-can:diary.write>Bearbeiten</button>
+  
+  <!-- Nur anzeigen, wenn Löschrechte für members vorhanden -->
+  <button v-can:members.delete>Löschen</button>
+  
+  <!-- Alternative Syntax -->
+  <div v-can="'diary.write'">Inhalt nur für Berechtigte</div>
+  
+  <!-- Nur für Admins -->
+  <div v-admin>Admin-Bereich</div>
+  
+  <!-- Nur für Owner -->
+  <div v-owner>Owner-Bereich</div>
+</template>
+```
+
+### Store verwenden
+
+```javascript
+import { useStore } from 'vuex';
+
+const store = useStore();
+
+// Berechtigungen abrufen
+const permissions = store.getters.currentPermissions;
+const hasPermission = store.getters.hasPermission('diary', 'write');
+const isOwner = store.getters.isClubOwner;
+const userRole = store.getters.userRole;
+
+// Berechtigungen laden (wird automatisch beim Club-Wechsel gemacht)
+await store.dispatch('loadPermissions', clubId);
+```
+
+## Admin-UI
+
+Die Berechtigungsverwaltung ist unter `/permissions` verfügbar und nur für Administratoren sichtbar.
+
+**Funktionen:**
+- Übersicht aller Clubmitglieder mit ihren Rollen
+- Rollen zuweisen/ändern
+- Custom Permissions für einzelne Benutzer definieren
+- Erklärung der verfügbaren Rollen
+
+## MyTischtennis-Integration
+
+Die MyTischtennis-Einstellungen und -Funktionen sind für **alle Club-Mitglieder** zugänglich, unabhängig von ihrer Rolle. Dies ermöglicht es jedem, die Anbindung einzurichten und Daten abzurufen.
+
+## Sicherheitshinweise
+
+1. **Der Club-Ersteller** (Owner) kann nicht degradiert oder gelöscht werden
+2. **Owner-Rechte** können nicht übertragen werden
+3. **Backend-Validierung** wird immer durchgeführt, auch wenn das Frontend Elemente ausblendet
+4. **Alle API-Routen** sind durch Middleware geschützt
+5. **Permissions werden gecacht** im localStorage für bessere Performance
+
+## Beispiel-Szenarien
+
+### Szenario 1: Trainer hinzufügen
+1. Admin öffnet `/permissions`
+2. Wählt Benutzer aus
+3. Ändert Rolle zu "Trainer"
+4. Benutzer kann jetzt Trainingseinheiten planen
+
+### Szenario 2: Custom Permissions
+1. Admin öffnet `/permissions`
+2. Wählt Benutzer aus
+3. Klickt auf "Anpassen"
+4. Setzt individuelle Berechtigungen (z.B. nur Diary-Schreibrecht)
+5. Speichert
+
+### Szenario 3: Neues Mitglied
+1. Mitglied registriert sich und fordert Zugang an
+2. Admin genehmigt Anfrage (Standardrolle: "member")
+3. Mitglied hat Lesezugriff
+4. Bei Bedarf kann Admin die Rolle später ändern
+
+## Troubleshooting
+
+**Problem**: Berechtigungen werden nicht aktualisiert
+- **Lösung**: Seite neu laden oder Club neu auswählen
+
+**Problem**: "Keine Berechtigung" trotz korrekter Rolle
+- **Lösung**: Prüfen, ob Custom Permissions die Rolle überschreiben
+
+**Problem**: Owner kann keine Änderungen vornehmen
+- **Lösung**: Owner sollte automatisch alle Rechte haben. Prüfen Sie die `isOwner`-Flag in der Datenbank
+
+## API-Endpunkte
+
+```
+GET    /api/permissions/:clubId                          - Eigene Berechtigungen abrufen
+GET    /api/permissions/:clubId/members                  - Alle Mitglieder mit Berechtigungen (Admin)
+PUT    /api/permissions/:clubId/user/:userId/role        - Rolle ändern (Admin)
+PUT    /api/permissions/:clubId/user/:userId/permissions - Custom Permissions setzen (Admin)
+GET    /api/permissions/roles/available                  - Verfügbare Rollen abrufen
+GET    /api/permissions/structure/all                    - Berechtigungsstruktur abrufen
+```
+
+

PERMISSIONS_MIGRATION.md

@@ -0,0 +1,235 @@
+# Berechtigungssystem - Migrations-Anleitung
+
+## Übersicht
+
+Diese Anleitung hilft Ihnen, das neue Berechtigungssystem für bestehende Clubs einzurichten.
+
+## Schritt 1: Datenbank-Schema erweitern
+
+Führen Sie zuerst die SQL-Migration aus, um die neuen Spalten hinzuzufügen:
+
+```bash
+mysql -u username -p database_name < backend/migrations/add_permissions_to_user_club.sql
+```
+
+Dies fügt folgende Spalten zur `user_club` Tabelle hinzu:
+- `role` (VARCHAR) - Benutzerrolle (admin, trainer, team_manager, member)
+- `permissions` (JSON) - Custom Permissions
+- `is_owner` (BOOLEAN) - Markiert den Club-Ersteller
+
+## Schritt 2: Bestehende Daten migrieren
+
+Sie haben zwei Optionen:
+
+### Option A: Node.js Script (Empfohlen)
+
+Das Script identifiziert automatisch den ersten Benutzer jedes Clubs (nach `createdAt`) und setzt ihn als Owner.
+
+```bash
+cd /home/torsten/Programs/trainingstagebuch/backend
+node scripts/migratePermissions.js
+```
+
+**Ausgabe:**
+```
+Starting permissions migration...
+
+Found 3 club(s)
+
+--- Club: TTC Beispiel (ID: 1) ---
+  Members found: 5
+  First member (will be owner): admin@example.com
+  ✓ Updated admin@example.com: role=admin, isOwner=true
+  ✓ Updated user1@example.com: role=member, isOwner=false
+  ✓ Updated user2@example.com: role=member, isOwner=false
+  ...
+
+✅ Migration completed successfully!
+
+Summary:
+Club Owners (3):
+  - TTC Beispiel: admin@example.com
+  - SV Teststadt: owner@test.de
+  - TSC Demo: demo@example.com
+
+Role Distribution:
+  - Admins: 3
+  - Members: 12
+```
+
+### Option B: SQL Script
+
+Wenn Sie lieber SQL verwenden möchten:
+
+```bash
+mysql -u username -p database_name < backend/migrations/update_existing_user_club_permissions.sql
+```
+
+Dieses Script:
+1. Setzt `role = 'member'` für alle genehmigten Benutzer ohne Rolle
+2. Markiert den Benutzer mit der niedrigsten `user_id` pro Club als Owner
+
+## Schritt 3: Manuelle Anpassungen (Optional)
+
+### Falscher Owner?
+
+Falls das Script den falschen Benutzer als Owner markiert hat, können Sie dies manuell korrigieren:
+
+```sql
+-- Alten Owner zurücksetzen
+UPDATE user_club 
+SET is_owner = 0, role = 'member' 
+WHERE club_id = 1 AND user_id = 123;
+
+-- Neuen Owner setzen
+UPDATE user_club 
+SET is_owner = 1, role = 'admin' 
+WHERE club_id = 1 AND user_id = 456;
+```
+
+### Weitere Admins ernennen
+
+```sql
+UPDATE user_club 
+SET role = 'admin' 
+WHERE club_id = 1 AND user_id = 789;
+```
+
+### Trainer ernennen
+
+```sql
+UPDATE user_club 
+SET role = 'trainer' 
+WHERE club_id = 1 AND user_id = 101;
+```
+
+## Schritt 4: Verifizierung
+
+### Backend neu starten
+
+```bash
+# Server neu starten (wenn er läuft)
+sudo systemctl restart tt-tagebuch
+```
+
+### Im Browser testen
+
+1. Loggen Sie sich ein
+2. Wählen Sie einen Club aus
+3. Navigieren Sie zu "Berechtigungen" (nur für Admins sichtbar)
+4. Überprüfen Sie, dass alle Mitglieder korrekt angezeigt werden
+
+### SQL Verifizierung
+
+```sql
+-- Alle Club-Mitglieder mit ihren Berechtigungen anzeigen
+SELECT 
+    c.name as club_name,
+    u.email as user_email,
+    uc.role,
+    uc.is_owner,
+    uc.approved
+FROM user_club uc
+JOIN club c ON c.id = uc.club_id
+JOIN user u ON u.id = uc.user_id
+WHERE uc.approved = 1
+ORDER BY c.name, uc.is_owner DESC, uc.role, u.email;
+```
+
+## Troubleshooting
+
+### Problem: "Keine Berechtigung" trotz Owner-Status
+
+**Lösung:** Überprüfen Sie in der Datenbank:
+
+```sql
+SELECT role, is_owner, approved 
+FROM user_club 
+WHERE user_id = YOUR_USER_ID AND club_id = YOUR_CLUB_ID;
+```
+
+Sollte sein: `role='admin'`, `is_owner=1`, `approved=1`
+
+### Problem: Owner kann nicht geändert werden
+
+Das ist korrekt! Der Owner (Club-Ersteller) kann seine eigenen Rechte nicht verlieren. Dies ist eine Sicherheitsmaßnahme.
+
+### Problem: Berechtigungen werden nicht geladen
+
+**Lösung:**
+1. Browser-Cache leeren
+2. LocalStorage leeren: `localStorage.clear()` in der Browser-Console
+3. Neu einloggen
+
+### Problem: "Lade Mitglieder..." bleibt hängen
+
+**Mögliche Ursachen:**
+1. Migration noch nicht ausgeführt
+2. Backend nicht neu gestartet
+3. Frontend nicht neu gebaut
+
+**Lösung:**
+```bash
+# Backend
+cd /home/torsten/Programs/trainingstagebuch/backend
+node scripts/migratePermissions.js
+
+# Frontend
+cd /home/torsten/Programs/trainingstagebuch/frontend
+npm run build
+
+# Server neu starten
+sudo systemctl restart tt-tagebuch
+```
+
+## Nach der Migration
+
+### Neue Clubs
+
+Bei neuen Clubs wird der Ersteller automatisch als Owner mit Admin-Rechten eingerichtet. Keine manuelle Aktion erforderlich.
+
+### Neue Mitglieder
+
+Neue Mitglieder erhalten automatisch die Rolle "member" (Lesezugriff). Admins können die Rolle später ändern.
+
+### Berechtigungen verwalten
+
+Admins können über die Web-UI unter `/permissions` Berechtigungen verwalten:
+1. Rollen zuweisen (Admin, Trainer, Mannschaftsführer, Mitglied)
+2. Custom Permissions definieren (für spezielle Anwendungsfälle)
+
+## Wichtige Hinweise
+
+⚠️ **Sicherung erstellen:**
+```bash
+mysqldump -u username -p database_name > backup_before_permissions_$(date +%Y%m%d).sql
+```
+
+⚠️ **Owner-Rechte:**
+- Der Owner (is_owner=1) kann nicht degradiert oder gelöscht werden
+- Jeder Club hat genau einen Owner
+- Owner-Rechte können nicht übertragen werden (nur durch direkte DB-Änderung)
+
+⚠️ **MyTischtennis:**
+- MyTischtennis-Funktionen sind für ALLE Mitglieder zugänglich
+- Keine Berechtigungsprüfung für MyTischtennis-Endpunkte
+
+## Rollback (falls nötig)
+
+Falls Sie das Berechtigungssystem zurücknehmen müssen:
+
+```sql
+-- Spalten entfernen (Achtung: Datenverlust!)
+ALTER TABLE user_club 
+DROP COLUMN role,
+DROP COLUMN permissions,
+DROP COLUMN is_owner;
+
+-- Indizes entfernen
+DROP INDEX idx_user_club_role ON user_club;
+DROP INDEX idx_user_club_owner ON user_club;
+```
+
+Dann Backend-Code auf vorherige Version zurücksetzen.
+
+

backend/MYTISCHTENNIS_AUTO_FETCH_README.md

@@ -0,0 +1,212 @@
+# MyTischtennis Automatischer Datenabruf
+
+## Übersicht
+
+Dieses System ermöglicht den automatischen Abruf von Spielergebnissen und Statistiken von myTischtennis.de.
+
+## Scheduler
+
+### 6:00 Uhr - Rating Updates
+- **Service:** `autoUpdateRatingsService.js`
+- **Funktion:** Aktualisiert TTR/QTTR-Werte für Spieler
+- **TODO:** Implementierung der eigentlichen Rating-Update-Logik
+
+### 6:30 Uhr - Spielergebnisse
+- **Service:** `autoFetchMatchResultsService.js`
+- **Funktion:** Ruft Spielerbilanzen für konfigurierte Teams ab
+- **Status:** ✅ Grundlegende Implementierung fertig
+
+## Benötigte Konfiguration
+
+### 1. MyTischtennis-Account
+- Account muss in den MyTischtennis-Settings verknüpft sein
+- Checkbox "Automatische Updates" aktivieren
+- Passwort speichern (erforderlich für automatische Re-Authentifizierung)
+
+### 2. League-Konfiguration
+
+Für jede Liga müssen folgende Felder ausgefüllt werden:
+
+```sql
+UPDATE league SET
+  my_tischtennis_group_id = '504417',  -- Group ID von myTischtennis
+  association = 'HeTTV',               -- Verband (z.B. HeTTV, DTTB)
+  groupname = '1.Kreisklasse'          -- Gruppenname für URL
+WHERE id = 1;
+```
+
+**Beispiel-URL:**
+```
+https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/...
+                                       ^^^^^         ^^^^^^^^^^^^^^        ^^^^^^
+                                    association      groupname          group_id
+```
+
+### 3. Team-Konfiguration
+
+Für jedes Team muss die myTischtennis Team-ID gesetzt werden:
+
+```sql
+UPDATE club_team SET
+  my_tischtennis_team_id = '2995094'  -- Team ID von myTischtennis
+WHERE id = 1;
+```
+
+**Beispiel-URL:**
+```
+.../mannschaft/2995094/Harheimer_TC_(J11)/spielerbilanzen/gesamt
+               ^^^^^^^
+              team_id
+```
+
+### 4. Spieler-Zuordnung (Optional)
+
+Spieler werden automatisch anhand des Namens zugeordnet. Für genauere Zuordnung kann die myTischtennis Player-ID gesetzt werden:
+
+```sql
+UPDATE member SET
+  my_tischtennis_player_id = 'NU2705037'  -- Player ID von myTischtennis
+WHERE id = 1;
+```
+
+## Migrationen
+
+Folgende Migrationen müssen ausgeführt werden:
+
+```bash
+# 1. MyTischtennis Auto-Update-Felder
+mysql -u root -p trainingstagebuch < backend/migrations/add_auto_update_ratings_to_my_tischtennis.sql
+
+# 2. MyTischtennis Update-History-Tabelle
+mysql -u root -p trainingstagebuch < backend/migrations/create_my_tischtennis_update_history.sql
+
+# 3. League MyTischtennis-Felder
+mysql -u root -p trainingstagebuch < backend/migrations/add_mytischtennis_fields_to_league.sql
+
+# 4. Team MyTischtennis-ID
+mysql -u root -p trainingstagebuch < backend/migrations/add_mytischtennis_team_id_to_club_team.sql
+
+# 5. Member MyTischtennis Player-ID
+mysql -u root -p trainingstagebuch < backend/migrations/add_mytischtennis_player_id_to_member.sql
+
+# 6. Match Result-Felder
+mysql -u root -p trainingstagebuch < backend/migrations/add_match_result_fields.sql
+```
+
+## Abgerufene Daten
+
+Von der myTischtennis API werden folgende Daten abgerufen:
+
+### Einzelstatistiken
+- Player ID, Vorname, Nachname
+- Gewonnene/Verlorene Punkte
+- Anzahl Spiele
+- Detaillierte Statistiken nach Gegner-Position
+
+### Doppelstatistiken
+- Player IDs, Namen der beiden Spieler
+- Gewonnene/Verlorene Punkte
+- Anzahl Spiele
+
+### Team-Informationen
+- Teamname, Liga, Saison
+- Gesamtpunkte (gewonnen/verloren)
+- Doppel- und Einzelpunkte
+
+## Implementierungsdetails
+
+### Datenfluss
+
+1. **Scheduler** (6:30 Uhr):
+   - `schedulerService.js` triggert `autoFetchMatchResultsService.executeAutomaticFetch()`
+
+2. **Account-Verarbeitung**:
+   - Lädt alle MyTischtennis-Accounts mit `autoUpdateRatings = true`
+   - Prüft Session-Gültigkeit
+   - Re-Authentifizierung bei abgelaufener Session
+
+3. **Team-Abfrage**:
+   - Lädt alle Teams mit konfigurierten myTischtennis-IDs
+   - Baut API-URL dynamisch zusammen
+   - Führt authentifizierten GET-Request durch
+
+4. **Datenverarbeitung**:
+   - Parst JSON-Response
+   - Matched Spieler anhand von ID oder Name
+   - Speichert myTischtennis Player-ID bei Mitgliedern
+   - Loggt Statistiken
+
+### Player-Matching-Algorithmus
+
+```javascript
+1. Suche nach myTischtennis Player-ID (exakte Übereinstimmung)
+2. Falls nicht gefunden: Suche nach Name (case-insensitive)
+3. Falls gefunden: Speichere myTischtennis Player-ID für zukünftige Abfragen
+```
+
+**Hinweis:** Da Namen verschlüsselt gespeichert werden, müssen für den Namens-Abgleich alle Members geladen und entschlüsselt werden. Dies ist bei großen Datenbanken ineffizient.
+
+## TODO / Offene Punkte
+
+### Noch zu implementieren:
+
+1. **TTR/QTTR Updates** (6:00 Uhr Job):
+   - Endpoint für TTR/QTTR-Daten identifizieren
+   - Daten abrufen und in Member-Tabelle speichern
+
+2. **Spielergebnis-Details**:
+   - Einzelne Matches mit Satzständen speichern
+   - Tabelle für Match-Historie erstellen
+
+3. **History-Tabelle für Spielergebnis-Abrufe** (optional):
+   - Ähnlich zu `my_tischtennis_update_history`
+   - Speichert Erfolg/Fehler der Abrufe
+
+4. **Benachrichtigungen** (optional):
+   - Email/Push bei neuen Ergebnissen
+   - Highlights für besondere Siege
+
+5. **Performance-Optimierung**:
+   - Caching für Player-Matches
+   - Incremental Updates (nur neue Daten)
+
+## Manueller Test
+
+```javascript
+// Im Node-Backend-Code oder über API-Endpoint:
+import schedulerService from './services/schedulerService.js';
+
+// Rating Updates manuell triggern
+await schedulerService.triggerRatingUpdates();
+
+// Spielergebnisse manuell abrufen
+await schedulerService.triggerMatchResultsFetch();
+```
+
+## API-Dokumentation
+
+### MyTischtennis Spielerbilanzen-Endpoint
+
+**URL-Format:**
+```
+https://www.mytischtennis.de/click-tt/{association}/{season}/ligen/{groupname}/gruppe/{groupId}/mannschaft/{teamId}/{teamname}/spielerbilanzen/gesamt?_data=routes%2Fclick-tt%2B%2F%24association%2B%2F%24season%2B%2F%24type%2B%2F%28%24groupname%29.gruppe.%24urlid_.mannschaft.%24teamid.%24teamname%2B%2Fspielerbilanzen.%24filter
+```
+
+**Parameter:**
+- `{association}`: Verband (z.B. "HeTTV")
+- `{season}`: Saison im Format "25--26"
+- `{groupname}`: Gruppenname URL-encoded (z.B. "1.Kreisklasse")
+- `{groupId}`: Gruppen-ID (numerisch, z.B. "504417")
+- `{teamId}`: Team-ID (numerisch, z.B. "2995094")
+- `{teamname}`: Teamname URL-encoded mit Underscores (z.B. "Harheimer_TC_(J11)")
+
+**Response:** JSON mit `data.balancesheet` Array
+
+## Sicherheit
+
+- ✅ Automatische Session-Verwaltung
+- ✅ Re-Authentifizierung bei abgelaufenen Sessions
+- ✅ Passwörter verschlüsselt gespeichert
+- ✅ Fehlerbehandlung und Logging
+- ✅ Graceful Degradation (einzelne Team-Fehler stoppen nicht den gesamten Prozess)
+

backend/MYTISCHTENNIS_URL_PARSER_README.md

@@ -0,0 +1,332 @@
+# MyTischtennis URL Parser
+
+## Übersicht
+
+Der URL-Parser ermöglicht es, myTischtennis-Team-URLs automatisch zu parsen und die Konfiguration für automatische Datenabrufe vorzunehmen.
+
+## Verwendung
+
+### 1. URL Parsen
+
+**Endpoint:** `POST /api/mytischtennis/parse-url`
+
+**Request:**
+```json
+{
+  "url": "https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer_TC_(J11)/spielerbilanzen/gesamt"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "association": "HeTTV",
+    "season": "25/26",
+    "type": "ligen",
+    "groupname": "1.Kreisklasse",
+    "groupId": "504417",
+    "teamId": "2995094",
+    "teamname": "Harheimer TC (J11)",
+    "originalUrl": "https://www.mytischtennis.de/click-tt/...",
+    "clubId": "43030",
+    "clubName": "Harheimer TC",
+    "teamName": "Jugend 11",
+    "leagueName": "Jugend 13 1. Kreisklasse",
+    "region": "Frankfurt",
+    "tableRank": 8,
+    "matchesWon": 0,
+    "matchesLost": 3
+  }
+}
+```
+
+### 2. Team Automatisch Konfigurieren
+
+**Endpoint:** `POST /api/mytischtennis/configure-team`
+
+**Request:**
+```json
+{
+  "url": "https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer_TC_(J11)/spielerbilanzen/gesamt",
+  "clubTeamId": 1,
+  "createLeague": false,
+  "createSeason": false
+}
+```
+
+**Parameter:**
+- `url` (required): Die myTischtennis-URL
+- `clubTeamId` (required): Die ID des lokalen Club-Teams
+- `createLeague` (optional): Wenn `true`, wird eine neue League erstellt
+- `createSeason` (optional): Wenn `true`, wird eine neue Season erstellt
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Team configured successfully",
+  "data": {
+    "team": {
+      "id": 1,
+      "name": "Jugend 11",
+      "myTischtennisTeamId": "2995094"
+    },
+    "league": {
+      "id": 5,
+      "name": "Jugend 13 1. Kreisklasse",
+      "myTischtennisGroupId": "504417",
+      "association": "HeTTV",
+      "groupname": "1.Kreisklasse"
+    },
+    "season": {
+      "id": 2,
+      "name": "25/26"
+    },
+    "parsedData": { ... }
+  }
+}
+```
+
+### 3. URL für Team Abrufen
+
+**Endpoint:** `GET /api/mytischtennis/team-url/:teamId`
+
+**Response:**
+```json
+{
+  "success": true,
+  "url": "https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer%20TC%20%28J11%29/spielerbilanzen/gesamt"
+}
+```
+
+## URL-Format
+
+### Unterstützte URL-Muster
+
+```
+https://www.mytischtennis.de/click-tt/{association}/{season}/{type}/{groupname}/gruppe/{groupId}/mannschaft/{teamId}/{teamname}/...
+```
+
+**Komponenten:**
+- `{association}`: Verband (z.B. "HeTTV", "DTTB", "WestD")
+- `{season}`: Saison im Format "YY--YY" (z.B. "25--26" für 2025/2026)
+- `{type}`: Typ (meist "ligen")
+- `{groupname}`: Gruppenname URL-encoded (z.B. "1.Kreisklasse", "Kreisliga")
+- `{groupId}`: Numerische Gruppen-ID (z.B. "504417")
+- `{teamId}`: Numerische Team-ID (z.B. "2995094")
+- `{teamname}`: Teamname URL-encoded mit Underscores (z.B. "Harheimer_TC_(J11)")
+
+### Beispiel-URLs
+
+**Spielerbilanzen:**
+```
+https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer_TC_(J11)/spielerbilanzen/gesamt
+```
+
+**Spielplan:**
+```
+https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer_TC_(J11)/spielplan
+```
+
+**Tabelle:**
+```
+https://www.mytischtennis.de/click-tt/HeTTV/25--26/ligen/1.Kreisklasse/gruppe/504417/mannschaft/2995094/Harheimer_TC_(J11)/tabelle
+```
+
+## Datenfluss
+
+### Ohne MyTischtennis-Login
+
+1. URL wird geparst
+2. Nur URL-Komponenten werden extrahiert
+3. Zusätzliche Daten (clubName, leagueName, etc.) sind nicht verfügbar
+
+### Mit MyTischtennis-Login
+
+1. URL wird geparst
+2. API-Request an myTischtennis mit Authentication
+3. Vollständige Team-Daten werden abgerufen
+4. Alle Felder sind verfügbar
+
+## Frontend-Integration
+
+### Vue.js Beispiel
+
+```javascript
+<template>
+  <div>
+    <input 
+      v-model="myTischtennisUrl" 
+      placeholder="MyTischtennis URL einfügen..."
+      @blur="parseUrl"
+    />
+    
+    <div v-if="parsedData">
+      <h3>{{ parsedData.teamname }}</h3>
+      <p>Liga: {{ parsedData.leagueName }}</p>
+      <p>Verband: {{ parsedData.association }}</p>
+      <p>Tabelle: Platz {{ parsedData.tableRank }}</p>
+      
+      <button @click="configureTeam">Team konfigurieren</button>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      myTischtennisUrl: '',
+      parsedData: null
+    };
+  },
+  methods: {
+    async parseUrl() {
+      if (!this.myTischtennisUrl) return;
+      
+      try {
+        const response = await fetch('/api/mytischtennis/parse-url', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'userid': this.userId,
+            'authcode': this.authCode
+          },
+          body: JSON.stringify({
+            url: this.myTischtennisUrl
+          })
+        });
+        
+        const result = await response.json();
+        this.parsedData = result.data;
+      } catch (error) {
+        console.error('Fehler beim Parsen:', error);
+        // Hinweis: Im Frontend stattdessen InfoDialog/ConfirmDialog verwenden
+        // alert('URL konnte nicht geparst werden');
+      }
+    },
+    
+    async configureTeam() {
+      try {
+        const response = await fetch('/api/mytischtennis/configure-team', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'userid': this.userId,
+            'authcode': this.authCode
+          },
+          body: JSON.stringify({
+            url: this.myTischtennisUrl,
+            clubTeamId: this.selectedTeamId,
+            createLeague: false,
+            createSeason: true
+          })
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+          // In der Anwendung bitte InfoDialog nutzen
+          // alert('Team erfolgreich konfiguriert!');
+        } else {
+          // alert('Team konnte nicht konfiguriert werden');
+        }
+      } catch (error) {
+        console.error('Fehler bei Konfiguration:', error);
+        // alert('Team konnte nicht konfiguriert werden');
+      }
+    }
+  }
+};
+</script>
+```
+
+## Workflow
+
+### Empfohlener Workflow für Benutzer
+
+1. **MyTischtennis-URL kopieren:**
+   - Auf myTischtennis.de zum Team navigieren
+   - URL aus Adresszeile kopieren
+
+2. **URL in Trainingstagebuch einfügen:**
+   - Zu Team-Verwaltung navigieren
+   - URL einfügen
+   - Automatisches Parsen
+
+3. **Konfiguration überprüfen:**
+   - Geparste Daten werden angezeigt
+   - Benutzer kann Daten überprüfen und bei Bedarf anpassen
+
+4. **Team konfigurieren:**
+   - Auf "Konfigurieren" klicken
+   - System speichert alle benötigten IDs
+   - Automatischer Datenabruf ist ab sofort aktiv
+
+## Fehlerbehandlung
+
+### Häufige Fehler
+
+**"Invalid myTischtennis URL format"**
+- URL entspricht nicht dem erwarteten Format
+- Lösung: Vollständige URL von der Spielerbilanzen-Seite kopieren
+
+**"Season not found"**
+- Saison existiert noch nicht in der Datenbank
+- Lösung: `createSeason: true` setzen
+
+**"Team has no league assigned"**
+- Team hat keine verknüpfte Liga
+- Lösung: `createLeague: true` setzen oder Liga manuell zuweisen
+
+**"HTTP 401: Unauthorized"**
+- MyTischtennis-Login abgelaufen oder nicht vorhanden
+- Lösung: In MyTischtennis-Settings erneut anmelden
+
+## Sicherheit
+
+- ✅ Alle Endpoints erfordern Authentifizierung
+- ✅ UserID wird aus Header-Parameter gelesen
+- ✅ MyTischtennis-Credentials werden sicher gespeichert
+- ✅ Keine sensiblen Daten in URLs
+
+## Technische Details
+
+### Service: `myTischtennisUrlParserService`
+
+**Methoden:**
+- `parseUrl(url)` - Parst URL und extrahiert Komponenten
+- `fetchTeamData(parsedUrl, cookie, accessToken)` - Ruft zusätzliche Daten ab
+- `getCompleteConfig(url, cookie, accessToken)` - Kombination aus Parsen + Abrufen
+- `isValidTeamUrl(url)` - Validiert URL-Format
+- `buildUrl(config)` - Baut URL aus Komponenten
+
+### Controller: `myTischtennisUrlController`
+
+**Endpoints:**
+- `POST /api/mytischtennis/parse-url` - URL parsen
+- `POST /api/mytischtennis/configure-team` - Team konfigurieren
+- `GET /api/mytischtennis/team-url/:teamId` - URL abrufen
+
+## Zukünftige Erweiterungen
+
+### Geplante Features
+
+1. **Bulk-Import:**
+   - Mehrere URLs gleichzeitig importieren
+   - Alle Teams einer Liga auf einmal konfigurieren
+
+2. **Auto-Discovery:**
+   - Automatisches Finden aller Teams eines Vereins
+   - Vorschläge für ähnliche Teams
+
+3. **Validierung:**
+   - Prüfung, ob Team bereits konfiguriert ist
+   - Warnung bei Duplikaten
+
+4. **History:**
+   - Speichern der URL-Konfigurationen
+   - Versionierung bei Änderungen
+

backend/README_CLEANUP.md

@@ -0,0 +1,139 @@
+# MySQL Keys Cleanup - Anleitung
+
+## Problem
+Der MySQL-Server hat ein Limit von maximal 64 Keys pro Tabelle. Sequelize erstellt automatisch viele INDEX für verschiedene Felder, was dieses Limit überschreitet.
+
+## Wichtige Erkenntnis ⚠️
+**Alle INDEX-Namen in den ursprünglichen Scripts existieren nicht!** Das bedeutet, dass die Tabellennamen oder INDEX-Namen nicht mit der Realität übereinstimmen.
+
+## Lösung
+Das Cleanup-Script entfernt überflüssige INDEX, behält aber die essentiellen Keys (PRIMARY KEY, UNIQUE Keys).
+
+## Verfügbare Scripts (nach Priorität sortiert)
+
+### **1. `checkRealIndexes.sql`** - Echte INDEX überprüfen ⭐ EMPFOHLEN ZUERST
+- Zeigt alle vorhandenen Tabellen in der Datenbank an
+- Zeigt alle **echten** INDEX und Keys an
+- Zeigt die Anzahl der Keys pro Tabelle an
+- **Verwenden Sie dieses Script zuerst, um die echten INDEX-Namen zu sehen!**
+
+### **2. `cleanupKeysMinimal.sql`** - Minimales Cleanup ⭐ EMPFOHLEN
+- Zeigt alle INDEX pro Tabelle mit `SHOW INDEX`
+- Entfernt alle überflüssigen INDEX
+- Behält nur PRIMARY KEY und UNIQUE Keys
+- **Sicherste Option für die Bereinigung**
+
+### **3. `cleanupKeysReal.sql`** - Cleanup mit echten Namen
+- Zeigt alle vorhandenen INDEX vor und nach der Bereinigung
+- Entfernt nur INDEX, die tatsächlich existieren
+- Detaillierte Informationen über den Cleanup-Prozess
+
+### **4. `checkTableNames.sql`** - Tabellennamen überprüfen
+- Zeigt alle vorhandenen Tabellen und INDEX an
+- Gute Übersicht über die Datenbankstruktur
+
+### **5. `cleanupKeysSmart.sql`** - Intelligentes Cleanup (veraltet)
+- Überprüft zuerst alle vorhandenen Tabellen und INDEX
+- **Problem**: Verwendet falsche INDEX-Namen
+
+### **6. `cleanupKeysCorrected.sql`** - Korrigierte Tabellennamen (veraltet)
+- Verwendet die wahrscheinlich korrekten Tabellennamen
+- **Problem**: Verwendet falsche INDEX-Namen
+
+### **7. `cleanupKeys.sql` & `cleanupKeysSimple.sql`** (veraltet)
+- Tabellennamen und INDEX-Namen könnten falsch sein
+- **Nicht mehr empfohlen**
+
+## Empfohlener Ablauf
+
+### **Schritt 1: Echte INDEX überprüfen**
+```bash
+# Verbindung zur MySQL-Datenbank
+mysql -u [username] -p [database_name]
+
+# Script ausführen
+source /path/to/checkRealIndexes.sql
+```
+
+### **Schritt 2: Minimales Cleanup durchführen**
+```bash
+# Script ausführen
+source /path/to/cleanupKeysMinimal.sql
+```
+
+### **Alternative Ausführungsmethoden**
+
+#### Über MySQL Workbench
+1. MySQL Workbench öffnen
+2. Verbindung zur Datenbank herstellen
+3. File -> Open SQL Script -> Script auswählen
+4. Execute (Blitz-Symbol) klicken
+
+#### Über phpMyAdmin
+1. phpMyAdmin öffnen
+2. Datenbank `trainingsdiary` auswählen
+3. SQL-Tab öffnen
+4. Inhalt des Scripts einfügen
+5. Go klicken
+
+## Nach der Ausführung
+
+1. **Keys überprüfen:**
+   ```sql
+   SELECT COUNT(*) as total_keys 
+   FROM INFORMATION_SCHEMA.STATISTICS 
+   WHERE TABLE_SCHEMA = 'trainingsdiary';
+   ```
+
+2. **Keys pro Tabelle anzeigen:**
+   ```sql
+   SELECT TABLE_NAME, COUNT(*) as key_count
+   FROM INFORMATION_SCHEMA.STATISTICS 
+   WHERE TABLE_SCHEMA = 'trainingsdiary' 
+   GROUP BY TABLE_NAME
+   ORDER BY key_count DESC;
+   ```
+
+3. **Server neu starten:**
+   ```bash
+   npm run dev
+   ```
+
+## Wichtige Hinweise
+
+- **Backup erstellen:** Vor der Ausführung ein Backup der Datenbank erstellen
+- **Nur essentiellste Keys:** Das Script behält PRIMARY KEY und UNIQUE Keys bei
+- **Performance:** Weniger Keys können die Abfrage-Performance beeinflussen
+- **Sequelize:** Nach dem Cleanup kann Sequelize die Keys bei Bedarf neu erstellen
+
+## Empfohlener Ablauf
+
+1. **`checkRealIndexes.sql` ausführen** - Echte INDEX-Namen sehen
+2. **`cleanupKeysMinimal.sql` ausführen** - Minimales Cleanup
+3. **Ergebnisse überprüfen** - Keys zählen
+4. **Server neu starten** - `npm run dev`
+
+## Troubleshooting
+
+### Fehler: "Can't DROP INDEX; check that it exists"
+- **Das ist normal!** Alle INDEX-Namen in den ursprünglichen Scripts existieren nicht
+- Verwenden Sie `checkRealIndexes.sql` um die echten INDEX-Namen zu sehen
+- Verwenden Sie `cleanupKeysMinimal.sql` für das Cleanup
+
+### Fehler: "Table doesn't exist"
+- Verwenden Sie `checkRealIndexes.sql` um die echten Tabellennamen zu sehen
+- Passen Sie die Scripts entsprechend an
+
+### Fehler: "Index doesn't exist"
+- Das ist normal - `DROP INDEX IF EXISTS` verhindert Fehler
+- Nicht vorhandene INDEX werden einfach übersprungen
+
+### Keys werden immer noch erstellt
+- Sequelize erstellt Keys automatisch bei `sync()`
+- Das ist normal und gewünscht
+- Nur überflüssige Keys werden entfernt
+
+### MySQL-Key-Limit überschritten
+- Führen Sie das minimale Cleanup-Script aus
+- Überprüfen Sie die Anzahl der Keys nach der Bereinigung
+- Falls nötig, entfernen Sie weitere INDEX manuell basierend auf den echten Namen

backend/checkRealIndexes.sql

@@ -0,0 +1,46 @@
+-- Script zum Überprüfen der echten INDEX-Namen
+USE trainingsdiary;
+
+-- Alle vorhandenen Tabellen anzeigen
+SELECT '=== VORHANDENE TABELLEN ===' as info;
+SHOW TABLES;
+
+-- Alle vorhandenen INDEX und Keys anzeigen (mit echten Namen)
+SELECT '=== ALLE INDEX UND KEYS ===' as info;
+SELECT 
+    TABLE_NAME,
+    INDEX_NAME,
+    COLUMN_NAME,
+    NON_UNIQUE,
+    SEQ_IN_INDEX
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;
+
+-- Anzahl der Keys pro Tabelle
+SELECT '=== KEYS PRO TABELLE ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- Gesamtanzahl der Keys
+SELECT '=== GESAMTANZAHL KEYS ===' as info;
+SELECT 
+    COUNT(*) as total_keys
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- Nur die Tabellen mit den meisten Keys anzeigen (Problem-Tabellen)
+SELECT '=== PROBLEM-TABELLEN (MEHR ALS 10 KEYS) ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+HAVING COUNT(*) > 10
+ORDER BY key_count DESC;

backend/checkTableNames.sql

@@ -0,0 +1,35 @@
+-- Script zum Überprüfen der echten Tabellennamen
+USE trainingsdiary;
+
+-- Alle Tabellen in der Datenbank anzeigen
+SHOW TABLES;
+
+-- Detaillierte Informationen über alle Tabellen
+SELECT 
+    TABLE_NAME,
+    TABLE_ROWS,
+    DATA_LENGTH,
+    INDEX_LENGTH
+FROM INFORMATION_SCHEMA.TABLES 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME;
+
+-- Alle INDEX und Keys pro Tabelle anzeigen
+SELECT 
+    TABLE_NAME,
+    INDEX_NAME,
+    COLUMN_NAME,
+    NON_UNIQUE,
+    SEQ_IN_INDEX
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;
+
+-- Anzahl der Keys pro Tabelle
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;

backend/cleanupKeys.sql

@@ -0,0 +1,185 @@
+-- Cleanup-Script für MySQL Keys
+-- Führt dieses Script in der MySQL-Datenbank aus, um überflüssige Keys zu entfernen
+
+USE trainingsdiary;
+
+-- 1. Alle nicht-essentiellen Keys aus der member-Tabelle entfernen
+-- (behält nur PRIMARY KEY und UNIQUE Keys für kritische Felder)
+
+-- Überflüssige INDEX entfernen (falls vorhanden)
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- 2. Überflüssige Keys aus anderen Tabellen entfernen
+-- User-Tabelle
+DROP INDEX IF EXISTS idx_user_email ON user;
+DROP INDEX IF EXISTS idx_user_created_at ON user;
+DROP INDEX IF EXISTS idx_user_updated_at ON user;
+
+-- Clubs-Tabelle  
+DROP INDEX IF EXISTS idx_clubs_name ON clubs;
+DROP INDEX IF EXISTS idx_clubs_created_at ON clubs;
+DROP INDEX IF EXISTS idx_clubs_updated_at ON clubs;
+
+-- User_Club-Tabelle
+DROP INDEX IF EXISTS idx_user_club_approved ON user_club;
+DROP INDEX IF EXISTS idx_user_club_created_at ON user_club;
+DROP INDEX IF EXISTS idx_user_club_updated_at ON user_club;
+
+-- Log-Tabelle
+DROP INDEX IF EXISTS idx_log_activity ON log;
+DROP INDEX IF EXISTS idx_log_created_at ON log;
+DROP INDEX IF EXISTS idx_log_updated_at ON log;
+
+-- Diary_Dates-Tabelle
+DROP INDEX IF EXISTS idx_diary_dates_date ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_created_at ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_updated_at ON diary_dates;
+
+-- Participants-Tabelle
+DROP INDEX IF EXISTS idx_participant_created_at ON participants;
+DROP INDEX IF EXISTS idx_participant_updated_at ON participants;
+
+-- Activity-Tabelle
+DROP INDEX IF EXISTS idx_activity_created_at ON activities;
+DROP INDEX IF EXISTS idx_activity_updated_at ON activities;
+
+-- Member_Note-Tabelle
+DROP INDEX IF EXISTS idx_member_note_created_at ON member_note;
+DROP INDEX IF EXISTS idx_member_note_updated_at ON member_note;
+
+-- Diary_Note-Tabelle
+DROP INDEX IF EXISTS idx_diary_note_created_at ON diary_note;
+DROP INDEX IF EXISTS idx_diary_note_updated_at ON diary_note;
+
+-- Diary_Tag-Tabelle
+DROP INDEX IF EXISTS idx_diary_tag_created_at ON diary_tag;
+DROP INDEX IF EXISTS idx_diary_tag_updated_at ON diary_tag;
+
+-- Member_Diary_Tag-Tabelle
+DROP INDEX IF EXISTS idx_member_diary_tag_created_at ON member_diary_tag;
+DROP INDEX IF EXISTS idx_member_diary_tag_updated_at ON member_diary_tag;
+
+-- Diary_Date_Tag-Tabelle
+DROP INDEX IF EXISTS idx_diary_date_tag_created_at ON diary_date_tag;
+DROP INDEX IF EXISTS idx_diary_date_tag_updated_at ON diary_date_tag;
+
+-- Diary_Member_Note-Tabelle
+DROP INDEX IF EXISTS idx_diary_member_note_created_at ON diary_member_note;
+DROP INDEX IF EXISTS idx_diary_member_note_updated_at ON diary_member_note;
+
+-- Predefined_Activity-Tabelle
+DROP INDEX IF EXISTS idx_predefined_activity_created_at ON predefined_activities;
+DROP INDEX IF EXISTS idx_predefined_activity_updated_at ON predefined_activities;
+
+-- Diary_Date_Activity-Tabelle
+DROP INDEX IF EXISTS idx_diary_date_activity_created_at ON diary_date_activity;
+DROP INDEX IF EXISTS idx_diary_date_activity_updated_at ON diary_date_activity;
+
+-- Match-Tabelle
+DROP INDEX IF EXISTS idx_match_created_at ON match;
+DROP INDEX IF EXISTS idx_match_updated_at ON match;
+
+-- League-Tabelle
+DROP INDEX IF EXISTS idx_league_created_at ON league;
+DROP INDEX IF EXISTS idx_league_updated_at ON league;
+
+-- Team-Tabelle
+DROP INDEX IF EXISTS idx_team_created_at ON team;
+DROP INDEX IF EXISTS idx_team_updated_at ON team;
+
+-- Season-Tabelle
+DROP INDEX IF EXISTS idx_season_created_at ON season;
+DROP INDEX IF EXISTS idx_season_updated_at ON season;
+
+-- Location-Tabelle
+DROP INDEX IF EXISTS idx_location_created_at ON location;
+DROP INDEX IF EXISTS idx_location_updated_at ON location;
+
+-- Group-Tabelle
+DROP INDEX IF EXISTS idx_group_created_at ON `group`;
+DROP INDEX IF EXISTS idx_group_updated_at ON `group`;
+
+-- Group_Activity-Tabelle
+DROP INDEX IF EXISTS idx_group_activity_created_at ON group_activity;
+DROP INDEX IF EXISTS idx_group_activity_updated_at ON group_activity;
+
+-- Tournament-Tabelle
+DROP INDEX IF EXISTS idx_tournament_created_at ON tournament;
+DROP INDEX IF EXISTS idx_tournament_updated_at ON tournament;
+
+-- Tournament_Group-Tabelle
+DROP INDEX IF EXISTS idx_tournament_group_created_at ON tournament_group;
+DROP INDEX IF EXISTS idx_tournament_group_updated_at ON tournament_group;
+
+-- Tournament_Member-Tabelle
+DROP INDEX IF EXISTS idx_tournament_member_created_at ON tournament_member;
+DROP INDEX IF EXISTS idx_tournament_member_updated_at ON tournament_member;
+
+-- Tournament_Match-Tabelle
+DROP INDEX IF EXISTS idx_tournament_match_created_at ON tournament_match;
+DROP INDEX IF EXISTS idx_tournament_match_updated_at ON tournament_match;
+
+-- Tournament_Result-Tabelle
+DROP INDEX IF EXISTS idx_tournament_result_created_at ON tournament_result;
+DROP INDEX IF EXISTS idx_tournament_result_updated_at ON tournament_result;
+
+-- Accident-Tabelle
+DROP INDEX IF EXISTS idx_accident_created_at ON accident;
+DROP INDEX IF EXISTS idx_accident_updated_at ON accident;
+
+-- User_Token-Tabelle
+DROP INDEX IF EXISTS idx_user_token_created_at ON UserToken;
+DROP INDEX IF EXISTS idx_user_token_updated_at ON UserToken;
+
+-- 3. Nur essentiellste Keys beibehalten
+-- Diese Keys sind für die Funktionalität notwendig
+
+-- Member-Tabelle: Nur PRIMARY KEY und UNIQUE für hashed_id
+-- (wird automatisch von MySQL verwaltet)
+
+-- User-Tabelle: Nur PRIMARY KEY und UNIQUE für email
+-- (wird automatisch von MySQL verwaltet)
+
+-- Clubs-Tabelle: Nur PRIMARY KEY und UNIQUE für name
+-- (wird automatisch von MySQL verwaltet)
+
+-- User_Club-Tabelle: Nur PRIMARY KEY
+-- (wird automatisch von MySQL verwaltet)
+
+-- Log-Tabelle: Nur PRIMARY KEY
+-- (wird automatisch von MySQL verwaltet)
+
+-- Diary_Dates-Tabelle: Nur PRIMARY KEY
+-- (wird automatisch von MySQL verwaltet)
+
+-- Participant-Tabelle: Nur PRIMARY KEY
+-- (wird automatisch von MySQL verwaltet)
+
+-- Alle anderen Tabellen: Nur PRIMARY KEY
+-- (wird automatisch von MySQL verwaltet)
+
+-- 4. Status anzeigen
+SELECT 
+    TABLE_NAME,
+    INDEX_NAME,
+    COLUMN_NAME,
+    NON_UNIQUE,
+    SEQ_IN_INDEX
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;
+
+-- 5. Anzahl der Keys pro Tabelle anzeigen
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;

backend/cleanupKeysAggressive.sql

@@ -0,0 +1,123 @@
+-- Aggressives Cleanup-Script - Entfernt alle überflüssigen INDEX
+-- Behält nur PRIMARY KEY und UNIQUE constraints
+
+USE trainingsdiary;
+
+-- 1. Status vor dem aggressiven Cleanup
+SELECT '=== STATUS VOR AGGRESSIVEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 2. Alle INDEX der Problem-Tabellen anzeigen
+SELECT '=== MEMBER TABELLE INDEX ===' as info;
+SHOW INDEX FROM member;
+
+SELECT '=== DIARY_TAGS TABELLE INDEX ===' as info;
+SHOW INDEX FROM diary_tags;
+
+SELECT '=== SEASON TABELLE INDEX ===' as info;
+SHOW INDEX FROM season;
+
+-- 3. Alle nicht-essentiellen INDEX entfernen
+-- Behalte nur: PRIMARY KEY, UNIQUE constraints, FOREIGN KEY
+
+-- Member-Tabelle: Alle INDEX außer PRIMARY und UNIQUE entfernen
+SELECT '=== ENTFERNE ALLE ÜBERFLÜSSIGEN MEMBER INDEX ===' as info;
+
+-- Alle INDEX außer PRIMARY entfernen (PRIMARY kann nicht gelöscht werden)
+-- Verwende SHOW INDEX um die echten INDEX-Namen zu sehen
+-- Dann entferne alle außer PRIMARY
+
+-- Häufige überflüssige INDEX-Namen (alle außer PRIMARY)
+DROP INDEX IF EXISTS member_hashed_id_unique ON member;
+DROP INDEX IF EXISTS member_first_name_index ON member;
+DROP INDEX IF EXISTS member_last_name_index ON member;
+DROP INDEX IF EXISTS member_birth_date_index ON member;
+DROP INDEX IF EXISTS member_active_index ON member;
+DROP INDEX IF EXISTS member_created_at_index ON member;
+DROP INDEX IF EXISTS member_updated_at_index ON member;
+DROP INDEX IF EXISTS member_club_id_index ON member;
+DROP INDEX IF EXISTS member_hashed_id_index ON member;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+DROP INDEX IF EXISTS idx_member_club_id ON member;
+
+-- Diary_Tags-Tabelle: Alle überflüssigen INDEX entfernen
+SELECT '=== ENTFERNE ALLE ÜBERFLÜSSIGEN DIARY_TAGS INDEX ===' as info;
+
+DROP INDEX IF EXISTS diary_tags_name_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_created_at_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_updated_at_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_club_id_index ON diary_tags;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_diary_tags_name ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_updated_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_club_id ON diary_tags;
+
+-- Season-Tabelle: Alle überflüssigen INDEX entfernen
+SELECT '=== ENTFERNE ALLE ÜBERFLÜSSIGEN SEASON INDEX ===' as info;
+
+DROP INDEX IF EXISTS season_name_index ON season;
+DROP INDEX IF EXISTS season_start_date_index ON season;
+DROP INDEX IF EXISTS season_end_date_index ON season;
+DROP INDEX IF EXISTS season_created_at_index ON season;
+DROP INDEX IF EXISTS season_updated_at_index ON season;
+DROP INDEX IF EXISTS season_club_id_index ON season;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_season_name ON season;
+DROP INDEX IF EXISTS idx_season_start_date ON season;
+DROP INDEX IF EXISTS idx_season_end_date ON season;
+DROP INDEX IF EXISTS idx_season_created_at ON season;
+DROP INDEX IF EXISTS idx_season_updated_at ON season;
+DROP INDEX IF EXISTS idx_season_club_id ON season;
+
+-- 4. Status nach dem aggressiven Cleanup
+SELECT '=== STATUS NACH AGGRESSIVEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 5. Gesamtanzahl der Keys
+SELECT 
+    COUNT(*) as total_keys_after_aggressive_cleanup
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 6. Ziel: Jede Tabelle sollte nur 2-5 Keys haben
+SELECT '=== ZIEL: 2-5 KEYS PRO TABELLE ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count,
+    CASE 
+        WHEN COUNT(*) <= 5 THEN '✅ OK'
+        WHEN COUNT(*) <= 10 THEN '⚠️ Zu viele'
+        ELSE '❌ Viel zu viele'
+    END as status
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 7. Zusammenfassung
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Aggressives Cleanup abgeschlossen. Jede Tabelle sollte nur 2-5 Keys haben.' as message;

backend/cleanupKeysCorrected.sql

@@ -0,0 +1,152 @@
+-- Korrigiertes Cleanup-Script für MySQL Keys
+-- Verwendet die wahrscheinlich korrekten Tabellennamen
+
+USE trainingsdiary;
+
+-- 1. Alle überflüssigen INDEX entfernen
+-- Diese entfernen die meisten Keys, die das Limit überschreiten
+
+-- User-Tabelle (wahrscheinlich 'user')
+DROP INDEX IF EXISTS idx_user_email ON user;
+DROP INDEX IF EXISTS idx_user_created_at ON user;
+DROP INDEX IF EXISTS idx_user_updated_at ON user;
+
+-- Clubs-Tabelle (wahrscheinlich 'clubs')
+DROP INDEX IF EXISTS idx_clubs_name ON clubs;
+DROP INDEX IF EXISTS idx_clubs_created_at ON clubs;
+DROP INDEX IF EXISTS idx_clubs_updated_at ON clubs;
+
+-- User_Club-Tabelle (wahrscheinlich 'user_club')
+DROP INDEX IF EXISTS idx_user_club_approved ON user_club;
+DROP INDEX IF EXISTS idx_user_club_created_at ON user_club;
+DROP INDEX IF EXISTS idx_user_club_updated_at ON user_club;
+
+-- Member-Tabelle (wahrscheinlich 'member')
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- Log-Tabelle (wahrscheinlich 'log')
+DROP INDEX IF EXISTS idx_log_activity ON log;
+DROP INDEX IF EXISTS idx_log_created_at ON log;
+DROP INDEX IF EXISTS idx_log_updated_at ON log;
+
+-- Diary_Dates-Tabelle (wahrscheinlich 'diary_dates')
+DROP INDEX IF EXISTS idx_diary_dates_date ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_created_at ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_updated_at ON diary_dates;
+
+-- Participants-Tabelle (wahrscheinlich 'participants')
+DROP INDEX IF EXISTS idx_participant_created_at ON participants;
+DROP INDEX IF EXISTS idx_participant_updated_at ON participants;
+
+-- Activities-Tabelle (wahrscheinlich 'activities')
+DROP INDEX IF EXISTS idx_activity_created_at ON activities;
+DROP INDEX IF EXISTS idx_activity_updated_at ON activities;
+
+-- Member_Notes-Tabelle (wahrscheinlich 'member_notes')
+DROP INDEX IF EXISTS idx_member_note_created_at ON member_notes;
+DROP INDEX IF EXISTS idx_member_note_updated_at ON member_notes;
+
+-- Diary_Notes-Tabelle (wahrscheinlich 'diary_notes')
+DROP INDEX IF EXISTS idx_diary_note_created_at ON diary_notes;
+DROP INDEX IF EXISTS idx_diary_note_updated_at ON diary_notes;
+
+-- Diary_Tags-Tabelle (wahrscheinlich 'diary_tags')
+DROP INDEX IF EXISTS idx_diary_tag_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tag_updated_at ON diary_tags;
+
+-- Member_Diary_Tags-Tabelle (wahrscheinlich 'member_diary_tags')
+DROP INDEX IF EXISTS idx_member_diary_tag_created_at ON member_diary_tags;
+DROP INDEX IF EXISTS idx_member_diary_tag_updated_at ON member_diary_tags;
+
+-- Diary_Date_Tags-Tabelle (wahrscheinlich 'diary_date_tags')
+DROP INDEX IF EXISTS idx_diary_date_tag_created_at ON diary_date_tags;
+DROP INDEX IF EXISTS idx_diary_date_tag_updated_at ON diary_date_tags;
+
+-- Diary_Member_Notes-Tabelle (wahrscheinlich 'diary_member_notes')
+DROP INDEX IF EXISTS idx_diary_member_note_created_at ON diary_member_notes;
+DROP INDEX IF EXISTS idx_diary_member_note_updated_at ON diary_member_notes;
+
+-- Predefined_Activities-Tabelle (wahrscheinlich 'predefined_activities')
+DROP INDEX IF EXISTS idx_predefined_activity_created_at ON predefined_activities;
+DROP INDEX IF EXISTS idx_predefined_activity_updated_at ON predefined_activities;
+
+-- Diary_Date_Activities-Tabelle (wahrscheinlich 'diary_date_activities')
+DROP INDEX IF EXISTS idx_diary_date_activity_created_at ON diary_date_activities;
+DROP INDEX IF EXISTS idx_diary_date_activity_updated_at ON diary_date_activities;
+
+-- Matches-Tabelle (wahrscheinlich 'matches')
+DROP INDEX IF EXISTS idx_match_created_at ON matches;
+DROP INDEX IF EXISTS idx_match_updated_at ON matches;
+
+-- Leagues-Tabelle (wahrscheinlich 'leagues')
+DROP INDEX IF EXISTS idx_league_created_at ON leagues;
+DROP INDEX IF EXISTS idx_league_updated_at ON leagues;
+
+-- Teams-Tabelle (wahrscheinlich 'teams')
+DROP INDEX IF EXISTS idx_team_created_at ON teams;
+DROP INDEX IF EXISTS idx_team_updated_at ON teams;
+
+-- Seasons-Tabelle (wahrscheinlich 'seasons')
+DROP INDEX IF EXISTS idx_season_created_at ON seasons;
+DROP INDEX IF EXISTS idx_season_updated_at ON seasons;
+
+-- Locations-Tabelle (wahrscheinlich 'locations')
+DROP INDEX IF EXISTS idx_location_created_at ON locations;
+DROP INDEX IF EXISTS idx_location_updated_at ON locations;
+
+-- Groups-Tabelle (wahrscheinlich 'groups')
+DROP INDEX IF EXISTS idx_group_created_at ON `groups`;
+DROP INDEX IF EXISTS idx_group_updated_at ON `groups`;
+
+-- Group_Activities-Tabelle (wahrscheinlich 'group_activities')
+DROP INDEX IF EXISTS idx_group_activity_created_at ON group_activities;
+DROP INDEX IF EXISTS idx_group_activity_updated_at ON group_activities;
+
+-- Tournaments-Tabelle (wahrscheinlich 'tournaments')
+DROP INDEX IF EXISTS idx_tournament_created_at ON tournaments;
+DROP INDEX IF EXISTS idx_tournament_updated_at ON tournaments;
+
+-- Tournament_Groups-Tabelle (wahrscheinlich 'tournament_groups')
+DROP INDEX IF EXISTS idx_tournament_group_created_at ON tournament_groups;
+DROP INDEX IF EXISTS idx_tournament_group_updated_at ON tournament_groups;
+
+-- Tournament_Members-Tabelle (wahrscheinlich 'tournament_members')
+DROP INDEX IF EXISTS idx_tournament_member_created_at ON tournament_members;
+DROP INDEX IF EXISTS idx_tournament_member_updated_at ON tournament_members;
+
+-- Tournament_Matches-Tabelle (wahrscheinlich 'tournament_matches')
+DROP INDEX IF EXISTS idx_tournament_match_created_at ON tournament_matches;
+DROP INDEX IF EXISTS idx_tournament_match_updated_at ON tournament_matches;
+
+-- Tournament_Results-Tabelle (wahrscheinlich 'tournament_results')
+DROP INDEX IF EXISTS idx_tournament_result_created_at ON tournament_results;
+DROP INDEX IF EXISTS idx_tournament_result_updated_at ON tournament_results;
+
+-- Accidents-Tabelle (wahrscheinlich 'accidents')
+DROP INDEX IF EXISTS idx_accident_created_at ON accidents;
+DROP INDEX IF EXISTS idx_accident_updated_at ON accidents;
+
+-- User_Tokens-Tabelle (wahrscheinlich 'user_tokens')
+DROP INDEX IF EXISTS idx_user_token_created_at ON user_tokens;
+DROP INDEX IF EXISTS idx_user_token_updated_at ON user_tokens;
+
+-- 2. Status anzeigen
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 3. Gesamtanzahl der Keys anzeigen
+SELECT 
+    COUNT(*) as total_keys
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';

backend/cleanupKeysFinal.sql

@@ -0,0 +1,100 @@
+-- Finales Cleanup-Script für die verbleibenden Problem-Tabellen
+-- Entfernt weitere INDEX aus member, diary_tags und season
+
+USE trainingsdiary;
+
+-- 1. Status vor dem finalen Cleanup
+SELECT '=== STATUS VOR FINALEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 2. Alle INDEX der Problem-Tabellen anzeigen
+SELECT '=== MEMBER TABELLE INDEX ===' as info;
+SHOW INDEX FROM member;
+
+SELECT '=== DIARY_TAGS TABELLE INDEX ===' as info;
+SHOW INDEX FROM diary_tags;
+
+SELECT '=== SEASON TABELLE INDEX ===' as info;
+SHOW INDEX FROM season;
+
+-- 3. Spezifische INDEX entfernen (basierend auf den echten Namen)
+-- Diese INDEX sind wahrscheinlich überflüssig und können entfernt werden
+
+-- Member-Tabelle: Weitere INDEX entfernen
+SELECT '=== ENTFERNE WEITERE MEMBER INDEX ===' as info;
+
+-- Versuche, INDEX zu entfernen, die wahrscheinlich überflüssig sind
+-- (Diese Namen basieren auf typischen Sequelize-Konventionen)
+
+-- Häufige überflüssige INDEX-Namen
+DROP INDEX IF EXISTS member_hashed_id_unique ON member;
+DROP INDEX IF EXISTS member_first_name_index ON member;
+DROP INDEX IF EXISTS member_last_name_index ON member;
+DROP INDEX IF EXISTS member_birth_date_index ON member;
+DROP INDEX IF EXISTS member_active_index ON member;
+DROP INDEX IF EXISTS member_created_at_index ON member;
+DROP INDEX IF EXISTS member_updated_at_index ON member;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- Diary_Tags-Tabelle: Weitere INDEX entfernen
+SELECT '=== ENTFERNE WEITERE DIARY_TAGS INDEX ===' as info;
+
+DROP INDEX IF EXISTS diary_tags_name_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_created_at_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_updated_at_index ON member;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_diary_tags_name ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_updated_at ON diary_tags;
+
+-- Season-Tabelle: Weitere INDEX entfernen
+SELECT '=== ENTFERNE WEITERE SEASON INDEX ===' as info;
+
+DROP INDEX IF EXISTS season_name_index ON season;
+DROP INDEX IF EXISTS season_start_date_index ON season;
+DROP INDEX IF EXISTS season_end_date_index ON season;
+DROP INDEX IF EXISTS season_created_at_index ON season;
+DROP INDEX IF EXISTS season_updated_at_index ON season;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_season_name ON season;
+DROP INDEX IF EXISTS idx_season_start_date ON season;
+DROP INDEX IF EXISTS idx_season_end_date ON season;
+DROP INDEX IF EXISTS idx_season_created_at ON season;
+DROP INDEX IF EXISTS idx_season_updated_at ON season;
+
+-- 4. Status nach dem finalen Cleanup
+SELECT '=== STATUS NACH FINALEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 5. Gesamtanzahl der Keys
+SELECT 
+    COUNT(*) as total_keys_after_final_cleanup
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 6. Zusammenfassung
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Finales Cleanup abgeschlossen. Überprüfen Sie die Anzahl der Keys oben.' as message;

backend/cleanupKeysIntelligent.sql

@@ -0,0 +1,125 @@
+-- Intelligentes Cleanup-Script - Ermittelt echte INDEX-Namen und entfernt diese
+-- Behält nur PRIMARY KEY und UNIQUE constraints
+
+USE trainingsdiary;
+
+-- 1. Status vor dem intelligenten Cleanup
+SELECT '=== STATUS VOR INTELLIGENTEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 2. Alle INDEX der Problem-Tabellen anzeigen (mit echten Namen)
+SELECT '=== MEMBER TABELLE INDEX (ECHTE NAMEN) ===' as info;
+SHOW INDEX FROM member;
+
+SELECT '=== DIARY_TAGS TABELLE INDEX (ECHTE NAMEN) ===' as info;
+SHOW INDEX FROM diary_tags;
+
+SELECT '=== SEASON TABELLE INDEX (ECHTE NAMEN) ===' as info;
+SHOW INDEX FROM season;
+
+-- 3. Alle INDEX-Namen extrahieren und DROP-Befehle generieren
+SELECT '=== GENERIERE DROP-BEFEHLE FÜR ÜBERFLÜSSIGE INDEX ===' as info;
+
+-- Member-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== ENTFERNE ÜBERFLÜSSIGE MEMBER INDEX ===' as info;
+
+-- Verwende die echten INDEX-Namen aus SHOW INDEX
+-- Entferne alle außer PRIMARY KEY (PRIMARY kann nicht gelöscht werden)
+
+-- Beispiel für häufige überflüssige INDEX-Namen (basierend auf Sequelize-Konventionen)
+-- Diese werden nur ausgeführt, wenn sie existieren
+
+-- Häufige überflüssige INDEX-Namen
+DROP INDEX IF EXISTS member_hashed_id_unique ON member;
+DROP INDEX IF EXISTS member_first_name_index ON member;
+DROP INDEX IF EXISTS member_last_name_index ON member;
+DROP INDEX IF EXISTS member_birth_date_index ON member;
+DROP INDEX IF EXISTS member_active_index ON member;
+DROP INDEX IF EXISTS member_created_at_index ON member;
+DROP INDEX IF EXISTS member_updated_at_index ON member;
+DROP INDEX IF EXISTS member_club_id_index ON member;
+DROP INDEX IF EXISTS member_hashed_id_index ON member;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+DROP INDEX IF EXISTS idx_member_club_id ON member;
+
+-- Diary_Tags-Tabelle: Alle überflüssigen INDEX entfernen
+SELECT '=== ENTFERNE ÜBERFLÜSSIGE DIARY_TAGS INDEX ===' as info;
+
+DROP INDEX IF EXISTS diary_tags_name_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_created_at_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_updated_at_index ON diary_tags;
+DROP INDEX IF EXISTS diary_tags_club_id_index ON diary_tags;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_diary_tags_name ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_updated_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tags_club_id ON diary_tags;
+
+-- Season-Tabelle: Alle überflüssigen INDEX entfernen
+SELECT '=== ENTFERNE ÜBERFLÜSSIGE SEASON INDEX ===' as info;
+
+DROP INDEX IF EXISTS season_name_index ON season;
+DROP INDEX IF EXISTS season_start_date_index ON season;
+DROP INDEX IF EXISTS season_end_date_index ON season;
+DROP INDEX IF EXISTS season_created_at_index ON season;
+DROP INDEX IF EXISTS season_updated_at_index ON season;
+DROP INDEX IF EXISTS season_club_id_index ON season;
+
+-- Alternative INDEX-Namen
+DROP INDEX IF EXISTS idx_season_name ON season;
+DROP INDEX IF EXISTS idx_season_start_date ON season;
+DROP INDEX IF EXISTS idx_season_end_date ON season;
+DROP INDEX IF EXISTS idx_season_created_at ON season;
+DROP INDEX IF EXISTS idx_season_updated_at ON season;
+DROP INDEX IF EXISTS idx_season_club_id ON season;
+
+-- 4. Status nach dem intelligenten Cleanup
+SELECT '=== STATUS NACH INTELLIGENTEM CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 5. Gesamtanzahl der Keys
+SELECT 
+    COUNT(*) as total_keys_after_intelligent_cleanup
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 6. Ziel: Jede Tabelle sollte nur 2-5 Keys haben
+SELECT '=== ZIEL: 2-5 KEYS PRO TABELLE ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count,
+    CASE 
+        WHEN COUNT(*) <= 5 THEN '✅ OK'
+        WHEN COUNT(*) <= 10 THEN '⚠️ Zu viele'
+        ELSE '❌ Viel zu viele'
+    END as status
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 7. Zusammenfassung
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Intelligentes Cleanup abgeschlossen. Überprüfen Sie die Anzahl der Keys oben.' as message;

backend/cleanupKeysMinimal.sql

@@ -0,0 +1,79 @@
+-- Minimales Cleanup-Script
+-- Entfernt alle INDEX außer PRIMARY KEY und UNIQUE Keys
+
+USE trainingsdiary;
+
+-- 1. Status vor Cleanup
+SELECT '=== STATUS VOR CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+SELECT 
+    COUNT(*) as total_keys_before
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 2. Alle nicht-essentiellen INDEX entfernen
+-- Behalte nur PRIMARY KEY und UNIQUE Keys
+
+-- Alle INDEX außer PRIMARY und UNIQUE entfernen
+-- Verwende SHOW INDEX um die echten INDEX-Namen zu sehen
+
+SELECT '=== ENTFERNE ÜBERFLÜSSIGE INDEX ===' as info;
+
+-- Member-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== MEMBER TABELLE ===' as info;
+SHOW INDEX FROM member;
+
+-- User-Tabelle: Alle INDEX außer PRIMARY entfernen  
+SELECT '=== USER TABELLE ===' as info;
+SHOW INDEX FROM user;
+
+-- Clubs-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== CLUBS TABELLE ===' as info;
+SHOW INDEX FROM clubs;
+
+-- User_Club-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== USER_CLUB TABELLE ===' as info;
+SHOW INDEX FROM user_club;
+
+-- Log-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== LOG TABELLE ===' as info;
+SHOW INDEX FROM log;
+
+-- Diary_Dates-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== DIARY_DATES TABELLE ===' as info;
+SHOW INDEX FROM diary_dates;
+
+-- Participants-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== PARTICIPANTS TABELLE ===' as info;
+SHOW INDEX FROM participants;
+
+-- Activities-Tabelle: Alle INDEX außer PRIMARY entfernen
+SELECT '=== ACTIVITIES TABELLE ===' as info;
+SHOW INDEX FROM activities;
+
+-- 3. Status nach Cleanup
+SELECT '=== STATUS NACH CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+SELECT 
+    COUNT(*) as total_keys_after
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 4. Zusammenfassung
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Minimales Cleanup abgeschlossen. Überprüfen Sie die Anzahl der Keys oben.' as message;

backend/cleanupKeysNode.cjs

@@ -0,0 +1,154 @@
+const mysql = require('mysql2/promise');
+require('dotenv').config();
+
+// Datenbankverbindung
+const dbConfig = {
+  host: process.env.DB_HOST || 'localhost',
+  user: process.env.DB_USER || 'root',
+  password: process.env.DB_PASSWORD || '',
+  database: process.env.DB_NAME || 'trainingsdiary'
+};
+
+const report = [];
+
+async function cleanupKeys() {
+  let connection;
+  
+  try {
+    report.push('🔌 Verbinde mit der Datenbank...');
+    connection = await mysql.createConnection(dbConfig);
+    
+    // 1. Status vor dem Cleanup
+    report.push('');
+    report.push('📊 STATUS VOR DEM CLEANUP:');
+    const [tablesBefore] = await connection.execute(`
+      SELECT 
+        TABLE_NAME,
+        COUNT(*) as key_count
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ? 
+      GROUP BY TABLE_NAME
+      ORDER BY key_count DESC
+    `, [dbConfig.database]);
+    
+    tablesBefore.forEach(table => {
+      report.push(`  ${table.TABLE_NAME}: ${table.key_count} Keys`);
+    });
+    
+    // 2. Alle INDEX der Problem-Tabellen anzeigen
+    const problemTables = ['member', 'diary_tags', 'season'];
+    
+    for (const tableName of problemTables) {
+      report.push('');
+      report.push(`🔍 INDEX für Tabelle '${tableName}':`);
+      
+      try {
+        const [indexes] = await connection.execute(`SHOW INDEX FROM \`${tableName}\``);
+        
+        if (indexes.length === 0) {
+          report.push(`  Keine INDEX gefunden für Tabelle '${tableName}'`);
+          continue;
+        }
+        
+        indexes.forEach(index => {
+          report.push(`  - ${index.Key_name} (${index.Column_name}) - ${index.Non_unique === 0 ? 'UNIQUE' : 'NON-UNIQUE'}`);
+        });
+        
+        // 3. Überflüssige INDEX entfernen (alle außer PRIMARY und UNIQUE)
+        report.push('');
+        report.push(`🗑️  Entferne überflüssige INDEX aus '${tableName}':`);
+        
+        for (const index of indexes) {
+          // Behalte PRIMARY KEY und UNIQUE constraints
+          if (index.Key_name === 'PRIMARY' || index.Non_unique === 0) {
+            report.push(`  ✅ Behalte: ${index.Key_name} (${index.Column_name})`);
+            continue;
+          }
+          
+          // Entferne alle anderen INDEX
+          try {
+            await connection.execute(`DROP INDEX \`${index.Key_name}\` ON \`${tableName}\``);
+            report.push(`  ❌ Entfernt: ${index.Key_name} (${index.Column_name})`);
+          } catch (error) {
+            if (error.code === 'ER_CANT_DROP_FIELD_OR_KEY') {
+              report.push(`  ⚠️  Kann nicht entfernen: ${index.Key_name} (${index.Column_name}) - ${error.message}`);
+            } else {
+              report.push(`  ❌ Fehler beim Entfernen von ${index.Key_name}: ${error.message}`);
+            }
+          }
+        }
+        
+      } catch (error) {
+        report.push(`  ⚠️  Fehler beim Zugriff auf Tabelle '${tableName}': ${error.message}`);
+      }
+    }
+    
+    // 4. Status nach dem Cleanup
+    report.push('');
+    report.push('📊 STATUS NACH DEM CLEANUP:');
+    const [tablesAfter] = await connection.execute(`
+      SELECT 
+        TABLE_NAME,
+        COUNT(*) as key_count
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ? 
+      GROUP BY TABLE_NAME
+      ORDER BY key_count DESC
+    `, [dbConfig.database]);
+    
+    tablesAfter.forEach(table => {
+      const before = tablesBefore.find(t => t.TABLE_NAME === table.TABLE_NAME);
+      const beforeCount = before ? before.key_count : 0;
+      const diff = beforeCount - table.key_count;
+      const status = table.key_count <= 5 ? '✅' : table.key_count <= 10 ? '⚠️' : '❌';
+      
+      report.push(`  ${status} ${table.TABLE_NAME}: ${table.key_count} Keys (${diff > 0 ? `-${diff}` : `+${Math.abs(diff)}`})`);
+    });
+    
+    // 5. Gesamtanzahl der Keys
+    const [totalKeys] = await connection.execute(`
+      SELECT COUNT(*) as total_keys
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ?
+    `, [dbConfig.database]);
+    
+    report.push('');
+    report.push(`📈 GESAMTANZAHL KEYS: ${totalKeys[0].total_keys}`);
+
+    // 6. Zusammenfassung
+    report.push('');
+    report.push('🎯 ZUSAMMENFASSUNG:');
+    const problemTablesAfter = tablesAfter.filter(t => t.key_count > 10);
+    
+    if (problemTablesAfter.length === 0) {
+      report.push('  ✅ Alle Tabellen haben jetzt weniger als 10 Keys!');
+    } else {
+      report.push('  ⚠️  Folgende Tabellen haben immer noch zu viele Keys:');
+      problemTablesAfter.forEach(table => {
+        report.push(`    - ${table.TABLE_NAME}: ${table.key_count} Keys`);
+      });
+    }
+    
+  } catch (error) {
+    console.error('❌ Fehler beim Cleanup:', error);
+  } finally {
+    if (connection) {
+      await connection.end();
+      report.push('');
+      report.push('🔌 Datenbankverbindung geschlossen.');
+    }
+  }
+}
+
+// Script ausführen
+report.push('🚀 Starte intelligentes INDEX-Cleanup...');
+cleanupKeys().then(() => {
+  report.push('');
+  report.push('✨ Cleanup abgeschlossen!');
+  process.stdout.write(`${report.join('\n')}\n`);
+  process.exit(0);
+}).catch(error => {
+  console.error('\n💥 Fehler beim Cleanup:', error);
+  process.exit(1);
+});
+

backend/cleanupKeysNode.js

@@ -0,0 +1,156 @@
+import mysql from 'mysql2/promise';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// __dirname für ES-Module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const report = [];
+
+// Umgebungsvariablen aus dem Root-Verzeichnis laden
+const envPath = path.join(__dirname, '..', '.env');
+dotenv.config();
+report.push('Environment variables loaded');
+
+async function cleanupKeys() {
+  let connection;
+  
+  try {
+    report.push('🔌 Verbinde mit der Datenbank...');
+    connection = await mysql.createConnection(dbConfig);
+    
+    // 1. Status vor dem Cleanup
+    report.push('');
+    report.push('📊 STATUS VOR DEM CLEANUP:');
+    const [tablesBefore] = await connection.execute(`
+      SELECT 
+        TABLE_NAME,
+        COUNT(*) as key_count
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ? 
+      GROUP BY TABLE_NAME
+      ORDER BY key_count DESC
+    `, [dbConfig.database]);
+    
+    tablesBefore.forEach(table => {
+      report.push(`  ${table.TABLE_NAME}: ${table.key_count} Keys`);
+    });
+    
+    // 2. Alle INDEX der Problem-Tabellen anzeigen
+    const problemTables = ['member', 'diary_tags', 'season'];
+    
+    for (const tableName of problemTables) {
+      report.push('');
+      report.push(`🔍 INDEX für Tabelle '${tableName}':`);
+      
+      try {
+        const [indexes] = await connection.execute(`SHOW INDEX FROM \`${tableName}\``);
+        
+        if (indexes.length === 0) {
+          report.push(`  Keine INDEX gefunden für Tabelle '${tableName}'`);
+          continue;
+        }
+        
+        indexes.forEach(index => {
+          report.push(`  - ${index.Key_name} (${index.Column_name}) - ${index.Non_unique === 0 ? 'UNIQUE' : 'NON-UNIQUE'}`);
+        });
+        
+        // 3. Überflüssige INDEX entfernen (alle außer PRIMARY und UNIQUE)
+        report.push('');
+        report.push(`🗑️  Entferne überflüssige INDEX aus '${tableName}':`);
+        
+        for (const index of indexes) {
+          // Behalte PRIMARY KEY und UNIQUE constraints
+          if (index.Key_name === 'PRIMARY' || index.Non_unique === 0) {
+            report.push(`  ✅ Behalte: ${index.Key_name} (${index.Column_name})`);
+            continue;
+          }
+          
+          // Entferne alle anderen INDEX
+          try {
+            await connection.execute(`DROP INDEX \`${index.Key_name}\` ON \`${tableName}\``);
+            report.push(`  ❌ Entfernt: ${index.Key_name} (${index.Column_name})`);
+          } catch (error) {
+            if (error.code === 'ER_CANT_DROP_FIELD_OR_KEY') {
+              report.push(`  ⚠️  Kann nicht entfernen: ${index.Key_name} (${index.Column_name}) - ${error.message}`);
+            } else {
+              report.push(`  ❌ Fehler beim Entfernen von ${index.Key_name}: ${error.message}`);
+            }
+          }
+        }
+        
+      } catch (error) {
+        report.push(`  ⚠️  Fehler beim Zugriff auf Tabelle '${tableName}': ${error.message}`);
+      }
+    }
+    
+    // 4. Status nach dem Cleanup
+    report.push('');
+    report.push('📊 STATUS NACH DEM CLEANUP:');
+    const [tablesAfter] = await connection.execute(`
+      SELECT 
+        TABLE_NAME,
+        COUNT(*) as key_count
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ? 
+      GROUP BY TABLE_NAME
+      ORDER BY key_count DESC
+    `, [dbConfig.database]);
+    
+    tablesAfter.forEach(table => {
+      const before = tablesBefore.find(t => t.TABLE_NAME === table.TABLE_NAME);
+      const beforeCount = before ? before.key_count : 0;
+      const diff = beforeCount - table.key_count;
+      const status = table.key_count <= 5 ? '✅' : table.key_count <= 10 ? '⚠️' : '❌';
+      
+      report.push(`  ${status} ${table.TABLE_NAME}: ${table.key_count} Keys (${diff > 0 ? `-${diff}` : `+${Math.abs(diff)}`})`);
+    });
+    
+    // 5. Gesamtanzahl der Keys
+    const [totalKeys] = await connection.execute(`
+      SELECT COUNT(*) as total_keys
+      FROM INFORMATION_SCHEMA.STATISTICS 
+      WHERE TABLE_SCHEMA = ?
+    `, [dbConfig.database]);
+    
+    report.push('');
+    report.push(`📈 GESAMTANZAHL KEYS: ${totalKeys[0].total_keys}`);
+    
+    // 6. Zusammenfassung
+    report.push('');
+    report.push('🎯 ZUSAMMENFASSUNG:');
+    const problemTablesAfter = tablesAfter.filter(t => t.key_count > 10);
+    
+    if (problemTablesAfter.length === 0) {
+      report.push('  ✅ Alle Tabellen haben jetzt weniger als 10 Keys!');
+    } else {
+      report.push('  ⚠️  Folgende Tabellen haben immer noch zu viele Keys:');
+      problemTablesAfter.forEach(table => {
+        report.push(`    - ${table.TABLE_NAME}: ${table.key_count} Keys`);
+      });
+    }
+    
+  } catch (error) {
+    console.error('❌ Fehler beim Cleanup:', error);
+  } finally {
+    if (connection) {
+      await connection.end();
+      report.push('');
+      report.push('🔌 Datenbankverbindung geschlossen.');
+    }
+  }
+}
+
+// Script ausführen
+report.push('🚀 Starte intelligentes INDEX-Cleanup...');
+cleanupKeys().then(() => {
+  report.push('');
+  report.push('✨ Cleanup abgeschlossen!');
+  process.stdout.write(`${report.join('\n')}\n`);
+  process.exit(0);
+}).catch(error => {
+  console.error('\n💥 Fehler beim Cleanup:', error);
+  process.exit(1);
+});

backend/cleanupKeysReal.sql

@@ -0,0 +1,149 @@
+-- Cleanup-Script mit echten INDEX-Namen
+-- Zeigt zuerst alle vorhandenen INDEX an und entfernt dann nur die überflüssigen
+
+USE trainingsdiary;
+
+-- 1. Alle vorhandenen INDEX anzeigen
+SELECT '=== VORHANDENE INDEX VOR CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    INDEX_NAME,
+    COLUMN_NAME,
+    NON_UNIQUE,
+    SEQ_IN_INDEX
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;
+
+-- 2. Anzahl der Keys pro Tabelle vor Cleanup
+SELECT '=== KEYS PRO TABELLE VOR CLEANUP ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 3. Gesamtanzahl der Keys vor Cleanup
+SELECT '=== GESAMTANZAHL KEYS VOR CLEANUP ===' as info;
+SELECT 
+    COUNT(*) as total_keys_before
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 4. Cleanup: Nur INDEX entfernen, die tatsächlich existieren
+-- Verwende DROP INDEX IF EXISTS für alle möglichen INDEX
+
+-- Member-Tabelle
+SELECT '=== ENTFERNE MEMBER INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- User-Tabelle
+SELECT '=== ENTFERNE USER INDEX ===' as info;
+DROP INDEX IF EXISTS idx_user_email ON user;
+DROP INDEX IF EXISTS idx_user_created_at ON user;
+DROP INDEX IF EXISTS idx_user_updated_at ON user;
+
+-- Clubs-Tabelle
+SELECT '=== ENTFERNE CLUBS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_clubs_name ON clubs;
+DROP INDEX IF EXISTS idx_clubs_created_at ON clubs;
+DROP INDEX IF EXISTS idx_clubs_updated_at ON clubs;
+
+-- User_Club-Tabelle
+SELECT '=== ENTFERNE USER_CLUB INDEX ===' as info;
+DROP INDEX IF EXISTS idx_user_club_approved ON user_club;
+DROP INDEX IF EXISTS idx_user_club_created_at ON user_club;
+DROP INDEX IF EXISTS idx_user_club_updated_at ON user_club;
+
+-- Log-Tabelle
+SELECT '=== ENTFERNE LOG INDEX ===' as info;
+DROP INDEX IF EXISTS idx_log_activity ON log;
+DROP INDEX IF EXISTS idx_log_created_at ON log;
+DROP INDEX IF EXISTS idx_log_updated_at ON log;
+
+-- Diary_Dates-Tabelle
+SELECT '=== ENTFERNE DIARY_DATES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_dates_date ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_created_at ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_updated_at ON diary_dates;
+
+-- Participants-Tabelle
+SELECT '=== ENTFERNE PARTICIPANTS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_participant_created_at ON participants;
+DROP INDEX IF EXISTS idx_participant_updated_at ON participants;
+
+-- Activities-Tabelle
+SELECT '=== ENTFERNE ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_activity_created_at ON activities;
+DROP INDEX IF EXISTS idx_activity_updated_at ON activities;
+
+-- Member_Notes-Tabelle
+SELECT '=== ENTFERNE MEMBER_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_note_created_at ON member_notes;
+DROP INDEX IF EXISTS idx_member_note_updated_at ON member_notes;
+
+-- Diary_Notes-Tabelle
+SELECT '=== ENTFERNE DIARY_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_note_created_at ON diary_notes;
+DROP INDEX IF EXISTS idx_diary_note_updated_at ON diary_notes;
+
+-- Diary_Tags-Tabelle
+SELECT '=== ENTFERNE DIARY_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_tag_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tag_updated_at ON diary_tags;
+
+-- Member_Diary_Tags-Tabelle
+SELECT '=== ENTFERNE MEMBER_DIARY_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_diary_tag_created_at ON member_diary_tags;
+DROP INDEX IF EXISTS idx_member_diary_tag_updated_at ON member_diary_tags;
+
+-- Diary_Date_Tags-Tabelle
+SELECT '=== ENTFERNE DIARY_DATE_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_date_tag_created_at ON diary_date_tags;
+DROP INDEX IF EXISTS idx_diary_date_tag_updated_at ON diary_date_tags;
+
+-- Diary_Member_Notes-Tabelle
+SELECT '=== ENTFERNE DIARY_MEMBER_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_member_note_created_at ON diary_member_notes;
+DROP INDEX IF EXISTS idx_diary_member_note_updated_at ON diary_member_notes;
+
+-- Predefined_Activities-Tabelle
+SELECT '=== ENTFERNE PREDEFINED_ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_predefined_activity_created_at ON predefined_activities;
+DROP INDEX IF EXISTS idx_predefined_activity_updated_at ON predefined_activities;
+
+-- Diary_Date_Activities-Tabelle
+SELECT '=== ENTFERNE DIARY_DATE_ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_date_activity_created_at ON diary_date_activities;
+DROP INDEX IF EXISTS idx_diary_date_activity_updated_at ON diary_date_activities;
+
+-- 5. Nach der Bereinigung: Status anzeigen
+SELECT '=== STATUS NACH BEREINIGUNG ===' as info;
+
+-- Anzahl der Keys pro Tabelle nach der Bereinigung
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- Gesamtanzahl der Keys nach der Bereinigung
+SELECT 
+    COUNT(*) as total_keys_after
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 6. Zusammenfassung der Änderungen
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Cleanup abgeschlossen. Überprüfen Sie die Anzahl der Keys oben.' as message;

backend/cleanupKeysSimple.sql

@@ -0,0 +1,41 @@
+-- Vereinfachtes Cleanup-Script für MySQL Keys
+-- Entfernt nur die problematischsten Keys
+
+USE trainingsdiary;
+
+-- 1. Alle überflüssigen INDEX entfernen (die meisten werden von Sequelize automatisch erstellt)
+-- Diese entfernen die meisten Keys, die das Limit überschreiten
+
+-- Member-Tabelle (Hauptproblem)
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- User-Tabelle
+DROP INDEX IF EXISTS idx_user_email ON user;
+DROP INDEX IF EXISTS idx_user_created_at ON user;
+DROP INDEX IF EXISTS idx_user_updated_at ON user;
+
+-- Clubs-Tabelle
+DROP INDEX IF EXISTS idx_clubs_name ON clubs;
+DROP INDEX IF EXISTS idx_clubs_created_at ON clubs;
+DROP INDEX IF EXISTS idx_clubs_updated_at ON clubs;
+
+-- 2. Status anzeigen
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 3. Gesamtanzahl der Keys anzeigen
+SELECT 
+    COUNT(*) as total_keys
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';

backend/cleanupKeysSmart.sql

@@ -0,0 +1,153 @@
+-- Intelligentes Cleanup-Script für MySQL Keys
+-- Überprüft zuerst die echten Tabellennamen und entfernt nur vorhandene INDEX
+
+USE trainingsdiary;
+
+-- 1. Alle vorhandenen Tabellen anzeigen
+SELECT '=== VORHANDENE TABELLEN ===' as info;
+SHOW TABLES;
+
+-- 2. Alle vorhandenen INDEX anzeigen
+SELECT '=== VORHANDENE INDEX ===' as info;
+SELECT 
+    TABLE_NAME,
+    INDEX_NAME,
+    COLUMN_NAME,
+    NON_UNIQUE,
+    SEQ_IN_INDEX
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;
+
+-- 3. Anzahl der Keys pro Tabelle anzeigen
+SELECT '=== KEYS PRO TABELLE ===' as info;
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- 4. Gesamtanzahl der Keys anzeigen
+SELECT '=== GESAMTANZAHL KEYS ===' as info;
+SELECT 
+    COUNT(*) as total_keys
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 5. Intelligente INDEX-Entfernung basierend auf vorhandenen Tabellen
+-- Nur INDEX entfernen, die tatsächlich existieren
+
+-- Member-Tabelle (Hauptproblem)
+SELECT '=== ENTFERNE MEMBER INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_hashed_id ON member;
+DROP INDEX IF EXISTS idx_member_first_name ON member;
+DROP INDEX IF EXISTS idx_member_last_name ON member;
+DROP INDEX IF EXISTS idx_member_birth_date ON member;
+DROP INDEX IF EXISTS idx_member_active ON member;
+DROP INDEX IF EXISTS idx_member_created_at ON member;
+DROP INDEX IF EXISTS idx_member_updated_at ON member;
+
+-- User-Tabelle
+SELECT '=== ENTFERNE USER INDEX ===' as info;
+DROP INDEX IF EXISTS idx_user_email ON user;
+DROP INDEX IF EXISTS idx_user_created_at ON user;
+DROP INDEX IF EXISTS idx_user_updated_at ON user;
+
+-- Clubs-Tabelle
+SELECT '=== ENTFERNE CLUBS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_clubs_name ON clubs;
+DROP INDEX IF EXISTS idx_clubs_created_at ON clubs;
+DROP INDEX IF EXISTS idx_clubs_updated_at ON clubs;
+
+-- User_Club-Tabelle
+SELECT '=== ENTFERNE USER_CLUB INDEX ===' as info;
+DROP INDEX IF EXISTS idx_user_club_approved ON user_club;
+DROP INDEX IF EXISTS idx_user_club_created_at ON user_club;
+DROP INDEX IF EXISTS idx_user_club_updated_at ON user_club;
+
+-- Log-Tabelle
+SELECT '=== ENTFERNE LOG INDEX ===' as info;
+DROP INDEX IF EXISTS idx_log_activity ON log;
+DROP INDEX IF EXISTS idx_log_created_at ON log;
+DROP INDEX IF EXISTS idx_log_updated_at ON log;
+
+-- Diary_Dates-Tabelle
+SELECT '=== ENTFERNE DIARY_DATES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_dates_date ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_created_at ON diary_dates;
+DROP INDEX IF EXISTS idx_diary_dates_updated_at ON diary_dates;
+
+-- Participants-Tabelle
+SELECT '=== ENTFERNE PARTICIPANTS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_participant_created_at ON participants;
+DROP INDEX IF EXISTS idx_participant_updated_at ON participants;
+
+-- Activities-Tabelle
+SELECT '=== ENTFERNE ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_activity_created_at ON activities;
+DROP INDEX IF EXISTS idx_activity_updated_at ON activities;
+
+-- Member_Notes-Tabelle
+SELECT '=== ENTFERNE MEMBER_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_note_created_at ON member_notes;
+DROP INDEX IF EXISTS idx_member_note_updated_at ON member_notes;
+
+-- Diary_Notes-Tabelle
+SELECT '=== ENTFERNE DIARY_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_note_created_at ON diary_notes;
+DROP INDEX IF EXISTS idx_diary_note_updated_at ON diary_notes;
+
+-- Diary_Tags-Tabelle
+SELECT '=== ENTFERNE DIARY_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_tag_created_at ON diary_tags;
+DROP INDEX IF EXISTS idx_diary_tag_updated_at ON diary_tags;
+
+-- Member_Diary_Tags-Tabelle
+SELECT '=== ENTFERNE MEMBER_DIARY_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_member_diary_tag_created_at ON member_diary_tags;
+DROP INDEX IF EXISTS idx_member_diary_tag_updated_at ON member_diary_tags;
+
+-- Diary_Date_Tags-Tabelle
+SELECT '=== ENTFERNE DIARY_DATE_TAGS INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_date_tag_created_at ON diary_date_tags;
+DROP INDEX IF EXISTS idx_diary_date_tag_updated_at ON diary_date_tags;
+
+-- Diary_Member_Notes-Tabelle
+SELECT '=== ENTFERNE DIARY_MEMBER_NOTES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_member_note_created_at ON diary_member_notes;
+DROP INDEX IF EXISTS idx_diary_member_note_updated_at ON diary_member_notes;
+
+-- Predefined_Activities-Tabelle
+SELECT '=== ENTFERNE PREDEFINED_ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_predefined_activity_created_at ON predefined_activities;
+DROP INDEX IF EXISTS idx_predefined_activity_updated_at ON predefined_activities;
+
+-- Diary_Date_Activities-Tabelle
+SELECT '=== ENTFERNE DIARY_DATE_ACTIVITIES INDEX ===' as info;
+DROP INDEX IF EXISTS idx_diary_date_activity_created_at ON diary_date_activities;
+DROP INDEX IF EXISTS idx_diary_date_activity_updated_at ON diary_date_activities;
+
+-- 6. Nach der Bereinigung: Status anzeigen
+SELECT '=== STATUS NACH BEREINIGUNG ===' as info;
+
+-- Anzahl der Keys pro Tabelle nach der Bereinigung
+SELECT 
+    TABLE_NAME,
+    COUNT(*) as key_count
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary' 
+GROUP BY TABLE_NAME
+ORDER BY key_count DESC;
+
+-- Gesamtanzahl der Keys nach der Bereinigung
+SELECT 
+    COUNT(*) as total_keys_after_cleanup
+FROM INFORMATION_SCHEMA.STATISTICS 
+WHERE TABLE_SCHEMA = 'trainingsdiary';
+
+-- 7. Zusammenfassung
+SELECT '=== ZUSAMMENFASSUNG ===' as info;
+SELECT 
+    'Cleanup abgeschlossen. Überprüfen Sie die Anzahl der Keys oben.' as message;

backend/clients/myTischtennisClient.js

@@ -0,0 +1,262 @@
+import axios from 'axios';
+
+const BASE_URL = 'https://www.mytischtennis.de';
+
+class MyTischtennisClient {
+  constructor() {
+    this.baseURL = BASE_URL;
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': '*/*'
+      },
+      maxRedirects: 0, // Don't follow redirects automatically
+      validateStatus: (status) => status >= 200 && status < 400 // Accept 3xx as success
+    });
+  }
+
+  /**
+   * Login to myTischtennis API
+   * @param {string} email - myTischtennis email (not username!)
+   * @param {string} password - myTischtennis password
+   * @returns {Promise<Object>} Login response with token and session data
+   */
+  async login(email, password) {
+    try {
+      // Create form data
+      const formData = new URLSearchParams();
+      formData.append('email', email);
+      formData.append('password', password);
+      formData.append('intent', 'login');
+
+      const response = await this.client.post(
+        '/login?next=%2F&_data=routes%2F_auth%2B%2Flogin',
+        formData.toString()
+      );
+
+      // Extract the cookie from response headers
+      const setCookie = response.headers['set-cookie'];
+      if (!setCookie || !Array.isArray(setCookie)) {
+        return {
+          success: false,
+          error: 'Keine Session-Cookie erhalten'
+        };
+      }
+
+      // Find the sb-10-auth-token cookie
+      const authCookie = setCookie.find(cookie => cookie.startsWith('sb-10-auth-token='));
+      if (!authCookie) {
+        return {
+          success: false,
+          error: 'Kein Auth-Token in Response gefunden'
+        };
+      }
+
+      // Extract and decode the token
+      const tokenMatch = authCookie.match(/sb-10-auth-token=base64-([^;]+)/);
+      if (!tokenMatch) {
+        return {
+          success: false,
+          error: 'Token-Format ungültig'
+        };
+      }
+
+      const base64Token = tokenMatch[1];
+      let tokenData;
+      try {
+        const decodedToken = Buffer.from(base64Token, 'base64').toString('utf-8');
+        tokenData = JSON.parse(decodedToken);
+      } catch (decodeError) {
+        console.error('Error decoding token:', decodeError);
+        return {
+          success: false,
+          error: 'Token konnte nicht dekodiert werden'
+        };
+      }
+
+      return {
+        success: true,
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+        expiresAt: tokenData.expires_at,
+        expiresIn: tokenData.expires_in,
+        user: tokenData.user,
+        cookie: authCookie.split(';')[0] // Just the cookie value without attributes
+      };
+    } catch (error) {
+      console.error('MyTischtennis login error:', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'Login fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Verify login credentials
+   * @param {string} email - myTischtennis email
+   * @param {string} password - myTischtennis password
+   * @returns {Promise<boolean>} True if credentials are valid
+   */
+  async verifyCredentials(email, password) {
+    const result = await this.login(email, password);
+    return result.success;
+  }
+
+  /**
+   * Make an authenticated request
+   * @param {string} endpoint - API endpoint
+   * @param {string} cookie - Authentication cookie (sb-10-auth-token)
+   * @param {Object} options - Additional axios options
+   * @returns {Promise<Object>} API response
+   */
+  async authenticatedRequest(endpoint, cookie, options = {}) {
+    try {
+      const response = await this.client.request({
+        url: endpoint,
+        ...options,
+        headers: {
+          ...options.headers,
+          'Cookie': cookie,
+          'Accept': '*/*',
+          'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
+          'Referer': 'https://www.mytischtennis.de/',
+          'sec-fetch-dest': 'empty',
+          'sec-fetch-mode': 'cors',
+          'sec-fetch-site': 'same-origin'
+        }
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      console.error('MyTischtennis API error:', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'API-Anfrage fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Get user profile and club information
+   * @param {string} cookie - Authentication cookie (sb-10-auth-token)
+   * @returns {Promise<Object>} User profile with club info
+   */
+  async getUserProfile(cookie) {
+    
+    const result = await this.authenticatedRequest('/?_data=root', cookie, {
+      method: 'GET'
+    });
+    
+    
+    if (result.success) {
+      
+      return {
+        success: true,
+        clubId: result.data?.userProfile?.club?.clubnr || null,
+        clubName: result.data?.userProfile?.club?.name || null,
+        fedNickname: result.data?.userProfile?.organization?.short || null,
+        ttr: result.data?.userProfile?.ttr || null,
+        qttr: result.data?.userProfile?.qttr || null,
+        userProfile: result.data?.userProfile || null
+      };
+    }
+    
+    console.error('[getUserProfile] - Failed:', result.error);
+    return result;
+  }
+
+  /**
+   * Get club rankings (andro-Rangliste)
+   * @param {string} cookie - Authentication cookie
+   * @param {string} clubId - Club number (e.g., "43030")
+   * @param {string} fedNickname - Federation nickname (e.g., "HeTTV")
+   * @returns {Promise<Object>} Rankings with player entries (all pages)
+   */
+  async getClubRankings(cookie, clubId, fedNickname, currentRanking = 'yes') {
+    const allEntries = [];
+    let currentPage = 0;
+    let hasMorePages = true;
+    
+    
+    while (hasMorePages) {
+      const endpoint = `/rankings/andro-rangliste?all-players=on&clubnr=${clubId}&fednickname=${fedNickname}&current-ranking=${currentRanking}&results-per-page=100&page=${currentPage}&_data=routes%2F%24`;
+      
+      
+      const result = await this.authenticatedRequest(endpoint, cookie, {
+        method: 'GET'
+      });
+      
+      if (!result.success) {
+        console.error(`[getClubRankings] - Failed to fetch page ${currentPage}:`, result.error);
+        return result;
+      }
+      
+      // Find the dynamic key that contains entries
+      const blockLoaderData = result.data?.pageContent?.blockLoaderData;
+      if (!blockLoaderData) {
+        console.error('[getClubRankings] - No blockLoaderData found');
+        return {
+          success: false,
+          error: 'Keine blockLoaderData gefunden'
+        };
+      }
+      
+      // Finde den Schlüssel, der entries enthält
+      let entries = null;
+      let rankingData = null;
+      
+      for (const key in blockLoaderData) {
+        if (blockLoaderData[key]?.entries) {
+          entries = blockLoaderData[key].entries;
+          rankingData = blockLoaderData[key];
+          break;
+        }
+      }
+      
+      if (!entries) {
+        console.error('[getClubRankings] - No entries found in blockLoaderData');
+        return {
+          success: false,
+          error: 'Keine entries in blockLoaderData gefunden'
+        };
+      }
+      
+      
+      // Füge Entries hinzu
+      allEntries.push(...entries);
+      
+      // Prüfe ob es weitere Seiten gibt
+      // Wenn die aktuelle Seite weniger Einträge hat als das Limit, sind wir am Ende
+      // Oder wenn wir alle erwarteten Einträge haben
+      if (entries.length === 0) {
+        hasMorePages = false;
+      } else if (rankingData.numberOfPages && currentPage >= rankingData.numberOfPages - 1) {
+        hasMorePages = false;
+      } else if (allEntries.length >= rankingData.resultLength) {
+        hasMorePages = false;
+      } else {
+        currentPage++;
+      }
+    }
+    
+    
+    return {
+      success: true,
+      entries: allEntries,
+      metadata: {
+        totalEntries: allEntries.length,
+        pagesFetched: currentPage + 1
+      }
+    };
+  }
+}
+
+export default new MyTischtennisClient();
+

backend/config.js

@@ -1,17 +1,41 @@
 import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
-dotenv.config();
+// Ensure .env is loaded from the backend folder (not dependent on process.cwd())
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+dotenv.config({ path: path.resolve(__dirname, '.env') });
 
-export const development = {
+const isTestEnv = process.env.NODE_ENV === 'test';
+
+const baseConfig = {
   username: process.env.DB_USER || 'root',
   password: process.env.DB_PASSWORD || 'hitomisan',
   database: process.env.DB_NAME || 'trainingdiary',
-  host: process.env.DB_HOST,
-  dialect: process.env.DB_DIALECT,
+  host: process.env.DB_HOST || 'localhost',
+  dialect: process.env.DB_DIALECT || 'mysql',
   define: {
     freezeTableName: true,
     underscored: true,
     underscoredAll: true,
   },
+  logging: false,
+  storage: process.env.DB_STORAGE,
 };
+
+if (isTestEnv) {
+  baseConfig.username = 'sqlite';
+  baseConfig.password = '';
+  baseConfig.database = 'sqlite';
+  baseConfig.host = 'localhost';
+  baseConfig.dialect = 'sqlite';
+  baseConfig.storage = process.env.DB_STORAGE || ':memory:';
+}
+
+if (baseConfig.dialect === 'sqlite' && !baseConfig.storage) {
+  baseConfig.storage = ':memory:';
+}
+
+export const development = baseConfig;
  

backend/controllers/apiLogController.js

@@ -0,0 +1,85 @@
+import apiLogService from '../services/apiLogService.js';
+import HttpError from '../exceptions/HttpError.js';
+
+class ApiLogController {
+  /**
+   * GET /api/logs
+   * Get API logs with optional filters
+   */
+  async getLogs(req, res, next) {
+    try {
+      const {
+        userId,
+        logType,
+        method,
+        path,
+        statusCode,
+        startDate,
+        endDate,
+        limit = 100,
+        offset = 0
+      } = req.query;
+
+      const result = await apiLogService.getLogs({
+        userId: userId ? parseInt(userId) : null,
+        logType,
+        method,
+        path,
+        statusCode: statusCode ? parseInt(statusCode) : null,
+        startDate,
+        endDate,
+        limit: parseInt(limit),
+        offset: parseInt(offset)
+      });
+
+      res.json({
+        success: true,
+        data: result
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/logs/:id
+   * Get a single log entry by ID
+   */
+  async getLogById(req, res, next) {
+    try {
+      const { id } = req.params;
+      const log = await apiLogService.getLogById(parseInt(id));
+
+      if (!log) {
+        throw new HttpError('Log entry not found', 404);
+      }
+
+      res.json({
+        success: true,
+        data: log
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/logs/scheduler/last-executions
+   * Get last execution info for scheduler jobs
+   */
+  async getLastSchedulerExecutions(req, res, next) {
+    try {
+      const { clubId } = req.query;
+      const results = await apiLogService.getLastSchedulerExecutions(clubId ? parseInt(clubId) : null);
+      res.json({
+        success: true,
+        data: results
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+export default new ApiLogController();
+

backend/controllers/authController.js

@@ -1,4 +1,7 @@
 import { register, activateUser, login, logout } from '../services/authService.js';
+import jwt from 'jsonwebtoken';
+import UserToken from '../models/UserToken.js';
+import User from '../models/User.js'; // ggf. Pfad anpassen
 
 const registerUser = async (req, res, next) => {
   try {
@@ -30,14 +33,14 @@ const loginUser = async (req, res, next) => {
   }
 };
 
-const logoutUser = async(req, res) => {
-  const { userid: userId, authtoken: authToken } = req.headers;
+const logoutUser = async (req, res, next) => {
   try {
-    logout(userId, authToken);
+    const token = req.headers['authorization']?.split(' ')[1];
+    const result = await logout(token);
+    res.status(200).json(result);
   } catch (error) {
-    res.status(401).json({ msg: 'not found' });
+    next(error);
   }
-  res.status(200).json({ msg: 'loggedout' });
-}
+};
 
 export { registerUser, activate, loginUser, logoutUser };

backend/controllers/clubTeamController.js

@@ -0,0 +1,128 @@
+import ClubTeamService from '../services/clubTeamService.js';
+import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
+
+export const getClubTeams = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubid: clubId } = req.params;
+        const { seasonid: seasonId } = req.query;
+        
+        const user = await getUserByToken(token);
+        
+        // Check if user has access to this club
+        const clubTeams = await ClubTeamService.getAllClubTeamsByClub(clubId, seasonId);
+        
+        res.status(200).json(clubTeams);
+    } catch (error) {
+        console.error('[getClubTeams] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const getClubTeam = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubteamid: clubTeamId } = req.params;
+        const user = await getUserByToken(token);
+        
+        const clubTeam = await ClubTeamService.getClubTeamById(clubTeamId);
+        if (!clubTeam) {
+            return res.status(404).json({ error: "notfound" });
+        }
+        
+        res.status(200).json(clubTeam);
+    } catch (error) {
+        console.error('[getClubTeam] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const createClubTeam = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubid: clubId } = req.params;
+        const { name, leagueId, seasonId } = req.body;
+        
+        const user = await getUserByToken(token);
+        
+        if (!name) {
+            return res.status(400).json({ error: "missingname" });
+        }
+        
+        const clubTeamData = {
+            name,
+            clubId: parseInt(clubId),
+            leagueId: leagueId ? parseInt(leagueId) : null,
+            seasonId: seasonId ? parseInt(seasonId) : null
+        };
+        
+        const newClubTeam = await ClubTeamService.createClubTeam(clubTeamData);
+        
+        res.status(201).json(newClubTeam);
+    } catch (error) {
+        console.error('[createClubTeam] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const updateClubTeam = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubteamid: clubTeamId } = req.params;
+        const { name, leagueId, seasonId } = req.body;
+        
+        const user = await getUserByToken(token);
+        
+        const updateData = {};
+        if (name !== undefined) updateData.name = name;
+        if (leagueId !== undefined) updateData.leagueId = leagueId ? parseInt(leagueId) : null;
+        if (seasonId !== undefined) updateData.seasonId = seasonId ? parseInt(seasonId) : null;
+        
+        const success = await ClubTeamService.updateClubTeam(clubTeamId, updateData);
+        if (!success) {
+            return res.status(404).json({ error: "notfound" });
+        }
+        
+        const updatedClubTeam = await ClubTeamService.getClubTeamById(clubTeamId);
+        res.status(200).json(updatedClubTeam);
+    } catch (error) {
+        console.error('[updateClubTeam] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const deleteClubTeam = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubteamid: clubTeamId } = req.params;
+        const user = await getUserByToken(token);
+        
+        const success = await ClubTeamService.deleteClubTeam(clubTeamId);
+        if (!success) {
+            return res.status(404).json({ error: "notfound" });
+        }
+        
+        res.status(200).json({ message: "Club team deleted successfully" });
+    } catch (error) {
+        console.error('[deleteClubTeam] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const getLeagues = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubid: clubId } = req.params;
+        const { seasonid: seasonId } = req.query;
+        
+        const user = await getUserByToken(token);
+        
+        const leagues = await ClubTeamService.getLeaguesByClub(clubId, seasonId);
+        
+        res.status(200).json(leagues);
+    } catch (error) {
+        console.error('[getLeagues] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};

backend/controllers/clubsController.js

@@ -1,88 +1,86 @@
 import ClubService from '../services/clubService.js';
 import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
 
 export const getClubs = async (req, res) => {
   try {
-    console.log('[getClubs] - get clubs');
     const clubs = await ClubService.getAllClubs();
-    console.log('[getClubs] - prepare response');
     res.status(200).json(clubs);
-    console.log('[getClubs] - done');
   } catch (error) {
-    console.log('[getClubs] - error');
-    console.log(error);
+    console.error('[getClubs] - error:', error);
     res.status(500).json({ error: "internalerror" });
   }
 };
 
 export const addClub = async (req, res) => {
-  console.log('[addClub] - Read out parameters');
   const { authcode: token } = req.headers;
   const { name: clubName } = req.body;
 
   try {
-    console.log('[addClub] - find club by name');
     const club = await ClubService.findClubByName(clubName);
-    console.log('[addClub] - get user');
     const user = await getUserByToken(token);
-    console.log('[addClub] - check if club already exists');
     if (club) {
       res.status(409).json({ error: "alreadyexists" });
       return;
     }
 
-    console.log('[addClub] - create club');
     const newClub = await ClubService.createClub(clubName);
-    console.log('[addClub] - add user to new club');
-    await ClubService.addUserToClub(user.id, newClub.id);
-    console.log('[addClub] - prepare response');
+    await ClubService.addUserToClub(user.id, newClub.id, true); // true = isOwner
     res.status(200).json(newClub);
-    console.log('[addClub] - done');
   } catch (error) {
-    console.log('[addClub] - error');
-    console.log(error);
+    console.error('[addClub] - error:', error);
     res.status(500).json({ error: "internalerror" });
   }
 };
 
 export const getClub = async (req, res) => {
-  console.log('[getClub] - start');
   try {
     const { authcode: token } = req.headers;
     const { clubid: clubId } = req.params;
-    console.log('[getClub] - get user');
     const user = await getUserByToken(token);
-    console.log('[getClub] - get users club');
     const access = await ClubService.getUserClubAccess(user.id, clubId);
-    console.log('[getClub] - check access');
     if (access.length === 0 || !access[0].approved) {
       res.status(403).json({ error: "noaccess", status: access.length === 0 ? "notrequested" : "requested" });
       return;
     }
 
-    console.log('[getClub] - get club');
     const club = await ClubService.findClubById(clubId);
-    console.log('[getClub] - check club exists');
     if (!club) {
       return res.status(404).json({ message: 'Club not found' });
     }
 
-    console.log('[getClub] - set response');
     res.status(200).json(club);
-    console.log('[getClub] - done');
   } catch (error) {
-    console.log(error);
+    console.error('[getClub] - error:', error);
     res.status(500).json({ message: 'Server error' });
   }
 };
 
+export const updateClubSettings = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { clubid } = req.params;
+    const { greetingText, associationMemberNumber } = req.body;
+    const updated = await ClubService.updateClubSettings(token, clubid, { greetingText, associationMemberNumber });
+    res.status(200).json(updated);
+  } catch (error) {
+    if (error.message === 'noaccess') {
+      res.status(403).json({ error: 'noaccess' });
+    } else if (error.message === 'clubnotfound') {
+      res.status(404).json({ error: 'clubnotfound' });
+    } else {
+      console.error('[updateClubSettings] - error:', error);
+      res.status(500).json({ error: 'internalerror' });
+    }
+  }
+};
+
 export const requestClubAccess = async (req, res) => {
   const { authcode: token } = req.headers;
   const { clubid: clubId } = req.params;
 
   try {
     const user = await getUserByToken(token);
-    console.log(user);
 
     await ClubService.requestAccessToClub(user.id, clubId);
     res.status(200).json({});
@@ -92,6 +90,7 @@ export const requestClubAccess = async (req, res) => {
     } else if (error.message === 'clubnotfound') {
       res.status(404).json({ err: "clubnotfound" });
     } else {
+      console.error('[requestClubAccess] - error:', error);
       res.status(500).json({ err: "internalerror" });
     }
   }

backend/controllers/diaryController.js

@@ -1,6 +1,7 @@
 import diaryService from '../services/diaryService.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 const getDatesForClub = async (req, res) => {
     try {
         const { clubId } = req.params; 
@@ -38,7 +39,7 @@ const updateTrainingTimes = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { dateId, trainingStart, trainingEnd } = req.body;
         if (!dateId || !trainingStart) {
-            console.log(dateId, trainingStart, trainingEnd);
+            devLog(dateId, trainingStart, trainingEnd);
             throw new HttpError('notallfieldsfilled', 400);
         }
         const updatedDate = await diaryService.updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd);
@@ -116,3 +117,15 @@ const deleteTagFromDiaryDate = async (req, res) => {
 
 export { getDatesForClub, createDateForClub, updateTrainingTimes, addDiaryNote, deleteDiaryNote, addDiaryTag,
     addTagToDiaryDate, deleteTagFromDiaryDate };
+
+export const deleteDateForClub = async (req, res) => {
+    try {
+        const { clubId, dateId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await diaryService.removeDateForClub(userToken, clubId, dateId);
+        res.status(200).json(result);
+    } catch (error) {
+        console.error('[deleteDateForClub] - Error:', error);
+        res.status(error.statusCode || 500).json({ error: error.message || 'systemerror' });
+    }
+};

backend/controllers/diaryDateActivityController.js

@@ -1,5 +1,6 @@
 import diaryDateActivityService from '../services/diaryDateActivityService.js';
 
+import { devLog } from '../utils/logger.js';
 export const createDiaryDateActivity = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -15,7 +16,7 @@ export const createDiaryDateActivity = async (req, res) => {
         });
         res.status(201).json(activityItem);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error creating activity' });
     }
 };
@@ -58,7 +59,7 @@ export const updateDiaryDateActivityOrder = async (req, res) => {
         const updatedActivity = await diaryDateActivityService.updateActivityOrder(userToken, clubId, id, orderId);
         res.status(200).json(updatedActivity);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error updating activity order' });
     }
 };
@@ -70,7 +71,7 @@ export const getDiaryDateActivities = async (req, res) => {
         const activities = await diaryDateActivityService.getActivities(userToken, clubId, diaryDateId);
         res.status(200).json(activities);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error getting activities' });
     }
 }
@@ -78,11 +79,23 @@ export const getDiaryDateActivities = async (req, res) => {
 export const addGroupActivity = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
-        const { clubId, diaryDateId, groupId, activity } = req.body;
-        const activityItem = await diaryDateActivityService.addGroupActivity(userToken, clubId, diaryDateId, groupId, activity);
+        const { clubId, diaryDateId, groupId, activity, timeblockId } = req.body;
+        const activityItem = await diaryDateActivityService.addGroupActivity(userToken, clubId, diaryDateId, groupId, activity, timeblockId);
         res.status(201).json(activityItem);        
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error adding group activity' });
     }
+}
+
+export const deleteGroupActivity = async(req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, groupActivityId } = req.params;
+        await diaryDateActivityService.deleteGroupActivity(userToken, clubId, groupActivityId);
+        res.status(200).json({ message: 'Group activity deleted' });
+    } catch (error) {
+        devLog(error);
+        res.status(500).json({ error: 'Error deleting group activity' });
+    }
 }

backend/controllers/diaryDateTagController.js

@@ -1,7 +1,8 @@
 import diaryDateTagService from "../services/diaryDateTagService.js"
 
+import { devLog } from '../utils/logger.js';
 export const getDiaryDateMemberTags = async (req, res) => {
-    console.log("getDiaryDateMemberTags");
+    devLog("getDiaryDateMemberTags");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId, memberId } = req.params;
@@ -14,7 +15,7 @@ export const getDiaryDateMemberTags = async (req, res) => {
 }
 
 export const addDiaryDateTag = async (req, res) => {
-    console.log("addDiaryDateTag");
+    devLog("addDiaryDateTag");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;

backend/controllers/diaryMemberActivityController.js

@@ -0,0 +1,64 @@
+import DiaryMemberActivity from '../models/DiaryMemberActivity.js';
+import Participant from '../models/Participant.js';
+import { checkAccess } from '../utils/userUtils.js';
+
+export const getMembersForActivity = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, diaryDateActivityId } = req.params;
+    await checkAccess(userToken, clubId);
+    const list = await DiaryMemberActivity.findAll({ where: { diaryDateActivityId } });
+    res.status(200).json(list);
+  } catch (e) {
+    res.status(500).json({ error: 'Error fetching members for activity' });
+  }
+};
+
+export const addMembersToActivity = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, diaryDateActivityId } = req.params;
+    const { participantIds } = req.body; // array of participant ids
+    
+    await checkAccess(userToken, clubId);
+    
+    if (!participantIds || !Array.isArray(participantIds)) {
+      console.error('[addMembersToActivity] Invalid participantIds:', participantIds);
+      return res.status(400).json({ error: 'participantIds must be an array' });
+    }
+    
+    const validParticipants = await Participant.findAll({ where: { id: participantIds } });
+    
+    const validIds = new Set(validParticipants.map(p => p.id));
+    const created = [];
+    for (const pid of participantIds) {
+      if (!validIds.has(pid)) {
+        continue;
+      }
+      const existing = await DiaryMemberActivity.findOne({ where: { diaryDateActivityId, participantId: pid } });
+      if (!existing) {
+        const rec = await DiaryMemberActivity.create({ diaryDateActivityId, participantId: pid });
+        created.push(rec);
+      } else {
+      }
+    }
+    res.status(201).json(created);
+  } catch (e) {
+    console.error('[addMembersToActivity] Error:', e);
+    res.status(500).json({ error: 'Error adding members to activity' });
+  }
+};
+
+export const removeMemberFromActivity = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, diaryDateActivityId, participantId } = req.params;
+    await checkAccess(userToken, clubId);
+    await DiaryMemberActivity.destroy({ where: { diaryDateActivityId, participantId } });
+    res.status(200).json({ ok: true });
+  } catch (e) {
+    res.status(500).json({ error: 'Error removing member from activity' });
+  }
+};
+
+

backend/controllers/diaryMemberController.js

@@ -1,11 +1,12 @@
 import DiaryMemberService from '../services/diaryMemberService.js';
 
+import { devLog } from '../utils/logger.js';
 const getMemberTags = async (req, res) => {
     try {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log(diaryDateId, memberId, clubId);
+        devLog(diaryDateId, memberId, clubId);
         const tags = await DiaryMemberService.getTagsForMemberAndDate(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(tags);
     } catch (error) {
@@ -19,7 +20,7 @@ const getMemberNotes = async (req, res) => {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log('---------->', userToken, clubId);
+        devLog('---------->', userToken, clubId);
         const notes = await DiaryMemberService.getNotesForMember(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(notes);
     } catch (error) {

backend/controllers/diaryNoteController.js

@@ -18,17 +18,28 @@ export const getNotes = async (req, res) => {
 
 export const createNote = async (req, res) => {
     try {
-        const { memberId, content, tags } = req.body;
-        const newNote = await DiaryNote.create({ memberId, content });
-        if (tags && tags.length > 0) {
+        const { memberId, diaryDateId, content, tags } = req.body;
+
+        if (!memberId || !diaryDateId || !content) {
+            return res.status(400).json({ error: 'memberId, diaryDateId und content sind erforderlich.' });
+        }
+
+        const newNote = await DiaryNote.create({ memberId, diaryDateId, content });
+
+        if (Array.isArray(tags) && tags.length > 0 && typeof newNote.addTags === 'function') {
             const tagInstances = await DiaryTag.findAll({ where: { id: tags } });
             await newNote.addTags(tagInstances);
+
+            const noteWithTags = await DiaryNote.findByPk(newNote.id, {
+                include: [{ model: DiaryTag, as: 'tags', required: false }],
+            });
+
+            return res.status(201).json(noteWithTags ?? newNote);
         }
-        const noteWithTags = await DiaryNote.findByPk(newNote.id, {
-            include: [{ model: DiaryTag, as: 'tags' }],
-        });
-        res.status(201).json(noteWithTags);
+
+        res.status(201).json(newNote);
     } catch (error) {
+        console.error('[createNote] - Error:', error);
         res.status(500).json({ error: 'Error creating note' });
     }
 };

backend/controllers/diaryTagController.js

@@ -12,11 +12,13 @@ export const getTags = async (req, res) => {
 export const createTag = async (req, res) => {
     try {
         const { name } = req.body;
-        console.log(name);
-        const newTag = await DiaryTag.findOrCreate({ where: { name }, defaults: { name } });
-        res.status(201).json(newTag);
+        if (!name) {
+            return res.status(400).json({ error: 'Der Name des Tags ist erforderlich.' });
+        }
+
+        const [tag, created] = await DiaryTag.findOrCreate({ where: { name }, defaults: { name } });
+        res.status(created ? 201 : 200).json(tag);
     } catch (error) {
-        console.log('[createTag] - Error:', error);
         res.status(500).json({ error: 'Error creating tag' });
     }
 };
@@ -24,9 +26,14 @@ export const createTag = async (req, res) => {
 export const deleteTag = async (req, res) => {
     try {
         const { tagId } = req.params;
-        const { authcode: userToken } = req.headers;
-        const { clubId } = req.params;
-        await diaryService.removeTagFromDiaryDate(userToken, clubId, tagId);
+
+        await DiaryDateTag.destroy({ where: { tagId } });
+        const deleted = await DiaryTag.destroy({ where: { id: tagId } });
+
+        if (!deleted) {
+            return res.status(404).json({ error: 'Tag nicht gefunden' });
+        }
+
         res.status(200).json({ message: 'Tag deleted' });
     } catch (error) {
         console.error('[deleteTag] - Error:', error);

backend/controllers/groupController.js

@@ -1,6 +1,7 @@
 import HttpError from '../exceptions/HttpError.js';
 import groupService from '../services/groupService.js';
 
+import { devLog } from '../utils/logger.js';
 const addGroup = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -9,7 +10,7 @@ const addGroup = async(req, res) => {
         res.status(201).json(result);
     } catch (error) {
         console.error('[addGroup] - Error:', error);
-        console.log(req.params, req.headers, req.body)
+        devLog(req.params, req.headers, req.body)
         res.status(error.statusCode || 500).json({ error: error.message });
     }
 }

backend/controllers/matchController.js

@@ -1,6 +1,7 @@
 import MatchService from '../services/matchService.js';
 import fs from 'fs';
 
+import { devLog } from '../utils/logger.js';
 export const uploadCSV = async (req, res) => {
     try {
         const { clubId } = req.body;
@@ -21,10 +22,11 @@ export const uploadCSV = async (req, res) => {
 
 export const getLeaguesForCurrentSeason = async (req, res) => {
     try {
-        console.log(req.headers, req.params);
+        devLog(req.headers, req.params);
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;
-        const leagues = await MatchService.getLeaguesForCurrentSeason(userToken, clubId);
+        const { seasonid: seasonId } = req.query;
+        const leagues = await MatchService.getLeaguesForCurrentSeason(userToken, clubId, seasonId);
         return res.status(200).json(leagues);
     } catch (error) {
         console.error('Error retrieving leagues:', error);
@@ -36,7 +38,8 @@ export const getMatchesForLeagues = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;
-        const matches = await MatchService.getMatchesForLeagues(userToken, clubId);
+        const { seasonid: seasonId } = req.query;
+        const matches = await MatchService.getMatchesForLeagues(userToken, clubId, seasonId);
         return res.status(200).json(matches);
     } catch (error) {
         console.error('Error retrieving matches:', error);
@@ -55,3 +58,90 @@ export const getMatchesForLeague = async (req, res) => {
         return res.status(500).json({ error: 'Failed to retrieve matches' });
     }
 };
+
+export const getLeagueTable = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, leagueId } = req.params;
+        const table = await MatchService.getLeagueTable(userToken, clubId, leagueId);
+        return res.status(200).json(table);
+    } catch (error) {
+        console.error('Error retrieving league table:', error);
+        return res.status(500).json({ error: 'Failed to retrieve league table' });
+    }
+};
+
+export const fetchLeagueTableFromMyTischtennis = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, leagueId } = req.params;
+        const { userid: userIdOrEmail } = req.headers;
+        
+        // Convert email to userId if needed
+        let userId = userIdOrEmail;
+        if (isNaN(userIdOrEmail)) {
+            const User = (await import('../models/User.js')).default;
+            const user = await User.findOne({ where: { email: userIdOrEmail } });
+            if (!user) {
+                return res.status(404).json({ error: 'User not found' });
+            }
+            userId = user.id;
+        }
+        
+        const autoFetchService = (await import('../services/autoFetchMatchResultsService.js')).default;
+        await autoFetchService.fetchAndUpdateLeagueTable(userId, leagueId);
+        
+        // Return updated table data
+        const table = await MatchService.getLeagueTable(userToken, clubId, leagueId);
+        return res.status(200).json({
+            message: 'League table updated from MyTischtennis',
+            data: table
+        });
+    } catch (error) {
+        console.error('Error fetching league table from MyTischtennis:', error);
+        return res.status(500).json({ error: 'Failed to fetch league table from MyTischtennis' });
+    }
+};
+
+export const updateMatchPlayers = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { matchId } = req.params;
+        const { playersReady, playersPlanned, playersPlayed } = req.body;
+        
+        const result = await MatchService.updateMatchPlayers(
+            userToken,
+            matchId,
+            playersReady,
+            playersPlanned,
+            playersPlayed
+        );
+        
+        return res.status(200).json({
+            message: 'Match players updated successfully',
+            data: result
+        });
+    } catch (error) {
+        console.error('Error updating match players:', error);
+        return res.status(error.statusCode || 500).json({ 
+            error: error.message || 'Failed to update match players' 
+        });
+    }
+};
+
+export const getPlayerMatchStats = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, leagueId } = req.params;
+        const { seasonid: seasonId } = req.query;
+        
+        const stats = await MatchService.getPlayerMatchStats(userToken, clubId, leagueId, seasonId);
+        
+        return res.status(200).json(stats);
+    } catch (error) {
+        console.error('Error retrieving player match stats:', error);
+        return res.status(error.statusCode || 500).json({ 
+            error: error.message || 'Failed to retrieve player match stats' 
+        });
+    }
+};

backend/controllers/memberActivityController.js

@@ -0,0 +1,232 @@
+import { checkAccess } from '../utils/userUtils.js';
+import DiaryMemberActivity from '../models/DiaryMemberActivity.js';
+import DiaryDateActivity from '../models/DiaryDateActivity.js';
+import DiaryDates from '../models/DiaryDates.js';
+import Participant from '../models/Participant.js';
+import PredefinedActivity from '../models/PredefinedActivity.js';
+import GroupActivity from '../models/GroupActivity.js';
+import { Op } from 'sequelize';
+
+export const getMemberActivities = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, memberId } = req.params;
+        const { period } = req.query; // 'month', '3months', '6months', 'year', 'all'
+        
+        await checkAccess(userToken, clubId);
+        
+        // Calculate date range based on period
+        const now = new Date();
+        let startDate = null;
+        
+        switch (period) {
+            case 'month':
+                startDate = new Date(now.getFullYear(), now.getMonth() - 1, now.getDate());
+                break;
+            case '3months':
+                startDate = new Date(now.getFullYear(), now.getMonth() - 3, now.getDate());
+                break;
+            case '6months':
+                startDate = new Date(now.getFullYear(), now.getMonth() - 6, now.getDate());
+                break;
+            case 'year':
+                startDate = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+                break;
+            case 'all':
+            default:
+                startDate = null;
+                break;
+        }
+        
+        // Get participant ID for this member
+        const participants = await Participant.findAll({
+            where: { memberId: memberId }
+        });
+        
+        if (participants.length === 0) {
+            return res.status(200).json([]);
+        }
+        
+        const participantIds = participants.map(p => p.id);
+        
+        // Get all diary member activities for this member
+        const whereClause = {
+            participantId: participantIds
+        };
+        
+        const memberActivities = await DiaryMemberActivity.findAll({
+            where: whereClause,
+            include: [
+                {
+                    model: Participant,
+                    as: 'participant',
+                    attributes: ['id', 'groupId', 'diaryDateId']
+                },
+                {
+                    model: DiaryDateActivity,
+                    as: 'activity',
+                    include: [
+                        {
+                            model: DiaryDates,
+                            as: 'diaryDate',
+                            where: startDate ? {
+                                date: {
+                                    [Op.gte]: startDate
+                                }
+                            } : {}
+                        },
+                        {
+                            model: PredefinedActivity,
+                            as: 'predefinedActivity'
+                        },
+                        {
+                            model: GroupActivity,
+                            as: 'groupActivities',
+                            required: false
+                        }
+                    ]
+                }
+            ],
+            order: [[{ model: DiaryDateActivity, as: 'activity' }, { model: DiaryDates, as: 'diaryDate' }, 'date', 'DESC']]
+        });
+        
+        // Group activities by name and count occurrences, considering group assignment
+        const activityMap = new Map();
+        
+        for (const ma of memberActivities) {
+            if (!ma.activity || !ma.activity.predefinedActivity || !ma.participant) {
+                continue;
+            }
+            
+            // Check group assignment
+            const participantGroupId = ma.participant.groupId;
+            const activityGroupIds = ma.activity.groupActivities?.map(ga => ga.groupId) || [];
+            
+            // Filter: Only count if:
+            // 1. Activity has no group assignment (empty activityGroupIds) - activity is for all groups OR
+            // 2. Participant's group matches one of the activity's groups
+            const shouldCount = activityGroupIds.length === 0 || 
+                                (participantGroupId !== null && activityGroupIds.includes(participantGroupId));
+            
+            if (!shouldCount) {
+                continue;
+            }
+            
+            const activity = ma.activity.predefinedActivity;
+            const activityName = activity.name;
+            const date = ma.activity.diaryDate?.date;
+            
+            if (!activityMap.has(activityName)) {
+                activityMap.set(activityName, {
+                    name: activityName,
+                    count: 0,
+                    dates: []
+                });
+            }
+            
+            const activityData = activityMap.get(activityName);
+            activityData.count++;
+            if (date) {
+                activityData.dates.push(date);
+            }
+        }
+        
+        // Convert map to array and sort by count
+        const activities = Array.from(activityMap.values())
+            .sort((a, b) => b.count - a.count);
+        
+        return res.status(200).json(activities);
+        
+    } catch (error) {
+        console.error('Error fetching member activities:', error);
+        return res.status(500).json({ error: 'Failed to fetch member activities' });
+    }
+};
+
+export const getMemberLastParticipations = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, memberId } = req.params;
+        const { limit = 3 } = req.query;
+        
+        await checkAccess(userToken, clubId);
+        
+        // Get participant ID for this member
+        const participants = await Participant.findAll({
+            where: { memberId: memberId }
+        });
+        
+        if (participants.length === 0) {
+            return res.status(200).json([]);
+        }
+        
+        const participantIds = participants.map(p => p.id);
+        
+        // Get last participations for this member
+        const memberActivities = await DiaryMemberActivity.findAll({
+            where: {
+                participantId: participantIds
+            },
+            include: [
+                {
+                    model: Participant,
+                    as: 'participant',
+                    attributes: ['id', 'groupId', 'diaryDateId']
+                },
+                {
+                    model: DiaryDateActivity,
+                    as: 'activity',
+                    include: [
+                        {
+                            model: DiaryDates,
+                            as: 'diaryDate'
+                        },
+                        {
+                            model: PredefinedActivity,
+                            as: 'predefinedActivity'
+                        },
+                        {
+                            model: GroupActivity,
+                            as: 'groupActivities',
+                            required: false
+                        }
+                    ]
+                }
+            ],
+            order: [[{ model: DiaryDateActivity, as: 'activity' }, { model: DiaryDates, as: 'diaryDate' }, 'date', 'DESC']],
+            limit: parseInt(limit) * 10 // Get more to filter by group
+        });
+        
+        // Format the results, considering group assignment
+        const participations = memberActivities
+            .filter(ma => {
+                if (!ma.activity || !ma.activity.predefinedActivity || !ma.activity.diaryDate || !ma.participant) {
+                    return false;
+                }
+                
+                // Check group assignment
+                const participantGroupId = ma.participant.groupId;
+                const activityGroupIds = ma.activity.groupActivities?.map(ga => ga.groupId) || [];
+                
+                // Filter: Only count if:
+                // 1. Activity has no group assignment (empty activityGroupIds) - activity is for all groups OR
+                // 2. Participant's group matches one of the activity's groups
+                return activityGroupIds.length === 0 || 
+                       (participantGroupId !== null && activityGroupIds.includes(participantGroupId));
+            })
+            .slice(0, parseInt(limit)) // Limit after filtering
+            .map(ma => ({
+                id: ma.id,
+                activityName: ma.activity.predefinedActivity.name,
+                date: ma.activity.diaryDate.date,
+                diaryDateId: ma.activity.diaryDate.id
+            }));
+        
+        return res.status(200).json(participations);
+        
+    } catch (error) {
+        console.error('Error fetching member last participations:', error);
+        return res.status(500).json({ error: 'Failed to fetch member last participations' });
+    }
+};
+

backend/controllers/memberController.js

@@ -1,48 +1,41 @@
 import MemberService from "../services/memberService.js";
+import MemberTransferService from "../services/memberTransferService.js";
 
+import { devLog } from '../utils/logger.js';
 const getClubMembers = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
-        const { id: clubId, showAll } = req.params;
-        if (showAll === null) {
-            showAll = false;
-        }
+        const { id: clubId } = req.params;
+        const showAll = req.params.showAll ?? 'false';
         res.status(200).json(await MemberService.getClubMembers(userToken, clubId, showAll));
     } catch(error) {
-        console.log('[getClubMembers] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 }
 
 const getWaitingApprovals = async(req, res) => {
     try {
-        console.log('[getWaitingApprovals] - Start');
         const { id: clubId } = req.params;
-        console.log('[getWaitingApprovals] - get token');
         const { authcode: userToken } = req.headers;
-        console.log('[getWaitingApprovals] - load for waiting approvals');
         const waitingApprovals = await MemberService.getApprovalRequests(userToken, clubId);
-        console.log('[getWaitingApprovals] - set response');
         res.status(200).json(waitingApprovals);
-        console.log('[getWaitingApprovals] - done');
     } catch(error) {
-        console.log('[getWaitingApprovals] - Error: ', error);
         res.status(403).json({ error: error });
     }
 } 
 
 const setClubMembers = async (req, res) => {
     try {
-        const { id: memberId, firstname: firstName, lastname: lastName, street, city, birthdate, phone, email, active, 
-            testMembership, picsInInternetAllowed } = req.body;
+    const { id: memberId, firstname: firstName, lastname: lastName, street, city, postalCode, birthdate, phone, email, active, 
+            testMembership, picsInInternetAllowed, gender, ttr, qttr, memberFormHandedOver, contacts } = req.body;
         const { id: clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        const addResult = await MemberService.setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, birthdate, 
-            phone, email, active, testMembership, picsInInternetAllowed);
+        const addResult = await MemberService.setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, postalCode, birthdate, 
+            phone, email, active, testMembership, picsInInternetAllowed, gender, ttr, qttr, memberFormHandedOver, contacts);
         res.status(addResult.status || 500).json(addResult.response);
     } catch (error) {
         console.error('[setClubMembers] - Error:', error);
-        res.status(500).json({ error: 'Failed to upload image' });
+        res.status(500).json({ error: 'Failed to save member' });
     }
 }
 
@@ -50,8 +43,12 @@ const uploadMemberImage = async (req, res) => {
     try {
         const { clubId, memberId } = req.params;
         const { authcode: userToken } = req.headers;
-        const result = await MemberService.uploadMemberImage(userToken, clubId, memberId, req.file.buffer);
-        res.status(result.status).json(result.message ? { message: result.message } : { error: result.error });
+        const makePrimary =
+            req.body?.makePrimary === true ||
+            req.body?.makePrimary === 'true' ||
+            req.query?.makePrimary === 'true';
+        const result = await MemberService.uploadMemberImage(userToken, clubId, memberId, req.file.buffer, { makePrimary });
+        res.status(result.status).json(result.response ?? { success: false, error: 'Unknown upload result' });
     } catch (error) {
         console.error('[uploadMemberImage] - Error:', error);
         res.status(500).json({ error: 'Failed to upload image' });
@@ -59,11 +56,12 @@ const uploadMemberImage = async (req, res) => {
 };
 
 const getMemberImage = async (req, res) => {
-    console.log('[getMemberImage]');
     try {
-        const { clubId, memberId } = req.params;
+        const { clubId, memberId, imageId } = req.params;
         const { authcode: userToken } = req.headers;
-        const result = await MemberService.getMemberImage(userToken, clubId, memberId);
+        // Support "latest" as imageId to get the latest image
+        const actualImageId = imageId === 'latest' ? null : (imageId || null);
+        const result = await MemberService.getMemberImage(userToken, clubId, memberId, actualImageId);
         if (result.status === 200) {
             res.sendFile(result.imagePath);
         } else {
@@ -75,4 +73,174 @@ const getMemberImage = async (req, res) => {
     }
 };
 
-export { getClubMembers, getWaitingApprovals, setClubMembers, uploadMemberImage, getMemberImage };
+const updateRatingsFromMyTischtennis = async (req, res) => {
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.updateRatingsFromMyTischtennis(userToken, clubId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[updateRatingsFromMyTischtennis] - Error:', error);
+        res.status(500).json({ error: 'Failed to update ratings' });
+    }
+};
+
+const rotateMemberImage = async (req, res) => {
+    try {
+        const { clubId, memberId, imageId } = req.params;
+        const { direction } = req.body;
+        const { authcode: userToken } = req.headers;
+        
+        if (!direction || !['left', 'right'].includes(direction)) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Ungültige Drehrichtung. Verwenden Sie "left" oder "right".' 
+            });
+        }
+        
+        const result = await MemberService.rotateMemberImage(userToken, clubId, memberId, imageId, direction);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[rotateMemberImage] - Error:', error);
+        res.status(500).json({ success: false, error: 'Failed to rotate image' });
+    }
+};
+
+const deleteMemberImage = async (req, res) => {
+    try {
+        const { clubId, memberId, imageId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.deleteMemberImage(userToken, clubId, memberId, imageId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[deleteMemberImage] - Error:', error);
+        res.status(500).json({ success: false, error: 'Failed to delete image' });
+    }
+};
+
+const generateMemberGallery = async (req, res) => {
+    try {
+        const { clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const size = parseInt(req.query.size) || 200; // Default: 200x200
+        const format = req.query.format || 'image'; // 'image' or 'json'
+        const result = await MemberService.generateMemberGallery(userToken, clubId, size);
+        if (result.status === 200) {
+            if (format === 'json') {
+                // Return member information for interactive gallery
+                return res.status(200).json({
+                    members: result.galleryEntries.map(entry => ({
+                        memberId: entry.memberId,
+                        firstName: entry.firstName,
+                        lastName: entry.lastName,
+                        fullName: entry.fullName
+                    }))
+                });
+            }
+            res.setHeader('Content-Type', 'image/png');
+            res.setHeader('Cache-Control', 'no-store');
+            return res.status(200).send(result.buffer);
+        }
+        return res.status(result.status).json({ error: result.error || 'Galerie konnte nicht erstellt werden' });
+    } catch (error) {
+        console.error('[generateMemberGallery] - Error:', error);
+        res.status(500).json({ error: 'Failed to generate member gallery' });
+    }
+};
+
+const setPrimaryMemberImage = async (req, res) => {
+    try {
+        const { clubId, memberId, imageId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.setPrimaryMemberImage(userToken, clubId, memberId, imageId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[setPrimaryMemberImage] - Error:', error);
+        res.status(500).json({ success: false, error: 'Failed to update primary image' });
+    }
+};
+
+const quickUpdateTestMembership = async (req, res) => {
+    try {
+        const { clubId, memberId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.quickUpdateTestMembership(userToken, clubId, memberId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[quickUpdateTestMembership] - Error:', error);
+        res.status(500).json({ error: 'Failed to update test membership' });
+    }
+};
+
+const quickUpdateMemberFormHandedOver = async (req, res) => {
+    try {
+        const { clubId, memberId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.quickUpdateMemberFormHandedOver(userToken, clubId, memberId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[quickUpdateMemberFormHandedOver] - Error:', error);
+        res.status(500).json({ error: 'Failed to update member form status' });
+    }
+};
+
+const quickDeactivateMember = async (req, res) => {
+    try {
+        const { clubId, memberId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.quickDeactivateMember(userToken, clubId, memberId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[quickDeactivateMember] - Error:', error);
+        res.status(500).json({ error: 'Failed to deactivate member' });
+    }
+};
+
+const transferMembers = async (req, res) => {
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const config = req.body;
+
+        // Validierung
+        if (!config.transferEndpoint) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Übertragungs-Endpoint ist erforderlich' 
+            });
+        }
+
+        if (!config.transferTemplate) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Übertragungs-Template ist erforderlich' 
+            });
+        }
+
+        const result = await MemberTransferService.transferMembers(userToken, clubId, config);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[transferMembers] - Error:', error);
+        res.status(500).json({ 
+            success: false, 
+            error: 'Fehler bei der Übertragung: ' + error.message 
+        });
+    }
+};
+
+export {
+    getClubMembers,
+    getWaitingApprovals,
+    setClubMembers,
+    uploadMemberImage,
+    getMemberImage,
+    updateRatingsFromMyTischtennis,
+    rotateMemberImage,
+    transferMembers,
+    quickUpdateTestMembership,
+    quickUpdateMemberFormHandedOver,
+    quickDeactivateMember,
+    deleteMemberImage,
+    setPrimaryMemberImage,
+    generateMemberGallery
+};

backend/controllers/memberNoteController.js

@@ -1,15 +1,15 @@
 import MemberNoteService from "../services/memberNoteService.js";
+import MemberNote from '../models/MemberNote.js';
 
+import { devLog } from '../utils/logger.js';
 const getMemberNotes = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId } = req.params;
         const { clubId } = req.query;
-        console.log('[getMemberNotes]', userToken, memberId, clubId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[getMemberNotes] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -18,12 +18,11 @@ const addMemberNote = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId, content, clubId } = req.body;
-        console.log('[addMemberNote]', userToken, memberId, content, clubId);
         await MemberNoteService.addNoteToMember(userToken, clubId, memberId, content);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(201).json(notes);
     } catch (error) {
-        console.log('[addMemberNote] - Error: ', error);
+        console.error('[addMemberNote] - Error:', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -33,13 +32,16 @@ const deleteMemberNote = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { noteId } = req.params;
         const { clubId } = req.body;
-        console.log('[deleteMemberNote]', userToken, noteId, clubId);
-        const memberId = await MemberNoteService.getMemberIdForNote(noteId); // Member ID ermitteln
+        const note = await MemberNote.findByPk(noteId);
+        if (!note) {
+            return res.status(404).json({ error: 'notfound' });
+        }
+        const memberId = note.memberId;
         await MemberNoteService.deleteNoteForMember(userToken, clubId, noteId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[deleteMemberNote] - Error: ', error);
+        console.error('[deleteMemberNote] - Error:', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };

backend/controllers/memberTransferConfigController.js

@@ -0,0 +1,51 @@
+import MemberTransferConfigService from '../services/memberTransferConfigService.js';
+
+export const getConfig = async (req, res) => {
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        
+        const result = await MemberTransferConfigService.getConfig(userToken, clubId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[getConfig] Error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Fehler beim Laden der Konfiguration'
+        });
+    }
+};
+
+export const saveConfig = async (req, res) => {
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const configData = req.body;
+        
+        const result = await MemberTransferConfigService.saveConfig(userToken, clubId, configData);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[saveConfig] Error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Fehler beim Speichern der Konfiguration'
+        });
+    }
+};
+
+export const deleteConfig = async (req, res) => {
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        
+        const result = await MemberTransferConfigService.deleteConfig(userToken, clubId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[deleteConfig] Error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Fehler beim Löschen der Konfiguration'
+        });
+    }
+};
+

backend/controllers/myTischtennisController.js

@@ -0,0 +1,205 @@
+import myTischtennisService from '../services/myTischtennisService.js';
+import HttpError from '../exceptions/HttpError.js';
+
+class MyTischtennisController {
+  /**
+   * GET /api/mytischtennis/account
+   * Get current user's myTischtennis account
+   */
+  async getAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const account = await myTischtennisService.getAccount(userId);
+      
+      if (!account) {
+        return res.status(200).json({ account: null });
+      }
+      
+      res.status(200).json({ account });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/mytischtennis/status
+   * Check account configuration status
+   */
+  async getStatus(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const status = await myTischtennisService.checkAccountStatus(userId);
+      res.status(200).json(status);
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * POST /api/mytischtennis/account
+   * Create or update myTischtennis account
+   */
+  async upsertAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const { email, password, savePassword, autoUpdateRatings, userPassword } = req.body;
+
+      if (!email) {
+        throw new HttpError('E-Mail-Adresse erforderlich', 400);
+      }
+
+      // Wenn ein Passwort gesetzt wird, muss das App-Passwort angegeben werden
+      if (password && !userPassword) {
+        throw new HttpError('App-Passwort erforderlich zum Setzen des myTischtennis-Passworts', 400);
+      }
+
+      const account = await myTischtennisService.upsertAccount(
+        userId,
+        email,
+        password,
+        savePassword || false,
+        autoUpdateRatings || false,
+        userPassword
+      );
+
+      res.status(200).json({ 
+        message: 'myTischtennis-Account erfolgreich gespeichert',
+        account 
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * DELETE /api/mytischtennis/account
+   * Delete myTischtennis account
+   */
+  async deleteAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const deleted = await myTischtennisService.deleteAccount(userId);
+      
+      if (!deleted) {
+        throw new HttpError('Kein myTischtennis-Account gefunden', 404);
+      }
+
+      res.status(200).json({ message: 'myTischtennis-Account gelöscht' });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * POST /api/mytischtennis/verify
+   * Verify login credentials
+   */
+  async verifyLogin(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const { password } = req.body;
+
+      const result = await myTischtennisService.verifyLogin(userId, password);
+
+      res.status(200).json({
+        message: 'Login erfolgreich',
+        success: true,
+        accessToken: result.accessToken,
+        expiresAt: result.expiresAt,
+        clubId: result.clubId,
+        clubName: result.clubName
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/mytischtennis/session
+   * Get stored session data for authenticated requests
+   */
+  async getSession(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const session = await myTischtennisService.getSession(userId);
+
+      res.status(200).json({ session });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/mytischtennis/update-history
+   * Get update ratings history
+   */
+  async getUpdateHistory(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const history = await myTischtennisService.getUpdateHistory(userId);
+      res.status(200).json({ history });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get fetch logs for current user
+   */
+  async getFetchLogs(req, res, next) {
+    try {
+      const { userid: userIdOrEmail } = req.headers;
+      
+      // Convert email to userId if needed
+      let userId = userIdOrEmail;
+      if (isNaN(userIdOrEmail)) {
+        const User = (await import('../models/User.js')).default;
+        const user = await User.findOne({ where: { email: userIdOrEmail } });
+        if (!user) {
+          return res.status(404).json({ error: 'User not found' });
+        }
+        userId = user.id;
+      }
+
+      const fetchLogService = (await import('../services/myTischtennisFetchLogService.js')).default;
+      const logs = await fetchLogService.getFetchLogs(userId, {
+        limit: req.query.limit ? parseInt(req.query.limit) : 50,
+        fetchType: req.query.type
+      });
+
+      res.status(200).json({ logs });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Get latest successful fetches for each type
+   */
+  async getLatestFetches(req, res, next) {
+    try {
+      const { userid: userIdOrEmail } = req.headers;
+      
+      // Convert email to userId if needed
+      let userId = userIdOrEmail;
+      if (isNaN(userIdOrEmail)) {
+        const User = (await import('../models/User.js')).default;
+        const user = await User.findOne({ where: { email: userIdOrEmail } });
+        if (!user) {
+          return res.status(404).json({ error: 'User not found' });
+        }
+        userId = user.id;
+      }
+
+      const fetchLogService = (await import('../services/myTischtennisFetchLogService.js')).default;
+      const latestFetches = await fetchLogService.getLatestSuccessfulFetches(userId);
+
+      res.status(200).json({ latestFetches });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+export default new MyTischtennisController();
+

backend/controllers/myTischtennisUrlController.js

@@ -0,0 +1,601 @@
+import myTischtennisUrlParserService from '../services/myTischtennisUrlParserService.js';
+import myTischtennisService from '../services/myTischtennisService.js';
+import MemberService from '../services/memberService.js';
+import autoFetchMatchResultsService from '../services/autoFetchMatchResultsService.js';
+import apiLogService from '../services/apiLogService.js';
+import ClubTeam from '../models/ClubTeam.js';
+import League from '../models/League.js';
+import Season from '../models/Season.js';
+import User from '../models/User.js';
+import HttpError from '../exceptions/HttpError.js';
+import { devLog } from '../utils/logger.js';
+
+class MyTischtennisUrlController {
+  /**
+   * Parse myTischtennis URL and return configuration data
+   * POST /api/mytischtennis/parse-url
+   * Body: { url: string }
+   */
+  async parseUrl(req, res, next) {
+    try {
+      const { url } = req.body;
+
+      if (!url) {
+        throw new HttpError('URL is required', 400);
+      }
+
+      // Validate URL
+      if (!myTischtennisUrlParserService.isValidTeamUrl(url)) {
+        throw new HttpError('Invalid myTischtennis URL format', 400);
+      }
+
+      // Parse URL
+      const parsedData = myTischtennisUrlParserService.parseUrl(url);
+
+      // Try to fetch additional data if user is authenticated
+      const userIdOrEmail = req.headers.userid;
+      let completeData = parsedData;
+
+      if (userIdOrEmail) {
+        // Get actual user ID
+        let userId = userIdOrEmail;
+        if (isNaN(userIdOrEmail)) {
+          const user = await User.findOne({ where: { email: userIdOrEmail } });
+          if (user) userId = user.id;
+        }
+        
+        try {
+          const account = await myTischtennisService.getAccount(userId);
+          
+          if (account && account.accessToken) {
+            completeData = await myTischtennisUrlParserService.fetchTeamData(
+              parsedData,
+              account.cookie,
+              account.accessToken
+            );
+          }
+        } catch (error) {
+          // Continue with parsed data only
+        }
+      }
+
+      res.json({
+        success: true,
+        data: completeData
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Configure team from myTischtennis URL
+   * POST /api/mytischtennis/configure-team
+   * Body: { url: string, clubTeamId: number, createLeague?: boolean, createSeason?: boolean }
+   */
+  async configureTeam(req, res, next) {
+    try {
+      const { url, clubTeamId, createLeague, createSeason } = req.body;
+      const userIdOrEmail = req.headers.userid;
+
+      if (!url || !clubTeamId) {
+        throw new HttpError('URL and clubTeamId are required', 400);
+      }
+
+      // Get actual user ID
+      let userId = userIdOrEmail;
+      if (isNaN(userIdOrEmail)) {
+        const user = await User.findOne({ where: { email: userIdOrEmail } });
+        if (!user) {
+          throw new HttpError('User not found', 404);
+        }
+        userId = user.id;
+      }
+
+      // Parse URL
+      const parsedData = myTischtennisUrlParserService.parseUrl(url);
+
+      // Try to fetch additional data
+      let completeData = parsedData;
+      const account = await myTischtennisService.getAccount(userId);
+      
+      if (account && account.accessToken) {
+        try {
+          completeData = await myTischtennisUrlParserService.fetchTeamData(
+            parsedData,
+            account.cookie,
+            account.accessToken
+          );
+        } catch (error) {
+        }
+      }
+
+      // Find or create season
+      let season = await Season.findOne({
+        where: { season: completeData.season }
+      });
+
+      if (!season && createSeason) {
+        season = await Season.create({
+          season: completeData.season
+        });
+      }
+
+      if (!season) {
+        throw new HttpError(`Season ${completeData.season} not found. Set createSeason=true to create it.`, 404);
+      }
+
+      // Find or create league
+      const team = await ClubTeam.findByPk(clubTeamId);
+      if (!team) {
+        throw new HttpError('Club team not found', 404);
+      }
+
+      let league;
+      
+      // First, try to find existing league by name and season
+      const leagueName = completeData.leagueName || completeData.groupname;
+      league = await League.findOne({
+        where: {
+          name: leagueName,
+          seasonId: season.id,
+          clubId: team.clubId
+        }
+      });
+
+      if (league) {
+        devLog(`Found existing league: ${league.name} (ID: ${league.id})`);
+        // Update myTischtennis fields
+        await league.update({
+          myTischtennisGroupId: completeData.groupId,
+          association: completeData.association,
+          groupname: completeData.groupname
+        });
+      } else if (team.leagueId) {
+        // Team has a league assigned, update it
+        league = await League.findByPk(team.leagueId);
+        
+        if (league) {
+          devLog(`Updating team's existing league: ${league.name} (ID: ${league.id})`);
+          await league.update({
+            name: leagueName,
+            myTischtennisGroupId: completeData.groupId,
+            association: completeData.association,
+            groupname: completeData.groupname
+          });
+        }
+      } else if (createLeague) {
+        // Create new league
+        devLog(`Creating new league: ${leagueName}`);
+        league = await League.create({
+          name: leagueName,
+          seasonId: season.id,
+          clubId: team.clubId,
+          myTischtennisGroupId: completeData.groupId,
+          association: completeData.association,
+          groupname: completeData.groupname
+        });
+      } else {
+        throw new HttpError('League not found and team has no league assigned. Set createLeague=true to create one.', 400);
+      }
+
+      // Update team
+      await team.update({
+        myTischtennisTeamId: completeData.teamId,
+        leagueId: league.id,
+        seasonId: season.id
+      });
+
+      res.json({
+        success: true,
+        message: 'Team configured successfully',
+        data: {
+          team: {
+            id: team.id,
+            name: team.name,
+            myTischtennisTeamId: completeData.teamId
+          },
+          league: {
+            id: league.id,
+            name: league.name,
+            myTischtennisGroupId: completeData.groupId,
+            association: completeData.association,
+            groupname: completeData.groupname
+          },
+          season: {
+            id: season.id,
+            name: season.season
+          },
+          parsedData: completeData
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Manually fetch team data from myTischtennis
+   * POST /api/mytischtennis/fetch-team-data
+   * Body: { clubTeamId: number }
+   */
+  async fetchTeamData(req, res, next) {
+    // Define outside of try/catch so catch has access
+    let account = null;
+    let team = null;
+    let myTischtennisUrl = null;
+    let requestStartTime = null;
+    try {
+      const { clubTeamId } = req.body;
+      const userIdOrEmail = req.headers.userid;
+
+      if (!clubTeamId) {
+        throw new HttpError('clubTeamId is required', 400);
+      }
+
+      if (!userIdOrEmail) {
+        throw new HttpError('User-ID fehlt. Bitte melden Sie sich an.', 401);
+      }
+
+      // Get actual user ID (userid header might be email address)
+      let userId = userIdOrEmail;
+      if (isNaN(userIdOrEmail)) {
+        // It's an email, find the user
+        const user = await User.findOne({ where: { email: userIdOrEmail } });
+        if (!user) {
+          throw new HttpError('User not found', 404);
+        }
+        userId = user.id;
+      }
+
+      // Get myTischtennis session (similar to memberService.updateRatingsFromMyTischtennis)
+      let session;
+      
+      try {
+        session = await myTischtennisService.getSession(userId);
+      } catch (sessionError) {
+        // Versuche automatischen Login mit gespeicherten Credentials
+        try {
+          // Check if account exists and has password
+          const accountCheck = await myTischtennisService.getAccount(userId);
+          if (!accountCheck) {
+            throw new Error('MyTischtennis-Account nicht gefunden');
+          }
+          
+          if (!accountCheck.encryptedPassword) {
+            throw new Error('Kein Passwort gespeichert. Bitte melden Sie sich in den MyTischtennis-Einstellungen an und speichern Sie Ihr Passwort.');
+          }
+          
+          await myTischtennisService.verifyLogin(userId);
+          session = await myTischtennisService.getSession(userId);
+        } catch (loginError) {
+          const errorMessage = loginError.message || 'Automatischer Login fehlgeschlagen';
+          throw new HttpError(`MyTischtennis-Session abgelaufen und automatischer Login fehlgeschlagen: ${errorMessage}. Bitte melden Sie sich in den MyTischtennis-Einstellungen an.`, 401);
+        }
+      }
+      
+      // Get account data (for clubId, etc.)
+      account = await myTischtennisService.getAccount(userId);
+      
+      if (!account) {
+        throw new HttpError('MyTischtennis-Account nicht verknüpft. Bitte verknüpfen Sie Ihren Account in den MyTischtennis-Einstellungen.', 404);
+      }
+      
+      
+      // Get team with league and season
+      team = await ClubTeam.findByPk(clubTeamId, {
+        include: [
+          {
+            model: League,
+            as: 'league',
+            include: [
+              {
+                model: Season,
+                as: 'season'
+              }
+            ]
+          }
+        ]
+      });
+
+      if (!team) {
+        throw new HttpError(`Team mit ID ${clubTeamId} nicht gefunden`, 404);
+      }
+
+      // Verbesserte Validierung mit detaillierten Fehlermeldungen
+      if (!team.myTischtennisTeamId) {
+        throw new HttpError(`Team "${team.name}" (interne ID: ${team.id}) ist nicht für myTischtennis konfiguriert: myTischtennisTeamId fehlt. Bitte konfigurieren Sie das Team zuerst über die MyTischtennis-URL.`, 400);
+      }
+      
+      if (!team.league) {
+        throw new HttpError('Team ist keiner Liga zugeordnet. Bitte ordnen Sie das Team einer Liga zu.', 400);
+      }
+      
+      if (!team.league.myTischtennisGroupId) {
+        throw new HttpError('Liga ist nicht für myTischtennis konfiguriert: myTischtennisGroupId fehlt. Bitte konfigurieren Sie die Liga zuerst über die MyTischtennis-URL.', 400);
+      }
+
+      // Validate season before proceeding
+      if (!team.league.season || !team.league.season.season) {
+        throw new HttpError('Liga ist keiner Saison zugeordnet. Bitte ordnen Sie die Liga einer Saison zu.', 400);
+      }
+
+      // Build the URL that will be used - do this early so we can log it even if errors occur
+      const seasonFull = team.league.season.season;
+      const seasonParts = seasonFull.split('/');
+      const seasonShort = seasonParts.length === 2 
+        ? `${seasonParts[0].slice(-2)}/${seasonParts[1].slice(-2)}` 
+        : seasonFull;
+      const seasonStr = seasonShort.replace('/', '--');
+      const teamnameEncoded = encodeURIComponent(team.name.replace(/\s/g, '_'));
+      myTischtennisUrl = `https://www.mytischtennis.de/click-tt/${team.league.association}/${seasonStr}/ligen/${team.league.groupname}/gruppe/${team.league.myTischtennisGroupId}/mannschaft/${team.myTischtennisTeamId}/${teamnameEncoded}/spielerbilanzen/gesamt`;
+
+      // Log the request to myTischtennis BEFORE making the call
+      // This ensures we always see what WILL BE sent, even if the call fails
+      requestStartTime = Date.now();
+      try {
+        await apiLogService.logRequest({
+          userId: account.userId,
+          method: 'GET',
+          path: myTischtennisUrl.replace('https://www.mytischtennis.de', ''),
+          statusCode: null,
+          requestBody: JSON.stringify({
+            url: myTischtennisUrl,
+            myTischtennisTeamId: team.myTischtennisTeamId,
+            clubTeamId: team.id,
+            teamName: team.name,
+            leagueName: team.league.name,
+            association: team.league.association,
+            groupId: team.league.myTischtennisGroupId,
+            groupname: team.league.groupname,
+            season: seasonFull
+          }),
+          responseBody: null,
+          executionTime: null,
+          errorMessage: 'Request wird ausgeführt...',
+          logType: 'api_request',
+          schedulerJobType: 'mytischtennis_fetch'
+        });
+      } catch (logError) {
+        // Silent fail - logging errors shouldn't break the request
+      }
+
+      // Fetch data for this specific team
+      // Note: fetchTeamResults will also log and update with actual response
+      const result = await autoFetchMatchResultsService.fetchTeamResults(
+        {
+          userId: account.userId,
+          email: account.email,
+          cookie: session.cookie,
+          accessToken: session.accessToken,
+          expiresAt: session.expiresAt,
+          getPassword: () => null // Not needed for manual fetch
+        },
+        team
+      );
+
+        // Also fetch and update league table data
+        let tableUpdateResult = null;
+      try {
+        await autoFetchMatchResultsService.fetchAndUpdateLeagueTable(account.userId, team.league.id);
+          tableUpdateResult = 'League table updated successfully';
+        } catch (error) {
+          tableUpdateResult = 'League table update failed: ' + error.message;
+          // Don't fail the entire request if table update fails
+        }
+
+        // Additionally update (Q)TTR ratings for the club
+        let ratingsUpdate = null;
+        try {
+          // Use already resolved userId instead of authcode to avoid header dependency
+          const ratingsResult = await MemberService.updateRatingsFromMyTischtennisByUserId(userId, team.clubId);
+          ratingsUpdate = ratingsResult?.response?.message || `Ratings update status: ${ratingsResult?.status}`;
+        } catch (ratingsErr) {
+          ratingsUpdate = 'Ratings update failed: ' + (ratingsErr.message || String(ratingsErr));
+        }
+
+        res.json({
+          success: true,
+          message: `${result.fetchedCount} Datensätze abgerufen und verarbeitet`,
+          data: {
+            fetchedCount: result.fetchedCount,
+            teamName: team.name,
+            tableUpdate: tableUpdateResult,
+            ratingsUpdate
+          }
+        });
+      } catch (error) {
+        
+        // Update log with error information if we got far enough to build the URL
+        if (myTischtennisUrl && account && team) {
+          const requestExecutionTime = requestStartTime ? (Date.now() - requestStartTime) : null;
+          try {
+            await apiLogService.logRequest({
+              userId: account.userId,
+              method: 'GET',
+              path: myTischtennisUrl.replace('https://www.mytischtennis.de', ''),
+              statusCode: 0,
+              requestBody: JSON.stringify({
+                url: myTischtennisUrl,
+                myTischtennisTeamId: team.myTischtennisTeamId,
+                clubTeamId: team.id,
+                teamName: team.name,
+                leagueName: team.league?.name,
+                association: team.league?.association,
+                groupname: team.league?.groupname,
+                groupId: team.league?.myTischtennisGroupId
+              }),
+              responseBody: null,
+              executionTime: requestExecutionTime,
+              errorMessage: error.message || String(error),
+              logType: 'api_request',
+              schedulerJobType: 'mytischtennis_fetch'
+            });
+          } catch (logError) {
+            // Silent fail - logging errors shouldn't break the request
+          }
+        }
+        
+        // Normalize HTTP status code (guard against strings)
+        const rawCode = error && (error.statusCode != null ? error.statusCode : error.status);
+        const parsed = Number(rawCode);
+        const status = Number.isInteger(parsed) && parsed >= 100 && parsed <= 599 ? parsed : 500;
+        const debug = {
+          message: error.message || String(error),
+          name: error.name,
+          stack: (process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development') ? (error.stack || null) : undefined,
+          team: team ? { id: team.id, name: team.name } : null,
+          league: team && team.league ? { id: team.league.id, name: team.league.name, association: team.league.association, groupId: team.league.myTischtennisGroupId, groupname: team.league.groupname } : null,
+          url: typeof myTischtennisUrl !== 'undefined' ? myTischtennisUrl : null
+        };
+        try {
+          if (!res.headersSent) {
+            // Spezieller Fall: myTischtennis-Reauth nötig → nicht 401 an FE senden, um App-Logout zu vermeiden
+            const isMyTischtennisAuthIssue = status === 401 && /MyTischtennis-Session abgelaufen|Automatischer Login fehlgeschlagen|Passwort gespeichert/i.test(debug.message || '');
+            if (isMyTischtennisAuthIssue) {
+              return res.status(200).json({ success: false, error: debug.message, debug, needsMyTischtennisReauth: true });
+            }
+            res.status(status).json({ success: false, error: debug.message, debug });
+          }
+        } catch (writeErr) {
+          // Fallback, falls Headers schon gesendet wurden
+          // eslint-disable-next-line no-console
+          console.error('[fetchTeamData] Response write failed:', writeErr);
+        }
+      }
+  }
+
+  /**
+   * Get myTischtennis URL for a team
+   * GET /api/mytischtennis/team-url/:teamId
+   */
+  async getTeamUrl(req, res, next) {
+    try {
+      const { teamId } = req.params;
+
+      const team = await ClubTeam.findByPk(teamId, {
+        include: [
+          {
+            model: League,
+            as: 'league',
+            include: [
+              {
+                model: Season,
+                as: 'season'
+              }
+            ]
+          }
+        ]
+      });
+
+      if (!team) {
+        throw new HttpError('Team not found', 404);
+      }
+
+      if (!team.myTischtennisTeamId || !team.league || !team.league.myTischtennisGroupId) {
+        throw new HttpError('Team is not configured for myTischtennis', 400);
+      }
+
+      const url = myTischtennisUrlParserService.buildUrl({
+        association: team.league.association,
+        season: team.league.season?.season,
+        groupname: team.league.groupname,
+        groupId: team.league.myTischtennisGroupId,
+        teamId: team.myTischtennisTeamId,
+        teamname: team.name
+      });
+
+      res.json({
+        success: true,
+        url
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Configure league from myTischtennis table URL
+   * POST /api/mytischtennis/configure-league
+   * Body: { url: string, createSeason?: boolean }
+   */
+  async configureLeague(req, res, next) {
+    try {
+      const { url, createSeason } = req.body;
+      const userIdOrEmail = req.headers.userid;
+
+      if (!url) {
+        throw new HttpError('URL is required', 400);
+      }
+
+      // Parse URL
+      const parsedData = myTischtennisUrlParserService.parseUrl(url);
+
+      if (parsedData.urlType !== 'table') {
+        throw new HttpError('URL must be a table URL (not a team URL)', 400);
+      }
+
+      // Find or create season
+      let season = await Season.findOne({
+        where: { season: parsedData.season }
+      });
+
+      if (!season && createSeason) {
+        season = await Season.create({
+          season: parsedData.season,
+          startDate: new Date(),
+          endDate: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // 1 Jahr später
+        });
+      }
+
+      // Find or create league
+      let league = await League.findOne({
+        where: {
+          myTischtennisGroupId: parsedData.groupId,
+          association: parsedData.association
+        }
+      });
+
+      if (!league) {
+        league = await League.create({
+          name: parsedData.groupnameOriginal, // Verwende die originale URL-kodierte Version
+          myTischtennisGroupId: parsedData.groupId,
+          association: parsedData.association,
+          groupname: parsedData.groupnameOriginal, // Verwende die originale URL-kodierte Version
+          seasonId: season?.id || null
+        });
+      } else {
+        // Update existing league - aber nur wenn es sich wirklich geändert hat
+        if (league.name !== parsedData.groupnameOriginal) {
+          league.name = parsedData.groupnameOriginal;
+          league.groupname = parsedData.groupnameOriginal;
+        }
+        league.seasonId = season?.id || league.seasonId;
+        await league.save();
+      }
+
+      res.json({
+        success: true,
+        message: 'League configured successfully',
+        data: {
+          league: {
+            id: league.id,
+            name: league.name,
+            myTischtennisGroupId: league.myTischtennisGroupId,
+            association: league.association,
+            groupname: league.groupname
+          },
+          season: season ? {
+            id: season.id,
+            name: season.season
+          } : null,
+          parsedData
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+export default new MyTischtennisUrlController();

backend/controllers/officialTournamentController.js

@@ -0,0 +1,619 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pdfParse = require('pdf-parse/lib/pdf-parse.js');
+import { checkAccess } from '../utils/userUtils.js';
+import OfficialTournament from '../models/OfficialTournament.js';
+import OfficialCompetition from '../models/OfficialCompetition.js';
+import OfficialCompetitionMember from '../models/OfficialCompetitionMember.js';
+import Member from '../models/Member.js';
+import { Op } from 'sequelize';
+
+// In-Memory Store (einfacher Start); später DB-Modell
+const parsedTournaments = new Map(); // key: id, value: { id, clubId, rawText, parsedData }
+let seq = 1;
+
+export const uploadTournamentPdf = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId } = req.params;
+    await checkAccess(userToken, clubId);
+    if (!req.file || !req.file.buffer) return res.status(400).json({ error: 'No pdf provided' });
+    const data = await pdfParse(req.file.buffer);
+    const parsed = parseTournamentText(data.text);
+    const t = await OfficialTournament.create({
+      clubId,
+      title: parsed.title || null,
+      eventDate: parsed.termin || null,
+      organizer: null,
+      host: null,
+      venues: JSON.stringify(parsed.austragungsorte || []),
+      competitionTypes: JSON.stringify(parsed.konkurrenztypen || []),
+      registrationDeadlines: JSON.stringify(parsed.meldeschluesse || []),
+      entryFees: JSON.stringify(parsed.entryFees || {}),
+    });
+    // competitions persistieren
+    for (const c of parsed.competitions || []) {
+      // Korrigiere Fehlzuordnung: Wenn die Zeile mit "Stichtag" fälschlich in performanceClass steht
+      let performanceClass = c.leistungsklasse || c.performanceClass || null;
+      let cutoffDate = c.stichtag || c.cutoffDate || null;
+      if (performanceClass && /^stichtag\b/i.test(performanceClass)) {
+        cutoffDate = performanceClass.replace(/^stichtag\s*:?\s*/i, '').trim();
+        performanceClass = null;
+      }
+      await OfficialCompetition.create({
+        tournamentId: t.id,
+        ageClassCompetition: c.altersklasseWettbewerb || c.ageClassCompetition || null,
+        performanceClass,
+        startTime: c.startzeit || c.startTime || null,
+        registrationDeadlineDate: c.meldeschlussDatum || c.registrationDeadlineDate || null,
+        registrationDeadlineOnline: c.meldeschlussOnline || c.registrationDeadlineOnline || null,
+        cutoffDate,
+        ttrRelevant: c.ttrRelevant || null,
+        openTo: c.offenFuer || c.openTo || null,
+        preliminaryRound: c.vorrunde || c.preliminaryRound || null,
+        finalRound: c.endrunde || c.finalRound || null,
+        maxParticipants: c.maxTeilnehmer || c.maxParticipants || null,
+        entryFee: c.startgeld || c.entryFee || null,
+      });
+    }
+    res.status(201).json({ id: String(t.id) });
+  } catch (e) {
+    console.error('[uploadTournamentPdf] Error:', e);
+    res.status(500).json({ error: 'Failed to parse pdf' });
+  }
+};
+
+export const getParsedTournament = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, id } = req.params;
+    await checkAccess(userToken, clubId);
+    const t = await OfficialTournament.findOne({ where: { id, clubId } });
+    if (!t) return res.status(404).json({ error: 'not found' });
+    const comps = await OfficialCompetition.findAll({ where: { tournamentId: id } });
+    const entries = await OfficialCompetitionMember.findAll({ where: { tournamentId: id } });
+    const competitions = comps.map((c) => {
+      const j = c.toJSON();
+      return {
+        id: j.id,
+        tournamentId: j.tournamentId,
+        ageClassCompetition: j.ageClassCompetition || null,
+        performanceClass: j.performanceClass || null,
+        startTime: j.startTime || null,
+        registrationDeadlineDate: j.registrationDeadlineDate || null,
+        registrationDeadlineOnline: j.registrationDeadlineOnline || null,
+        cutoffDate: j.cutoffDate || null,
+        ttrRelevant: j.ttrRelevant || null,
+        openTo: j.openTo || null,
+        preliminaryRound: j.preliminaryRound || null,
+        finalRound: j.finalRound || null,
+        maxParticipants: j.maxParticipants || null,
+        entryFee: j.entryFee || null,
+        // Legacy Felder zusätzlich, falls Frontend sie noch nutzt
+        altersklasseWettbewerb: j.ageClassCompetition || null,
+        leistungsklasse: j.performanceClass || null,
+        startzeit: j.startTime || null,
+        meldeschlussDatum: j.registrationDeadlineDate || null,
+        meldeschlussOnline: j.registrationDeadlineOnline || null,
+        stichtag: j.cutoffDate || null,
+        offenFuer: j.openTo || null,
+        vorrunde: j.preliminaryRound || null,
+        endrunde: j.finalRound || null,
+        maxTeilnehmer: j.maxParticipants || null,
+        startgeld: j.entryFee || null,
+      };
+    });
+    res.status(200).json({
+      id: String(t.id),
+      clubId: String(t.clubId),
+      parsedData: {
+        title: t.title,
+        termin: t.eventDate,
+        austragungsorte: JSON.parse(t.venues || '[]'),
+        konkurrenztypen: JSON.parse(t.competitionTypes || '[]'),
+        meldeschluesse: JSON.parse(t.registrationDeadlines || '[]'),
+        entryFees: JSON.parse(t.entryFees || '{}'),
+        competitions,
+      },
+      participation: entries.map(e => ({
+        id: e.id,
+        tournamentId: e.tournamentId,
+        competitionId: e.competitionId,
+        memberId: e.memberId,
+        wants: !!e.wants,
+        registered: !!e.registered,
+        participated: !!e.participated,
+        placement: e.placement || null,
+      })),
+    });
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to fetch parsed tournament' });
+  }
+};
+
+export const upsertCompetitionMember = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, id } = req.params; // id = tournamentId
+    await checkAccess(userToken, clubId);
+    const { competitionId, memberId, wants, registered, participated, placement } = req.body;
+    if (!competitionId || !memberId) return res.status(400).json({ error: 'competitionId and memberId required' });
+    const [row] = await OfficialCompetitionMember.findOrCreate({
+      where: { competitionId, memberId },
+      defaults: {
+        tournamentId: id,
+        competitionId,
+        memberId,
+        wants: !!wants,
+        registered: !!registered,
+        participated: !!participated,
+        placement: placement || null,
+      }
+    });
+    row.wants = wants !== undefined ? !!wants : row.wants;
+    row.registered = registered !== undefined ? !!registered : row.registered;
+    row.participated = participated !== undefined ? !!participated : row.participated;
+    if (placement !== undefined) row.placement = placement;
+    await row.save();
+    return res.status(200).json({ success: true, id: row.id });
+  } catch (e) {
+    console.error('[upsertCompetitionMember] Error:', e);
+    res.status(500).json({ error: 'Failed to save participation' });
+  }
+};
+
+export const updateParticipantStatus = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, id } = req.params; // id = tournamentId
+    await checkAccess(userToken, clubId);
+    const { competitionId, memberId, action } = req.body;
+    
+    if (!competitionId || !memberId || !action) {
+      return res.status(400).json({ error: 'competitionId, memberId and action required' });
+    }
+
+    const [row] = await OfficialCompetitionMember.findOrCreate({
+      where: { competitionId, memberId },
+      defaults: {
+        tournamentId: id,
+        competitionId,
+        memberId,
+        wants: false,
+        registered: false,
+        participated: false,
+        placement: null,
+      }
+    });
+
+    // Status-Update basierend auf Aktion
+    switch (action) {
+      case 'register':
+        // Von "möchte teilnehmen" zu "angemeldet"
+        row.wants = true;
+        row.registered = true;
+        row.participated = false;
+        break;
+      case 'participate':
+        // Von "angemeldet" zu "hat gespielt"
+        row.wants = true;
+        row.registered = true;
+        row.participated = true;
+        break;
+      case 'reset':
+        // Zurück zu "möchte teilnehmen"
+        row.wants = true;
+        row.registered = false;
+        row.participated = false;
+        break;
+      default:
+        return res.status(400).json({ error: 'Invalid action. Use: register, participate, or reset' });
+    }
+
+    await row.save();
+    return res.status(200).json({ 
+      success: true, 
+      id: row.id,
+      status: {
+        wants: row.wants,
+        registered: row.registered,
+        participated: row.participated,
+        placement: row.placement
+      }
+    });
+  } catch (e) {
+    console.error('[updateParticipantStatus] Error:', e);
+    res.status(500).json({ error: 'Failed to update participant status' });
+  }
+};
+
+export const listOfficialTournaments = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId } = req.params;
+    await checkAccess(userToken, clubId);
+    const list = await OfficialTournament.findAll({ where: { clubId } });
+    res.status(200).json(list);
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to list tournaments' });
+  }
+};
+
+export const listClubParticipations = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId } = req.params;
+    await checkAccess(userToken, clubId);
+    const tournaments = await OfficialTournament.findAll({ where: { clubId } });
+    if (!tournaments || tournaments.length === 0) return res.status(200).json([]);
+    const tournamentIds = tournaments.map(t => t.id);
+
+    const rows = await OfficialCompetitionMember.findAll({
+      where: { tournamentId: { [Op.in]: tournamentIds }, participated: true },
+      include: [
+        { model: OfficialCompetition, as: 'competition', attributes: ['id', 'tournamentId', 'ageClassCompetition', 'startTime'] },
+        { model: OfficialTournament, as: 'tournament', attributes: ['id', 'title', 'eventDate'] },
+        { model: Member, as: 'member', attributes: ['id', 'firstName', 'lastName'] },
+      ]
+    });
+
+    const parseDmy = (s) => {
+      if (!s) return null;
+      const m = String(s).match(/(\d{1,2})\.(\d{1,2})\.(\d{4})/);
+      if (!m) return null;
+      const d = new Date(Number(m[3]), Number(m[2]) - 1, Number(m[1]));
+      return isNaN(d.getTime()) ? null : d;
+    };
+    const fmtDmy = (d) => {
+      const dd = String(d.getDate()).padStart(2, '0');
+      const mm = String(d.getMonth() + 1).padStart(2, '0');
+      const yyyy = d.getFullYear();
+      return `${dd}.${mm}.${yyyy}`;
+    };
+
+    const byTournament = new Map();
+    for (const r of rows) {
+      const t = r.tournament;
+      const c = r.competition;
+      const m = r.member;
+      if (!t || !c || !m) continue;
+      if (!byTournament.has(t.id)) {
+        byTournament.set(t.id, {
+          tournamentId: String(t.id),
+          title: t.title || null,
+          startDate: null,
+          endDate: null,
+          entries: [],
+          _dates: [],
+          _eventDate: t.eventDate || null,
+        });
+      }
+      const bucket = byTournament.get(t.id);
+      const compDate = parseDmy(c.startTime || '') || null;
+      if (compDate) bucket._dates.push(compDate);
+      bucket.entries.push({
+        memberId: m.id,
+        memberName: `${m.firstName || ''} ${m.lastName || ''}`.trim(),
+        competitionId: c.id,
+        competitionName: c.ageClassCompetition || '',
+        placement: r.placement || null,
+        date: compDate ? fmtDmy(compDate) : null,
+      });
+    }
+
+    const out = [];
+    for (const t of tournaments) {
+      const bucket = byTournament.get(t.id) || {
+        tournamentId: String(t.id),
+        title: t.title || null,
+        startDate: null,
+        endDate: null,
+        entries: [],
+        _dates: [],
+        _eventDate: t.eventDate || null,
+      };
+      // Ableiten Start/Ende
+      if (bucket._dates.length) {
+        bucket._dates.sort((a, b) => a - b);
+        bucket.startDate = fmtDmy(bucket._dates[0]);
+        bucket.endDate = fmtDmy(bucket._dates[bucket._dates.length - 1]);
+      } else if (bucket._eventDate) {
+        const all = String(bucket._eventDate).match(/(\d{1,2}\.\d{1,2}\.\d{4})/g) || [];
+        if (all.length >= 1) {
+          const d1 = parseDmy(all[0]);
+          const d2 = all.length >= 2 ? parseDmy(all[1]) : d1;
+          if (d1) bucket.startDate = fmtDmy(d1);
+          if (d2) bucket.endDate = fmtDmy(d2);
+        }
+      }
+      // Sort entries: Mitglied, dann Konkurrenz
+      bucket.entries.sort((a, b) => {
+        const mcmp = (a.memberName || '').localeCompare(b.memberName || '', 'de', { sensitivity: 'base' });
+        if (mcmp !== 0) return mcmp;
+        return (a.competitionName || '').localeCompare(b.competitionName || '', 'de', { sensitivity: 'base' });
+      });
+      delete bucket._dates;
+      delete bucket._eventDate;
+      out.push(bucket);
+    }
+
+    res.status(200).json(out);
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to list club participations' });
+  }
+};
+
+export const deleteOfficialTournament = async (req, res) => {
+  try {
+    const { authcode: userToken } = req.headers;
+    const { clubId, id } = req.params;
+    await checkAccess(userToken, clubId);
+    const t = await OfficialTournament.findOne({ where: { id, clubId } });
+    if (!t) return res.status(404).json({ error: 'not found' });
+    await OfficialCompetition.destroy({ where: { tournamentId: id } });
+    await OfficialTournament.destroy({ where: { id } });
+    res.status(204).send();
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to delete tournament' });
+  }
+};
+
+function parseTournamentText(text) {
+  const lines = text.split(/\r?\n/);
+  const normLines = lines.map(l => l.replace(/\s+/g, ' ').trim());
+
+  const findTitle = () => {
+    const idx = normLines.findIndex(l => /Kreiseinzelmeisterschaften/i.test(l));
+    return idx >= 0 ? normLines[idx] : null;
+  };
+
+  // Neue Funktion: Teilnahmegebühren pro Spielklasse extrahieren
+  const extractEntryFees = () => {
+    const entryFees = {};
+    
+    // Verschiedene Patterns für Teilnahmegebühren suchen
+    const feePatterns = [
+      // Pattern 1: "Startgeld: U12: 5€, U14: 7€, U16: 10€"
+      /startgeld\s*:?\s*(.+)/i,
+      // Pattern 2: "Teilnahmegebühr: U12: 5€, U14: 7€"
+      /teilnahmegebühr\s*:?\s*(.+)/i,
+      // Pattern 3: "Gebühr: U12: 5€, U14: 7€"
+      /gebühr\s*:?\s*(.+)/i,
+      // Pattern 4: "Einschreibegebühr: U12: 5€, U14: 7€"
+      /einschreibegebühr\s*:?\s*(.+)/i,
+      // Pattern 5: "Anmeldegebühr: U12: 5€, U14: 7€"
+      /anmeldegebühr\s*:?\s*(.+)/i
+    ];
+
+    for (const pattern of feePatterns) {
+      for (let i = 0; i < normLines.length; i++) {
+        const line = normLines[i];
+        const match = line.match(pattern);
+        if (match) {
+          const feeText = match[1];
+          
+          // Extrahiere Gebühren aus dem Text
+          // Unterstützt verschiedene Formate:
+          // "U12: 5€, U14: 7€, U16: 10€"
+          // "U12: 5 Euro, U14: 7 Euro"
+          // "U12 5€, U14 7€"
+          // "U12: 5,00€, U14: 7,00€"
+          const feeMatches = feeText.matchAll(/(U\d+|AK\s*\d+)\s*:?\s*(\d+(?:[,.]\d+)?)\s*(?:€|Euro|EUR)?/gi);
+          
+          for (const feeMatch of feeMatches) {
+            const ageClass = feeMatch[1].toUpperCase().replace(/\s+/g, '');
+            const amount = feeMatch[2].replace(',', '.');
+            const numericAmount = parseFloat(amount);
+            
+            if (!isNaN(numericAmount)) {
+              entryFees[ageClass] = {
+                amount: numericAmount,
+                currency: '€',
+                rawText: feeMatch[0]
+              };
+            }
+          }
+          
+          // Wenn wir Gebühren gefunden haben, brechen wir ab
+          if (Object.keys(entryFees).length > 0) {
+            break;
+          }
+        }
+      }
+      if (Object.keys(entryFees).length > 0) {
+        break;
+      }
+    }
+
+    return entryFees;
+  };
+
+  const extractBlockAfter = (labels, multiline = false) => {
+    const idx = normLines.findIndex(l => labels.some(lb => l.toLowerCase().startsWith(lb)));
+    if (idx === -1) return multiline ? [] : null;
+    const line = normLines[idx];
+    const afterColon = line.includes(':') ? line.split(':').slice(1).join(':').trim() : '';
+    if (!multiline) {
+      if (afterColon) return afterColon;
+      // sonst nächste nicht-leere Zeile
+      for (let i = idx + 1; i < normLines.length; i++) {
+        if (normLines[i]) return normLines[i];
+      }
+      return null;
+    }
+    // multiline bis zur nächsten Leerzeile oder nächsten bekannten Section
+    const out = [];
+    if (afterColon) out.push(afterColon);
+    for (let i = idx + 1; i < normLines.length; i++) {
+      const ln = normLines[i];
+      if (!ln) break;
+      if (/^(termin|austragungsort|austragungsorte|konkurrenz|konkurrenzen|konkurrenztypen|meldeschluss|altersklassen|startzeiten)/i.test(ln)) break;
+      out.push(ln);
+    }
+    return out;
+  };
+
+  const extractAllMatches = (regex) => {
+    const results = [];
+    for (const l of normLines) {
+      const m = l.match(regex);
+      if (m) results.push(m);
+    }
+    return results;
+  };
+
+  const title = findTitle();
+  const termin = extractBlockAfter(['termin', 'termin '], false);
+  const austragungsorte = extractBlockAfter(['austragungsort', 'austragungsorte'], true);
+  let konkurrenzRaw = extractBlockAfter(['konkurrenz', 'konkurrenzen', 'konkurrenztypen'], true);
+  if (konkurrenzRaw && !Array.isArray(konkurrenzRaw)) konkurrenzRaw = [konkurrenzRaw];
+  const konkurrenztypen = (konkurrenzRaw || []).flatMap(l => l.split(/[;,]/)).map(s => s.trim()).filter(Boolean);
+
+  // Meldeschlüsse mit Position und Zuordnung zu AK ermitteln
+  const meldeschluesseRaw = [];
+  for (let i = 0; i < normLines.length; i++) {
+    const l = normLines[i];
+    const m = l.match(/meldeschluss\s*:?\s*(.+)$/i);
+    if (m) meldeschluesseRaw.push({ line: i, value: m[1].trim() });
+  }
+
+  let altersRaw = extractBlockAfter(['altersklassen', 'altersklasse'], true);
+  if (altersRaw && !Array.isArray(altersRaw)) altersRaw = [altersRaw];
+  const altersklassen = (altersRaw || []).flatMap(l => l.split(/[;,]/)).map(s => s.trim()).filter(Boolean);
+
+  // Wettbewerbe/Konkurrenzen parsen (Block ab "3. Konkurrenzen")
+  const competitions = [];
+  const konkIdx = normLines.findIndex(l => /^\s*3\.?\s+Konkurrenzen/i.test(l) || /^Konkurrenzen\b/i.test(l));
+  // Bestimme Start-Sektionsnummer (z. B. 3 bei "3. Konkurrenzen"), fallback 3
+  const startSectionNum = (() => {
+    if (konkIdx === -1) return 3;
+    const m = normLines[konkIdx].match(/^\s*(\d+)\./);
+    return m ? parseInt(m[1], 10) : 3;
+  })();
+  const nextSectionIdx = () => {
+    for (let i = konkIdx + 1; i < normLines.length; i++) {
+      const m = normLines[i].match(/^\s*(\d+)\.\s+/);
+      if (m) {
+        const num = parseInt(m[1], 10);
+        if (!Number.isNaN(num) && num > startSectionNum) return i;
+      }
+      // Hinweis: Seitenfußzeilen wie "nu.Dokument ..." ignorieren wir, damit mehrseitige Blöcke nicht abbrechen
+    }
+    return normLines.length;
+  };
+  if (konkIdx !== -1) {
+    const endIdx = nextSectionIdx();
+    let i = konkIdx + 1;
+    while (i < endIdx) {
+      const line = normLines[i];
+      if (/^Altersklasse\/Wettbewerb\s*:/i.test(line)) {
+        const comp = {};
+        comp.altersklasseWettbewerb = line.split(':').slice(1).join(':').trim();
+        i++;
+        while (i < endIdx && !/^Altersklasse\/Wettbewerb\s*:/i.test(normLines[i])) {
+          const ln = normLines[i];
+          const m = ln.match(/^([^:]+):\s*(.*)$/);
+          if (m) {
+            const key = m[1].trim().toLowerCase();
+            const val = m[2].trim();
+            if (key.startsWith('leistungsklasse')) comp.leistungsklasse = val;
+            else if (key === 'startzeit') {
+              // Erwartet: 20.09.2025 13:30 Uhr -> wir extrahieren Datum+Zeit
+              const sm = val.match(/(\d{2}\.\d{2}\.\d{4})\s+(\d{1,2}:\d{2})/);
+              comp.startzeit = sm ? `${sm[1]} ${sm[2]}` : val;
+            }
+            else if (key.startsWith('meldeschluss datum')) comp.meldeschlussDatum = val;
+            else if (key.startsWith('meldeschluss online')) comp.meldeschlussOnline = val;
+            else if (key === 'stichtag') comp.stichtag = val;
+            else if (key === 'ttr-relevant') comp.ttrRelevant = val;
+            else if (key === 'offen für') comp.offenFuer = val;
+            else if (key.startsWith('austragungssys. vorrunde')) comp.vorrunde = val;
+            else if (key.startsWith('austragungssys. endrunde')) comp.endrunde = val;
+            else if (key.startsWith('max. teilnehmerzahl')) comp.maxTeilnehmer = val;
+            else if (key === 'startgeld') {
+              comp.startgeld = val;
+              // Versuche auch spezifische Gebühren für diese Altersklasse zu extrahieren
+              const ageClassMatch = comp.altersklasseWettbewerb?.match(/(U\d+|AK\s*\d+)/i);
+              if (ageClassMatch) {
+                const ageClass = ageClassMatch[1].toUpperCase().replace(/\s+/g, '');
+                const feeMatch = val.match(/(\d+(?:[,.]\d+)?)\s*(?:€|Euro|EUR)?/);
+                if (feeMatch) {
+                  const amount = feeMatch[1].replace(',', '.');
+                  const numericAmount = parseFloat(amount);
+                  if (!isNaN(numericAmount)) {
+                    comp.entryFeeDetails = {
+                      amount: numericAmount,
+                      currency: '€',
+                      ageClass: ageClass
+                    };
+                  }
+                }
+              }
+            }
+          }
+          i++;
+        }
+        competitions.push(comp);
+        continue; // schon auf nächster Zeile
+      }
+      i++;
+    }
+  }
+
+  // Altersklassen-Positionen im Text (zur Zuordnung von Meldeschlüssen)
+  const akPositions = [];
+  for (let i = 0; i < normLines.length; i++) {
+    const l = normLines[i];
+    const m = l.match(/\b(U\d+|AK\s*\d+)\b/i);
+    if (m) akPositions.push({ line: i, ak: m[1].toUpperCase().replace(/\s+/g, '') });
+  }
+
+  const meldeschluesseByAk = {};
+  for (const ms of meldeschluesseRaw) {
+    // Nächste AK im Umkreis von 3 Zeilen suchen
+    let best = null;
+    let bestDist = Infinity;
+    for (const ak of akPositions) {
+      const dist = Math.abs(ak.line - ms.line);
+      if (dist < bestDist && dist <= 3) { best = ak; bestDist = dist; }
+    }
+    if (best) {
+      if (!meldeschluesseByAk[best.ak]) meldeschluesseByAk[best.ak] = new Set();
+      meldeschluesseByAk[best.ak].add(ms.value);
+    }
+  }
+
+  // Dedup global
+  const meldeschluesse = Array.from(new Set(meldeschluesseRaw.map(x => x.value)));
+  // Sets zu Arrays
+  const meldeschluesseByAkOut = Object.fromEntries(Object.entries(meldeschluesseByAk).map(([k,v]) => [k, Array.from(v)]));
+
+  // Vorhandene einfache Personenerkennung (optional, zu Analysezwecken)
+  const entries = [];
+  for (const l of normLines) {
+    const m = l.match(/^([A-Za-zÄÖÜäöüß\-\s']{3,})(?:\s+\((m|w|d)\))?$/i);
+    if (m && /\s/.test(m[1])) {
+      entries.push({ name: m[1].trim(), genderHint: m[2] || null });
+    }
+  }
+
+  // Extrahiere Teilnahmegebühren
+  const entryFees = extractEntryFees();
+
+  return {
+    title,
+    termin,
+    austragungsorte,
+    konkurrenztypen,
+    meldeschluesse,
+    meldeschluesseByAk: meldeschluesseByAkOut,
+    altersklassen,
+    startzeiten: {},
+    competitions,
+    entries,
+    entryFees, // Neue: Teilnahmegebühren pro Spielklasse
+    debug: { normLines },
+  };
+}
+
+

backend/controllers/participantController.js

@@ -1,23 +1,53 @@
 import Participant from '../models/Participant.js';
 
+import { devLog } from '../utils/logger.js';
 export const getParticipants = async (req, res) => {
     try {
         const { dateId } = req.params;
-        const participants = await Participant.findAll({ where: { diaryDateId: dateId } });
+        const participants = await Participant.findAll({ 
+            where: { diaryDateId: dateId },
+            attributes: ['id', 'diaryDateId', 'memberId', 'groupId', 'notes', 'createdAt', 'updatedAt']
+        });
         res.status(200).json(participants);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Abrufen der Teilnehmer' });
     }
 };
 
+export const updateParticipantGroup = async (req, res) => {
+    try {
+        const { dateId, memberId } = req.params;
+        const { groupId } = req.body;
+        
+        const participant = await Participant.findOne({
+            where: { 
+                diaryDateId: dateId,
+                memberId: memberId
+            }
+        });
+        
+        if (!participant) {
+            return res.status(404).json({ error: 'Teilnehmer nicht gefunden' });
+        }
+        
+        participant.groupId = groupId || null;
+        await participant.save();
+        
+        res.status(200).json(participant);
+    } catch (error) {
+        devLog(error);
+        res.status(500).json({ error: 'Fehler beim Aktualisieren der Teilnehmer-Gruppenzuordnung' });
+    }
+};
+
 export const addParticipant = async (req, res) => {
     try {
         const { diaryDateId, memberId } = req.body;
         const participant = await Participant.create({ diaryDateId, memberId });
         res.status(201).json(participant);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Hinzufügen des Teilnehmers' });
     }
 };
@@ -28,7 +58,7 @@ export const removeParticipant = async (req, res) => {
         await Participant.destroy({ where: { diaryDateId, memberId } });
         res.status(200).json({ message: 'Teilnehmer entfernt' });
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Entfernen des Teilnehmers' });
     }
 };

backend/controllers/permissionController.js

@@ -0,0 +1,167 @@
+import permissionService from '../services/permissionService.js';
+
+/**
+ * Get user's permissions for a club
+ */
+export const getUserPermissions = async (req, res) => {
+  try {
+    const { clubId } = req.params;
+    const userId = req.user.id;
+
+    // Validierung: clubId muss eine gültige Zahl sein
+    const parsedClubId = parseInt(clubId, 10);
+    if (isNaN(parsedClubId) || parsedClubId <= 0) {
+      return res.status(400).json({ error: 'Ungültige Club-ID' });
+    }
+
+    const permissions = await permissionService.getUserClubPermissions(userId, parsedClubId);
+
+    if (!permissions) {
+      return res.status(404).json({ error: 'Keine Berechtigungen gefunden' });
+    }
+
+    res.json(permissions);
+  } catch (error) {
+    console.error('Error getting user permissions:', error);
+    res.status(500).json({ error: 'Fehler beim Abrufen der Berechtigungen' });
+  }
+};
+
+/**
+ * Get all club members with their permissions
+ */
+export const getClubMembersWithPermissions = async (req, res) => {
+  try {
+    const { clubId } = req.params;
+    const userId = req.user.id;
+
+    const members = await permissionService.getClubMembersWithPermissions(
+      parseInt(clubId),
+      userId
+    );
+
+    res.json(members);
+  } catch (error) {
+    console.error('Error getting club members with permissions:', error);
+    if (error.message === 'Keine Berechtigung zum Anzeigen von Berechtigungen') {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(500).json({ error: 'Fehler beim Abrufen der Mitglieder' });
+  }
+};
+
+/**
+ * Update user role
+ */
+export const updateUserRole = async (req, res) => {
+  try {
+    const { clubId, userId: targetUserId } = req.params;
+    const { role } = req.body;
+    const updatingUserId = req.user.id;
+
+    const result = await permissionService.setUserRole(
+      parseInt(targetUserId),
+      parseInt(clubId),
+      role,
+      updatingUserId
+    );
+
+    res.json(result);
+  } catch (error) {
+    console.error('Error updating user role:', error);
+    if (error.message && error.message.toLowerCase().includes('keine berechtigung')) {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(400).json({ error: error.message });
+  }
+};
+
+/**
+ * Update user custom permissions
+ */
+export const updateUserPermissions = async (req, res) => {
+  try {
+    const { clubId, userId: targetUserId } = req.params;
+    const { permissions } = req.body;
+    const updatingUserId = req.user.id;
+
+    const result = await permissionService.setCustomPermissions(
+      parseInt(targetUserId),
+      parseInt(clubId),
+      permissions,
+      updatingUserId
+    );
+
+    res.json(result);
+  } catch (error) {
+    console.error('Error updating user permissions:', error);
+    if (error.message && error.message.toLowerCase().includes('keine berechtigung')) {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(400).json({ error: error.message });
+  }
+};
+
+/**
+ * Get available roles
+ */
+export const getAvailableRoles = async (req, res) => {
+  try {
+    const roles = permissionService.getAvailableRoles();
+    res.json(roles);
+  } catch (error) {
+    console.error('Error getting available roles:', error);
+    res.status(500).json({ error: 'Fehler beim Abrufen der Rollen' });
+  }
+};
+
+/**
+ * Get permission structure
+ */
+export const getPermissionStructure = async (req, res) => {
+  try {
+    const structure = permissionService.getPermissionStructure();
+    res.json(structure);
+  } catch (error) {
+    console.error('Error getting permission structure:', error);
+    res.status(500).json({ error: 'Fehler beim Abrufen der Berechtigungsstruktur' });
+  }
+};
+
+/**
+ * Update user status (activate/deactivate)
+ */
+export const updateUserStatus = async (req, res) => {
+  try {
+    const { clubId, userId: targetUserId } = req.params;
+    const { approved } = req.body;
+    const updatingUserId = req.user.id;
+
+    const result = await permissionService.setUserStatus(
+      parseInt(targetUserId),
+      parseInt(clubId),
+      approved,
+      updatingUserId
+    );
+
+    res.json(result);
+  } catch (error) {
+    console.error('Error updating user status:', error);
+    if (error.message && error.message.toLowerCase().includes('keine berechtigung')) {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(400).json({ error: error.message });
+  }
+};
+
+export default {
+  getUserPermissions,
+  getClubMembersWithPermissions,
+  updateUserRole,
+  updateUserPermissions,
+  updateUserStatus,
+  getAvailableRoles,
+  getPermissionStructure
+};
+
+

backend/controllers/predefinedActivityController.js

@@ -1,9 +1,12 @@
 import predefinedActivityService from '../services/predefinedActivityService.js';
+import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
+import path from 'path';
+import fs from 'fs';
 
 export const createPredefinedActivity = async (req, res) => {
     try {
-        const { name, description, durationText, duration } = req.body;
-        const predefinedActivity = await predefinedActivityService.createPredefinedActivity({ name, description, durationText, duration });
+        const { name, code, description, durationText, duration, imageLink, drawingData } = req.body;
+        const predefinedActivity = await predefinedActivityService.createPredefinedActivity({ name, code, description, durationText, duration, imageLink, drawingData });
         res.status(201).json(predefinedActivity);
     } catch (error) {
         console.error('[createPredefinedActivity] - Error:', error);
@@ -25,10 +28,11 @@ export const getPredefinedActivityById = async (req, res) => {
     try {
         const { id } = req.params;
         const predefinedActivity = await predefinedActivityService.getPredefinedActivityById(id);
+        const images = await PredefinedActivityImage.findAll({ where: { predefinedActivityId: id } });
         if (!predefinedActivity) {
             return res.status(404).json({ error: 'Predefined activity not found' });
         }
-        res.status(200).json(predefinedActivity);
+        res.status(200).json({ ...predefinedActivity.toJSON(), images });
     } catch (error) {
         console.error('[getPredefinedActivityById] - Error:', error);
         res.status(500).json({ error: 'Error fetching predefined activity' });
@@ -38,11 +42,43 @@ export const getPredefinedActivityById = async (req, res) => {
 export const updatePredefinedActivity = async (req, res) => {
     try {
         const { id } = req.params;
-        const { name, description, durationText, duration } = req.body;
-        const updatedActivity = await predefinedActivityService.updatePredefinedActivity(id, { name, description, durationText, duration });
+        const { name, code, description, durationText, duration, imageLink, drawingData } = req.body;
+        const updatedActivity = await predefinedActivityService.updatePredefinedActivity(id, { name, code, description, durationText, duration, imageLink, drawingData });
         res.status(200).json(updatedActivity);
     } catch (error) {
         console.error('[updatePredefinedActivity] - Error:', error);
         res.status(500).json({ error: 'Error updating predefined activity' });
     }
 };
+
+export const searchPredefinedActivities = async (req, res) => {
+    try {
+        const { q, limit } = req.query;
+        const result = await predefinedActivityService.searchPredefinedActivities(q, limit);
+        res.status(200).json(result);
+    } catch (error) {
+        console.error('[searchPredefinedActivities] - Error:', error);
+        res.status(500).json({ error: 'Error searching predefined activities' });
+    }
+};
+
+export const mergePredefinedActivities = async (req, res) => {
+    try {
+        const { sourceId, targetId } = req.body;
+        await predefinedActivityService.mergeActivities(sourceId, targetId);
+        res.status(200).json({ ok: true });
+    } catch (error) {
+        console.error('[mergePredefinedActivities] - Error:', error);
+        res.status(500).json({ error: 'Error merging predefined activities' });
+    }
+};
+
+export const deduplicatePredefinedActivities = async (req, res) => {
+    try {
+        const result = await predefinedActivityService.deduplicateActivities();
+        res.status(200).json(result);
+    } catch (error) {
+        console.error('[deduplicatePredefinedActivities] - Error:', error);
+        res.status(500).json({ error: 'Error deduplicating predefined activities' });
+    }
+};

backend/controllers/predefinedActivityImageController.js

@@ -0,0 +1,97 @@
+import PredefinedActivity from '../models/PredefinedActivity.js';
+import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
+import { checkGlobalAccess } from '../utils/userUtils.js';
+import path from 'path';
+import fs from 'fs';
+import sharp from 'sharp';
+
+import { devLog } from '../utils/logger.js';
+export const uploadPredefinedActivityImage = async (req, res) => {
+  try {
+    const { id } = req.params; // predefinedActivityId
+    const { authcode: userToken } = req.headers;
+    await checkGlobalAccess(userToken); // Predefined Activities sind global, keine Club-Zugriffskontrolle nötig
+
+    const activity = await PredefinedActivity.findByPk(id);
+    if (!activity) {
+      return res.status(404).json({ error: 'Predefined activity not found' });
+    }
+
+    if (!req.file || !req.file.buffer) {
+      return res.status(400).json({ error: 'No image uploaded' });
+    }
+
+    const imagesDir = path.join('images', 'predefined');
+    if (!fs.existsSync(imagesDir)) {
+      fs.mkdirSync(imagesDir, { recursive: true });
+    }
+
+    const fileName = `${id}-${Date.now()}.jpg`;
+    const filePath = path.join(imagesDir, fileName);
+
+    await sharp(req.file.buffer)
+      .resize(800, 800, { fit: 'inside' })
+      .jpeg({ quality: 85 })
+      .toFile(filePath);
+
+    // Extrahiere Zeichnungsdaten aus dem Request
+    const drawingData = req.body.drawingData ? JSON.parse(req.body.drawingData) : null;
+
+    const imageRecord = await PredefinedActivityImage.create({
+      predefinedActivityId: id,
+      imagePath: filePath,
+      mimeType: 'image/jpeg',
+      drawingData: drawingData ? JSON.stringify(drawingData) : null,
+    });
+
+    // Optional: als imageLink am Activity-Datensatz setzen
+    activity.imageLink = `/api/predefined-activities/${id}/image/${imageRecord.id}`;
+    await activity.save();
+
+    res.status(201).json({ id: imageRecord.id, imageLink: activity.imageLink });
+  } catch (error) {
+    console.error('[uploadPredefinedActivityImage] - Error:', error);
+    res.status(500).json({ error: 'Failed to upload image' });
+  }
+};
+
+export const deletePredefinedActivityImage = async (req, res) => {
+  try {
+    const { id, imageId } = req.params; // predefinedActivityId, imageId
+    const { authcode: userToken } = req.headers;
+    await checkGlobalAccess(userToken);
+
+    const activity = await PredefinedActivity.findByPk(id);
+    if (!activity) {
+      return res.status(404).json({ error: 'Predefined activity not found' });
+    }
+
+    const image = await PredefinedActivityImage.findOne({ 
+      where: { id: imageId, predefinedActivityId: id } 
+    });
+    if (!image) {
+      return res.status(404).json({ error: 'Image not found' });
+    }
+
+    // Datei vom Dateisystem löschen
+    if (fs.existsSync(image.imagePath)) {
+      fs.unlinkSync(image.imagePath);
+    }
+
+    // Datensatz aus der Datenbank löschen
+    await image.destroy();
+
+    // Falls das gelöschte Bild der aktuelle imageLink war, diesen zurücksetzen
+    if (activity.imageLink === `/api/predefined-activities/${id}/image/${imageId}`) {
+      activity.imageLink = null;
+      await activity.save();
+    }
+
+    res.status(200).json({ message: 'Image deleted successfully' });
+  } catch (error) {
+    console.error('[deletePredefinedActivityImage] - Error:', error);
+    res.status(500).json({ error: 'Failed to delete image' });
+  }
+};
+
+

backend/controllers/seasonController.js

@@ -0,0 +1,103 @@
+import SeasonService from '../services/seasonService.js';
+import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
+
+export const getSeasons = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const user = await getUserByToken(token);
+    
+    const seasons = await SeasonService.getAllSeasons();
+    
+    res.status(200).json(seasons);
+  } catch (error) {
+    console.error('[getSeasons] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const getCurrentSeason = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const user = await getUserByToken(token);
+    
+    const season = await SeasonService.getOrCreateCurrentSeason();
+    
+    res.status(200).json(season);
+  } catch (error) {
+    console.error('[getCurrentSeason] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const createSeason = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { season } = req.body;
+    
+    const user = await getUserByToken(token);
+    
+    if (!season) {
+      return res.status(400).json({ error: "missingseason" });
+    }
+    
+    // Validiere Saison-Format (z.B. "2023/2024")
+    const seasonRegex = /^\d{4}\/\d{4}$/;
+    if (!seasonRegex.test(season)) {
+      return res.status(400).json({ error: "invalidseasonformat" });
+    }
+    
+    const newSeason = await SeasonService.createSeason(season);
+    
+    res.status(201).json(newSeason);
+  } catch (error) {
+    console.error('[createSeason] - Error:', error);
+    if (error.message === 'Season already exists') {
+      res.status(409).json({ error: "alreadyexists" });
+    } else {
+      res.status(500).json({ error: "internalerror" });
+    }
+  }
+};
+
+export const getSeason = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { seasonid: seasonId } = req.params;
+    
+    const user = await getUserByToken(token);
+    
+    const season = await SeasonService.getSeasonById(seasonId);
+    if (!season) {
+      return res.status(404).json({ error: "notfound" });
+    }
+    
+    res.status(200).json(season);
+  } catch (error) {
+    console.error('[getSeason] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const deleteSeason = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { seasonid: seasonId } = req.params;
+    
+    const user = await getUserByToken(token);
+    
+    const success = await SeasonService.deleteSeason(seasonId);
+    if (!success) {
+      return res.status(404).json({ error: "notfound" });
+    }
+    
+    res.status(200).json({ message: "deleted" });
+  } catch (error) {
+    console.error('[deleteSeason] - Error:', error);
+    if (error.message === 'Season is used by teams' || error.message === 'Season is used by leagues') {
+      res.status(409).json({ error: "seasoninuse" });
+    } else {
+      res.status(500).json({ error: "internalerror" });
+    }
+  }
+};

backend/controllers/teamController.js

@@ -0,0 +1,130 @@
+import TeamService from '../services/teamService.js';
+import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
+
+export const getTeams = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { clubid: clubId } = req.params;
+    const { seasonid: seasonId } = req.query;
+    
+    const user = await getUserByToken(token);
+    
+    // Check if user has access to this club
+    const teams = await TeamService.getAllTeamsByClub(clubId, seasonId);
+    
+    res.status(200).json(teams);
+  } catch (error) {
+    console.error('[getTeams] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const getTeam = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { teamid: teamId } = req.params;
+    
+    const user = await getUserByToken(token);
+    
+    const team = await TeamService.getTeamById(teamId);
+    if (!team) {
+      return res.status(404).json({ error: "notfound" });
+    }
+    
+    res.status(200).json(team);
+  } catch (error) {
+    console.error('[getTeam] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const createTeam = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { clubid: clubId } = req.params;
+    const { name, leagueId, seasonId } = req.body;
+    
+    const user = await getUserByToken(token);
+    
+    if (!name) {
+      return res.status(400).json({ error: "missingname" });
+    }
+    
+    const teamData = {
+      name,
+      clubId: parseInt(clubId),
+      leagueId: leagueId ? parseInt(leagueId) : null,
+      seasonId: seasonId ? parseInt(seasonId) : null
+    };
+    
+    const newTeam = await TeamService.createTeam(teamData);
+    
+    res.status(201).json(newTeam);
+  } catch (error) {
+    console.error('[createTeam] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const updateTeam = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { teamid: teamId } = req.params;
+    const { name, leagueId, seasonId } = req.body;
+    
+    const user = await getUserByToken(token);
+    
+    const updateData = {};
+    if (name !== undefined) updateData.name = name;
+    if (leagueId !== undefined) updateData.leagueId = leagueId ? parseInt(leagueId) : null;
+    if (seasonId !== undefined) updateData.seasonId = seasonId ? parseInt(seasonId) : null;
+    
+    const success = await TeamService.updateTeam(teamId, updateData);
+    if (!success) {
+      return res.status(404).json({ error: "notfound" });
+    }
+    
+    const updatedTeam = await TeamService.getTeamById(teamId);
+    res.status(200).json(updatedTeam);
+  } catch (error) {
+    console.error('[updateTeam] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const deleteTeam = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { teamid: teamId } = req.params;
+    
+    const user = await getUserByToken(token);
+    
+    const success = await TeamService.deleteTeam(teamId);
+    if (!success) {
+      return res.status(404).json({ error: "notfound" });
+    }
+    
+    res.status(200).json({ message: "deleted" });
+  } catch (error) {
+    console.error('[deleteTeam] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};
+
+export const getLeagues = async (req, res) => {
+  try {
+    const { authcode: token } = req.headers;
+    const { clubid: clubId } = req.params;
+    const { seasonid: seasonId } = req.query;
+    
+    const user = await getUserByToken(token);
+    
+    const leagues = await TeamService.getLeaguesByClub(clubId, seasonId);
+    
+    res.status(200).json(leagues);
+  } catch (error) {
+    console.error('[getLeagues] - Error:', error);
+    res.status(500).json({ error: "internalerror" });
+  }
+};

backend/controllers/teamDocumentController.js

@@ -0,0 +1,223 @@
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs';
+import TeamDocumentService from '../services/teamDocumentService.js';
+import PDFParserService from '../services/pdfParserService.js';
+import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
+
+// Multer-Konfiguration für Datei-Uploads
+const storage = multer.diskStorage({
+    destination: (req, file, cb) => {
+        try {
+            fs.mkdirSync('uploads/temp', { recursive: true });
+        } catch (mkdirError) {
+            console.error('[multer] - Failed to ensure temp upload directory exists:', mkdirError);
+        }
+        cb(null, 'uploads/temp/');
+    },
+    filename: (req, file, cb) => {
+        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+        cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
+    }
+});
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 10 * 1024 * 1024 // 10MB Limit
+    },
+    fileFilter: (req, file, cb) => {
+        // Erlaube nur PDF, DOC, DOCX, TXT, CSV Dateien
+        const allowedExtensions = ['.pdf', '.doc', '.docx', '.txt', '.csv'];
+        const allowedMimePatterns = ['pdf', 'msword', 'wordprocessingml.document', 'text/plain', 'csv', 'excel'];
+
+        const extensionValid = allowedExtensions.includes(path.extname(file.originalname).toLowerCase());
+        const mimetypeValid = allowedMimePatterns.some((pattern) => file.mimetype && file.mimetype.toLowerCase().includes(pattern));
+
+        if (extensionValid && mimetypeValid) {
+            return cb(null, true);
+        }
+
+        cb(new Error('Nur PDF, DOC, DOCX, TXT und CSV Dateien sind erlaubt!'));
+    }
+});
+
+export const uploadMiddleware = upload.single('document');
+
+export const uploadDocument = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubteamid: clubTeamId } = req.params;
+        const { documentType } = req.body;
+
+        const user = await getUserByToken(token);
+
+        if (!req.file) {
+            return res.status(400).json({ error: "nofile" });
+        }
+
+        if (!documentType || !['code_list', 'pin_list'].includes(documentType)) {
+            return res.status(400).json({ error: "invaliddocumenttype" });
+        }
+
+        const document = await TeamDocumentService.uploadDocument(req.file, clubTeamId, documentType);
+        
+        res.status(201).json(document);
+    } catch (error) {
+        console.error('[uploadDocument] - Error:', error);
+        
+        // Lösche temporäre Datei bei Fehler
+        if (req.file && req.file.path) {
+            try {
+                const fs = await import('fs');
+                fs.unlinkSync(req.file.path);
+            } catch (cleanupError) {
+                console.error('Fehler beim Löschen der temporären Datei:', cleanupError);
+            }
+        }
+
+        if (error.message === 'Club-Team nicht gefunden') {
+            return res.status(404).json({ error: "clubteamnotfound" });
+        }
+        
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const getDocuments = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { clubteamid: clubTeamId } = req.params;
+        
+        const user = await getUserByToken(token);
+        
+        const documents = await TeamDocumentService.getDocumentsByClubTeam(clubTeamId);
+        
+        res.status(200).json(documents);
+    } catch (error) {
+        console.error('[getDocuments] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const getDocument = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { documentid: documentId } = req.params;
+        
+        const user = await getUserByToken(token);
+        
+        const document = await TeamDocumentService.getDocumentById(documentId);
+        if (!document) {
+            return res.status(404).json({ error: "notfound" });
+        }
+        
+        res.status(200).json(document);
+    } catch (error) {
+        console.error('[getDocument] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const downloadDocument = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { documentid: documentId } = req.params;
+        
+        const user = await getUserByToken(token);
+        
+        const document = await TeamDocumentService.getDocumentById(documentId);
+        if (!document) {
+            return res.status(404).json({ error: "notfound" });
+        }
+
+        const filePath = await TeamDocumentService.getDocumentPath(documentId);
+        if (!filePath) {
+            return res.status(404).json({ error: "filenotfound" });
+        }
+
+        // Prüfe ob Datei existiert
+        const fs = await import('fs');
+        if (!fs.existsSync(filePath)) {
+            return res.status(404).json({ error: "filenotfound" });
+        }
+
+        // Setze Headers für Inline-Anzeige (PDF-Viewer)
+        res.setHeader('Content-Disposition', `inline; filename="${document.originalFileName}"`);
+        res.setHeader('Content-Type', document.mimeType);
+        
+        // Sende die Datei
+        res.sendFile(filePath);
+    } catch (error) {
+        console.error('[downloadDocument] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const deleteDocument = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { documentid: documentId } = req.params;
+        
+        const user = await getUserByToken(token);
+        
+        const success = await TeamDocumentService.deleteDocument(documentId);
+        if (!success) {
+            return res.status(404).json({ error: "notfound" });
+        }
+        
+        res.status(200).json({ message: "Document deleted successfully" });
+    } catch (error) {
+        console.error('[deleteDocument] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};
+
+export const parsePDF = async (req, res) => {
+    try {
+        const { authcode: token } = req.headers;
+        const { documentid: documentId } = req.params;
+        const { leagueid: leagueId } = req.query;
+        
+        const user = await getUserByToken(token);
+        
+        if (!leagueId) {
+            return res.status(400).json({ error: "missingleagueid" });
+        }
+        
+        // Hole Dokument-Informationen
+        const document = await TeamDocumentService.getDocumentById(documentId);
+        if (!document) {
+            return res.status(404).json({ error: "documentnotfound" });
+        }
+        
+        // Prüfe ob es eine PDF- oder TXT-Datei ist
+        if (!document.mimeType.includes('pdf') && !document.mimeType.includes('text/plain')) {
+            return res.status(400).json({ error: "notapdfortxt" });
+        }
+        
+        // Parse PDF
+        const parseResult = await PDFParserService.parsePDF(document.filePath, document.clubTeam.clubId);
+        
+        // Speichere Matches in Datenbank
+        const saveResult = await PDFParserService.saveMatchesToDatabase(parseResult.matches, parseInt(leagueId));
+        
+        res.status(200).json({
+            parseResult: {
+                matchesFound: parseResult.matches.length,
+                debugInfo: parseResult.debugInfo,
+                allLines: parseResult.allLines,
+                rawText: parseResult.rawText
+            },
+            saveResult: {
+                created: saveResult.created,
+                updated: saveResult.updated,
+                errors: saveResult.errors
+            }
+        });
+    } catch (error) {
+        console.error('[parsePDF] - Error:', error);
+        res.status(500).json({ error: "internalerror" });
+    }
+};

backend/controllers/tournamentController.js

@@ -0,0 +1,280 @@
+// controllers/tournamentController.js
+import tournamentService from "../services/tournamentService.js";
+
+// 1. Alle Turniere eines Vereins
+export const getTournaments = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId } = req.params;
+    try {
+        const tournaments = await tournamentService.getTournaments(token, clubId);
+        res.status(200).json(tournaments);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 2. Neues Turnier anlegen
+export const addTournament = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentName, date } = req.body;
+    try {
+        const tournament = await tournamentService.addTournament(token, clubId, tournamentName, date);
+        res.status(201).json(tournament);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 3. Teilnehmer hinzufügen
+export const addParticipant = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, participant: participantId } = req.body;
+    try {
+        await tournamentService.addParticipant(token, clubId, tournamentId, participantId);
+        const participants = await tournamentService.getParticipants(token, clubId, tournamentId);
+        res.status(200).json(participants);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 4. Teilnehmerliste abrufen
+export const getParticipants = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+        const participants = await tournamentService.getParticipants(token, clubId, tournamentId);
+        res.status(200).json(participants);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 5. Turniermodus (Gruppen/K.O.) setzen
+export const setModus = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, type, numberOfGroups, advancingPerGroup } = req.body;
+    try {
+        await tournamentService.setModus(token, clubId, tournamentId, type, numberOfGroups, advancingPerGroup);
+        res.sendStatus(204);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 6. Gruppen-Strukturen anlegen (leere Gruppen)
+export const createGroups = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+        await tournamentService.createGroups(token, clubId, tournamentId);
+        res.sendStatus(204);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 7. Teilnehmer zufällig auf Gruppen verteilen & Gruppenspiele anlegen
+export const fillGroups = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+        const updatedMembers = await tournamentService.fillGroups(token, clubId, tournamentId);
+        res.status(200).json(updatedMembers);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 8. Gruppen mit ihren Teilnehmern abfragen
+export const getGroups = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.query;
+    try {
+        const groups = await tournamentService.getGroupsWithParticipants(token, clubId, tournamentId);
+        res.status(200).json(groups);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 9. Einzelnes Turnier abrufen
+export const getTournament = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.params;
+    try {
+        const tournament = await tournamentService.getTournament(token, clubId, tournamentId);
+        res.status(200).json(tournament);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 10. Alle Spiele eines Turniers abfragen
+export const getTournamentMatches = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.params;
+    try {
+        const matches = await tournamentService.getTournamentMatches(token, clubId, tournamentId);
+        res.status(200).json(matches);
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 11. Satz-Ergebnis speichern
+export const addMatchResult = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, matchId, set, result } = req.body;
+    try {
+        await tournamentService.addMatchResult(token, clubId, tournamentId, matchId, set, result);
+        res.status(200).json({ message: "Result added successfully" });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+// 12. Spiel abschließen (Endergebnis ermitteln)
+export const finishMatch = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, matchId } = req.body;
+    try {
+        await tournamentService.finishMatch(token, clubId, tournamentId, matchId);
+        res.status(200).json({ message: "Match finished successfully" });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+export const startKnockout = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+
+    try {
+        await tournamentService.startKnockout(token, clubId, tournamentId);
+        res.status(200).json({ message: "K.o.-Runde erfolgreich gestartet" });
+    } catch (error) {
+        const status = /Gruppenmodus|Zu wenige Qualifikanten/.test(error.message) ? 400 : 500;
+        res.status(status).json({ error: error.message });
+    }
+};
+
+export const manualAssignGroups = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const {
+        clubId,
+        tournamentId,
+        assignments,     // [{ participantId, groupNumber }]
+        numberOfGroups,  // optional
+        maxGroupSize     // optional
+    } = req.body;
+
+    try {
+        const groupsWithParts = await tournamentService.manualAssignGroups(
+            token,
+            clubId,
+            tournamentId,
+            assignments,
+            numberOfGroups,  // neu
+            maxGroupSize     // neu
+        );
+        res.status(200).json(groupsWithParts);
+    } catch (error) {
+        console.error('Error in manualAssignGroups:', error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+export const resetGroups = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+        await tournamentService.resetGroups(token, clubId, tournamentId);
+        res.sendStatus(204);
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: err.message });
+    }
+};
+
+export const resetMatches = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+        await tournamentService.resetMatches(token, clubId, tournamentId);
+        res.sendStatus(204);
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: err.message });
+    }
+};
+
+export const removeParticipant = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, participantId } = req.body;
+    try {
+        await tournamentService.removeParticipant(token, clubId, tournamentId, participantId);
+        const participants = await tournamentService.getParticipants(token, clubId, tournamentId);
+        res.status(200).json(participants);
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: err.message });
+    }
+};
+
+export const deleteMatchResult = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, matchId, set } = req.body;
+    try {
+        await tournamentService.deleteMatchResult(
+            token,
+            clubId,
+            tournamentId,
+            matchId,
+            set
+        );
+        res.status(200).json({ message: 'Einzelsatz gelöscht' });
+    } catch (error) {
+        console.error('Error in deleteMatchResult:', error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+
+export const reopenMatch = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId, matchId } = req.body;
+    try {
+        await tournamentService.reopenMatch(token, clubId, tournamentId, matchId);
+        // Gib optional das aktualisierte Match zurück
+        res.status(200).json({ message: "Match reopened" });
+    } catch (error) {
+        console.error("Error in reopenMatch:", error);
+        res.status(500).json({ error: error.message });
+    }
+};
+
+export const deleteKnockoutMatches = async (req, res) => {
+    const { authcode: token } = req.headers;
+    const { clubId, tournamentId } = req.body;
+    try {
+      await tournamentService.resetKnockout(token, clubId, tournamentId);
+      res.status(200).json({ message: "K.o.-Runde gelöscht" });
+    } catch (error) {
+      console.error("Error in deleteKnockoutMatches:", error);
+      res.status(500).json({ error: error.message });
+    }
+  };
+  

backend/controllers/trainingStatsController.js

@@ -0,0 +1,176 @@
+import { DiaryDate, Member, Participant } from '../models/index.js';
+import { Op } from 'sequelize';
+
+class TrainingStatsController {
+  async getTrainingStats(req, res) {
+    try {
+      const { clubId } = req.params;
+      
+      // Aktuelle Datum für Berechnungen
+      const now = new Date();
+      const twelveMonthsAgo = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+      const threeMonthsAgo = new Date(now.getFullYear(), now.getMonth() - 3, now.getDate());
+      
+      // Alle aktiven Mitglieder des spezifischen Vereins laden
+      const members = await Member.findAll({
+        where: {
+          active: true,
+          clubId: parseInt(clubId)
+        }
+      });
+      
+      // Anzahl der Trainings im jeweiligen Zeitraum berechnen
+      const trainingsCount12Months = await DiaryDate.count({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: twelveMonthsAgo
+          }
+        }
+      });
+      
+      const trainingsCount3Months = await DiaryDate.count({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: threeMonthsAgo
+          }
+        }
+      });
+      
+      const stats = [];
+      
+      for (const member of members) {
+        // Trainingsteilnahmen der letzten 12 Monate über Participant-Model
+        const participation12Months = await Participant.count({
+          include: [{
+            model: DiaryDate,
+            as: 'diaryDate',
+            where: {
+              clubId: parseInt(clubId),
+              date: {
+                [Op.gte]: twelveMonthsAgo
+              }
+            }
+          }],
+          where: {
+            memberId: member.id
+          }
+        });
+        
+        // Trainingsteilnahmen der letzten 3 Monate über Participant-Model
+        const participation3Months = await Participant.count({
+          include: [{
+            model: DiaryDate,
+            as: 'diaryDate',
+            where: {
+              clubId: parseInt(clubId),
+              date: {
+                [Op.gte]: threeMonthsAgo
+              }
+            }
+          }],
+          where: {
+            memberId: member.id
+          }
+        });
+        
+        // Trainingsteilnahmen insgesamt über Participant-Model
+        const participationTotal = await Participant.count({
+          include: [{
+            model: DiaryDate,
+            as: 'diaryDate',
+            where: {
+              clubId: parseInt(clubId)
+            }
+          }],
+          where: {
+            memberId: member.id
+          }
+        });
+        
+        // Detaillierte Trainingsdaten (absteigend sortiert) über Participant-Model
+        const trainingDetails = await Participant.findAll({
+          include: [{
+            model: DiaryDate,
+            as: 'diaryDate',
+            where: {
+              clubId: parseInt(clubId)
+            }
+          }],
+          where: {
+            memberId: member.id
+          },
+          order: [['diaryDate', 'date', 'DESC']],
+          limit: 50 // Begrenzen auf die letzten 50 Trainingseinheiten
+        });
+        
+        // Trainingsteilnahmen für den Member formatieren
+        const formattedTrainingDetails = trainingDetails.map(participation => ({
+          id: participation.id,
+          date: participation.diaryDate.date,
+          activityName: 'Training',
+          startTime: '--:--',
+          endTime: '--:--'
+        }));
+        
+        // Letztes Training
+        const lastTrainingDate = trainingDetails.length ? trainingDetails[0].diaryDate.date : null;
+        const lastTrainingTs = lastTrainingDate ? new Date(lastTrainingDate).getTime() : 0;
+
+        stats.push({
+          id: member.id,
+          firstName: member.firstName,
+          lastName: member.lastName,
+          birthDate: member.birthDate,
+          participation12Months,
+          participation3Months,
+          participationTotal,
+          lastTraining: lastTrainingDate,
+          lastTrainingTs,
+          trainingDetails: formattedTrainingDetails
+        });
+      }
+      
+      // Nach Gesamtteilnahme absteigend sortieren
+      stats.sort((a, b) => b.participationTotal - a.participationTotal);
+      
+      // Trainingstage mit Teilnehmerzahlen abrufen (letzte 12 Monate, absteigend sortiert)
+      const trainingDays = await DiaryDate.findAll({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: twelveMonthsAgo
+          }
+        },
+        include: [{
+          model: Participant,
+          as: 'participantList',
+          attributes: ['id']
+        }],
+        order: [['date', 'DESC']]
+      });
+      
+      // Formatiere Trainingstage mit Teilnehmerzahl
+      const formattedTrainingDays = trainingDays.map(day => ({
+        id: day.id,
+        date: day.date,
+        participantCount: day.participantList ? day.participantList.length : 0
+      }));
+      
+      // Zusätzliche Metadaten mit Trainingsanzahl zurückgeben
+      res.json({
+        members: stats,
+        trainingsCount12Months,
+        trainingsCount3Months,
+        trainingDays: formattedTrainingDays
+      });
+      
+    } catch (error) {
+      console.error('Fehler beim Laden der Trainings-Statistik:', error);
+      res.status(500).json({ error: 'Fehler beim Laden der Trainings-Statistik' });
+    }
+  }
+}
+
+export default new TrainingStatsController();

backend/database.js

@@ -1,14 +1,17 @@
 import { Sequelize } from 'sequelize';
 import { development } from './config.js';
 
+
 const sequelize = new Sequelize(
-  development.database,  
+  development.database,
   development.username,
   development.password,
   {
     host: development.host,
     dialect: development.dialect,
     define: development.define,
+    logging: development.logging ?? false,
+    storage: development.storage,
   }
 );
 

backend/middleware/authMiddleware.js

@@ -1,18 +1,26 @@
-import User from '../models/User.js';
+import jwt from 'jsonwebtoken';
+import UserToken from '../models/UserToken.js';
 
 export const authenticate = async (req, res, next) => {
-    try {
-        const { userid: userId, authcode: authCode } = req.headers;
-        if (!userId || !authCode) {
-            return res.status(401).json({ error: 'Unauthorized: Missing credentials' });
-        }
-        const user = await User.findOne({ where: { email: userId, authCode: authCode } });
-        if (!user) {
-            return res.status(401).json({ error: 'Unauthorized: Invalid credentials' });
-        } 
-        next();
-    } catch(error) {
-        console.log(error);
-        return res.status(500).json({ error: 'Internal Server Error at auth' });
+  let token = req.headers['authorization']?.split(' ')[1];
+  if (!token) {
+    token = req.headers['authcode'];
+  }
+  if (!token) {
+    token = req.query?.authcode || req.query?.token || null;
+  }
+  if (!token) {
+    return res.status(401).json({ error: 'Unauthorized: Token fehlt' });
+  }
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    const tokenRecord = await UserToken.findOne({ where: { token } });
+    if (!tokenRecord || tokenRecord.expiresAt < new Date()) {
+      return res.status(401).json({ error: 'Unauthorized: Invalid credentials' });
     }
+    req.user = { id: decoded.userId };
+    next();
+  } catch (err) {
+    return res.status(401).json({ error: 'Unauthorized: Invalid credentials' });
+  }
 };

backend/middleware/authorizationMiddleware.js

@@ -0,0 +1,215 @@
+import permissionService from '../services/permissionService.js';
+
+/**
+ * Authorization Middleware
+ * Checks if user has permission to access a resource
+ */
+
+/**
+ * Check if user has permission for a specific resource and action
+ * @param {string} resource - Resource name (diary, members, teams, etc.)
+ * @param {string} action - Action type (read, write, delete)
+ * @returns {Function} Express middleware function
+ */
+export const authorize = (resource, action = 'read') => {
+  return async (req, res, next) => {
+    try {
+      const userId = req.user?.id;
+      
+      if (!userId) {
+        return res.status(401).json({ error: 'Nicht authentifiziert' });
+      }
+
+      // Get clubId from various possible sources
+      const clubId =
+        req.params.clubId ??
+        req.params.clubid ??
+        req.params.id ??
+        req.body.clubId ??
+        req.body.clubid ??
+        req.query.clubId ??
+        req.query.clubid;
+
+      if (!clubId) {
+        return res.status(400).json({ error: 'Club-ID fehlt' });
+      }
+
+      // Check permission
+      const hasPermission = await permissionService.hasPermission(
+        userId,
+        parseInt(clubId),
+        resource,
+        action
+      );
+
+      if (!hasPermission) {
+        return res.status(403).json({ 
+          error: 'Keine Berechtigung',
+          details: `Fehlende Berechtigung: ${resource}.${action}`
+        });
+      }
+
+      // Store permissions in request for later use
+      const userPermissions = await permissionService.getUserClubPermissions(
+        userId,
+        parseInt(clubId)
+      );
+      req.userPermissions = userPermissions;
+
+      next();
+    } catch (error) {
+      console.error('Authorization error:', error);
+      res.status(500).json({ error: 'Fehler bei der Berechtigungsprüfung' });
+    }
+  };
+};
+
+/**
+ * Check if user is club owner
+ * @returns {Function} Express middleware function
+ */
+export const requireOwner = () => {
+  return async (req, res, next) => {
+    try {
+      const userId = req.user?.id;
+      
+      if (!userId) {
+        return res.status(401).json({ error: 'Nicht authentifiziert' });
+      }
+
+      const clubId =
+        req.params.clubId ??
+        req.params.clubid ??
+        req.params.id ??
+        req.body.clubId ??
+        req.body.clubid ??
+        req.query.clubId ??
+        req.query.clubid;
+
+      if (!clubId) {
+        return res.status(400).json({ error: 'Club-ID fehlt' });
+      }
+
+      const userPermissions = await permissionService.getUserClubPermissions(
+        userId,
+        parseInt(clubId)
+      );
+
+      if (!userPermissions || !userPermissions.isOwner) {
+        return res.status(403).json({ 
+          error: 'Keine Berechtigung',
+          details: 'Nur der Club-Ersteller hat Zugriff'
+        });
+      }
+
+      req.userPermissions = userPermissions;
+      next();
+    } catch (error) {
+      console.error('Owner check error:', error);
+      res.status(500).json({ error: 'Fehler bei der Berechtigungsprüfung' });
+    }
+  };
+};
+
+/**
+ * Check if user is admin (owner or admin role)
+ * @returns {Function} Express middleware function
+ */
+export const requireAdmin = () => {
+  return async (req, res, next) => {
+    try {
+      const userId = req.user?.id;
+      
+      if (!userId) {
+        return res.status(401).json({ error: 'Nicht authentifiziert' });
+      }
+
+      const clubId =
+        req.params.clubId ??
+        req.params.clubid ??
+        req.params.id ??
+        req.body.clubId ??
+        req.body.clubid ??
+        req.query.clubId ??
+        req.query.clubid;
+
+      if (!clubId) {
+        return res.status(400).json({ error: 'Club-ID fehlt' });
+      }
+
+      const userPermissions = await permissionService.getUserClubPermissions(
+        userId,
+        parseInt(clubId)
+      );
+
+      if (!userPermissions || (userPermissions.role !== 'admin' && !userPermissions.isOwner)) {
+        return res.status(403).json({ 
+          error: 'Keine Berechtigung',
+          details: 'Administrator-Rechte erforderlich'
+        });
+      }
+
+      req.userPermissions = userPermissions;
+      next();
+    } catch (error) {
+      console.error('Admin check error:', error);
+      res.status(500).json({ error: 'Fehler bei der Berechtigungsprüfung' });
+    }
+  };
+};
+
+/**
+ * Check if user has any of the specified roles
+ * @param {string[]} roles - Array of allowed roles
+ * @returns {Function} Express middleware function
+ */
+export const requireRole = (roles) => {
+  return async (req, res, next) => {
+    try {
+      const userId = req.user?.id;
+      
+      if (!userId) {
+        return res.status(401).json({ error: 'Nicht authentifiziert' });
+      }
+
+      const clubId =
+        req.params.clubId ??
+        req.params.clubid ??
+        req.params.id ??
+        req.body.clubId ??
+        req.body.clubid ??
+        req.query.clubId ??
+        req.query.clubid;
+
+      if (!clubId) {
+        return res.status(400).json({ error: 'Club-ID fehlt' });
+      }
+
+      const userPermissions = await permissionService.getUserClubPermissions(
+        userId,
+        parseInt(clubId)
+      );
+
+      if (!userPermissions || !roles.includes(userPermissions.role)) {
+        return res.status(403).json({ 
+          error: 'Keine Berechtigung',
+          details: `Erforderliche Rolle: ${roles.join(', ')}`
+        });
+      }
+
+      req.userPermissions = userPermissions;
+      next();
+    } catch (error) {
+      console.error('Role check error:', error);
+      res.status(500).json({ error: 'Fehler bei der Berechtigungsprüfung' });
+    }
+  };
+};
+
+export default {
+  authorize,
+  requireOwner,
+  requireAdmin,
+  requireRole
+};
+

backend/middleware/requestLoggingMiddleware.js

@@ -0,0 +1,87 @@
+import ApiLog from '../models/ApiLog.js';
+
+/**
+ * Middleware to log all API requests and responses
+ * Should be added early in the middleware chain, but after authentication
+ */
+export const requestLoggingMiddleware = async (req, res, next) => {
+  const startTime = Date.now();
+  const originalSend = res.send;
+  
+  // Get request body (but limit size for sensitive data)
+  let requestBody = null;
+  if (req.body && Object.keys(req.body).length > 0) {
+    const bodyStr = JSON.stringify(req.body);
+    // Truncate very long bodies
+    requestBody = bodyStr.length > 10000 ? bodyStr.substring(0, 10000) + '... (truncated)' : bodyStr;
+  }
+  
+  // Capture response
+  let responseBody = null;
+  res.send = function(data) {
+    // Try to parse response as JSON
+    try {
+      const parsed = JSON.parse(data);
+      const responseStr = JSON.stringify(parsed);
+      // Truncate very long responses
+      responseBody = responseStr.length > 10000 ? responseStr.substring(0, 10000) + '... (truncated)' : responseStr;
+    } catch (e) {
+      // Not JSON, just use raw data (truncated)
+      responseBody = typeof data === 'string' ? data.substring(0, 1000) : String(data).substring(0, 1000);
+    }
+    
+    // Restore original send
+    res.send = originalSend;
+    return res.send.apply(res, arguments);
+  };
+  
+  // Log after response is sent
+  res.on('finish', async () => {
+    const executionTime = Date.now() - startTime;
+    const ipAddress = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
+    const path = req.path || req.url;
+    
+    // Nur myTischtennis-Requests loggen
+    // Skip logging for non-data endpoints (Status-Checks, Health-Checks, etc.)
+    // Exclude any endpoint containing 'status' or root paths
+    if (
+      path.includes('/status') || 
+      path === '/' || 
+      path === '/health' ||
+      path.endsWith('/status') ||
+      path.includes('/scheduler-status')
+    ) {
+      return;
+    }
+    
+    // Nur myTischtennis-Endpunkte loggen (z.B. /api/mytischtennis/*)
+    if (!path.includes('/mytischtennis')) {
+      return;
+    }
+    
+    // Get user ID if available (wird von authMiddleware gesetzt)
+    const userId = req.user?.id || null;
+    
+    try {
+      await ApiLog.create({
+        userId,
+        method: req.method,
+        path: path,
+        statusCode: res.statusCode,
+        requestBody,
+        responseBody,
+        executionTime,
+        errorMessage: res.statusCode >= 400 ? `HTTP ${res.statusCode}` : null,
+        ipAddress,
+        userAgent: req.headers['user-agent'],
+        logType: 'api_request'
+      });
+    } catch (error) {
+      // Don't let logging errors break the request
+      console.error('Error logging API request:', error);
+    }
+  });
+  
+  next();
+};
+

backend/migrations/20251111_add_member_images.sql

@@ -0,0 +1,17 @@
+-- Create table for storing multiple images per member
+CREATE TABLE IF NOT EXISTS `member_image` (
+    `id` INT NOT NULL AUTO_INCREMENT,
+    `member_id` INT NOT NULL,
+    `file_name` VARCHAR(255) NOT NULL,
+    `sort_order` INT NOT NULL DEFAULT 0,
+    `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`),
+    INDEX `idx_member_image_member_id` (`member_id`),
+    CONSTRAINT `fk_member_image_member`
+        FOREIGN KEY (`member_id`)
+        REFERENCES `member` (`id`)
+        ON DELETE CASCADE
+        ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+

backend/migrations/add_auto_update_ratings_to_my_tischtennis.sql

@@ -0,0 +1,13 @@
+-- Migration: Add auto update ratings fields to my_tischtennis table
+-- Date: 2025-01-27
+
+-- Add auto_update_ratings column
+ALTER TABLE my_tischtennis 
+ADD COLUMN auto_update_ratings BOOLEAN NOT NULL DEFAULT FALSE;
+
+-- Add last_update_ratings column
+ALTER TABLE my_tischtennis 
+ADD COLUMN last_update_ratings TIMESTAMP NULL;
+
+-- Create index for auto_update_ratings for efficient querying
+CREATE INDEX idx_my_tischtennis_auto_update_ratings ON my_tischtennis(auto_update_ratings);

backend/migrations/add_drawing_data_to_predefined_activity_images.sql

@@ -0,0 +1,11 @@
+-- Migration: Add drawing_data column to predefined_activity_images table
+-- Date: 2025-09-22
+-- Description: Adds drawing_data column to store Court Drawing Tool metadata
+
+ALTER TABLE `predefined_activity_images` 
+ADD COLUMN `drawing_data` TEXT NULL 
+COMMENT 'JSON string containing drawing metadata for Court Drawing Tool' 
+AFTER `mime_type`;
+
+-- Verify the column was added
+DESCRIBE `predefined_activity_images`;

backend/migrations/add_greeting_and_association_to_clubs.sql

@@ -0,0 +1,5 @@
+ALTER TABLE clubs
+  ADD COLUMN IF NOT EXISTS greeting_text TEXT NULL,
+  ADD COLUMN IF NOT EXISTS association_member_number VARCHAR(255) NULL;
+
+

backend/migrations/add_group_id_to_participants.sql

@@ -0,0 +1,9 @@
+-- Migration: Add group_id to participants table
+-- This allows assigning participants to groups for training organization
+
+ALTER TABLE participants
+ADD COLUMN group_id INTEGER NULL REFERENCES "group"(id) ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- Add index for better query performance
+CREATE INDEX IF NOT EXISTS idx_participants_group_id ON participants(group_id);
+

backend/migrations/add_match_result_fields.sql

@@ -0,0 +1,28 @@
+-- Migration: Add match result fields to match table
+-- Date: 2025-01-27
+-- For MariaDB
+
+-- Add myTischtennis meeting ID
+ALTER TABLE `match` 
+ADD COLUMN my_tischtennis_meeting_id VARCHAR(255) NULL UNIQUE COMMENT 'Meeting ID from myTischtennis (e.g. 15440488)';
+
+-- Add home match points
+ALTER TABLE `match` 
+ADD COLUMN home_match_points INT DEFAULT 0 NULL COMMENT 'Match points won by home team';
+
+-- Add guest match points
+ALTER TABLE `match` 
+ADD COLUMN guest_match_points INT DEFAULT 0 NULL COMMENT 'Match points won by guest team';
+
+-- Add is_completed flag
+ALTER TABLE `match` 
+ADD COLUMN is_completed BOOLEAN NOT NULL DEFAULT FALSE COMMENT 'Whether the match is completed';
+
+-- Add PDF URL
+ALTER TABLE `match` 
+ADD COLUMN pdf_url VARCHAR(512) NULL COMMENT 'PDF URL from myTischtennis';
+
+-- Create indexes
+CREATE INDEX idx_match_my_tischtennis_meeting_id ON `match`(my_tischtennis_meeting_id);
+CREATE INDEX idx_match_is_completed ON `match`(is_completed);
+

backend/migrations/add_matches_tied_to_team.sql

@@ -0,0 +1,4 @@
+-- Add matches_tied column to team table
+ALTER TABLE team
+ADD COLUMN matches_tied INTEGER NOT NULL DEFAULT 0 AFTER matches_lost;
+

backend/migrations/add_member_contact_and_postal_code.sql

@@ -0,0 +1,57 @@
+-- Add postal_code column to member table
+ALTER TABLE `member` 
+ADD COLUMN `postal_code` TEXT NULL COMMENT 'Postal code (PLZ)' AFTER `city`;
+
+-- Create member_contact table for multiple phone numbers and email addresses
+CREATE TABLE IF NOT EXISTS `member_contact` (
+  `id` INT NOT NULL AUTO_INCREMENT,
+  `member_id` INT NOT NULL,
+  `type` ENUM('phone', 'email') NOT NULL COMMENT 'Type of contact: phone or email',
+  `value` TEXT NOT NULL,
+  `is_parent` BOOLEAN NOT NULL DEFAULT FALSE COMMENT 'Whether this contact belongs to a parent',
+  `parent_name` TEXT NULL COMMENT 'Name of the parent (e.g. "Mutter", "Vater", "Elternteil 1")',
+  `is_primary` BOOLEAN NOT NULL DEFAULT FALSE COMMENT 'Whether this is the primary contact of this type',
+  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  INDEX `idx_member_id` (`member_id`),
+  INDEX `idx_type` (`type`),
+  CONSTRAINT `fk_member_contact_member` 
+    FOREIGN KEY (`member_id`) 
+    REFERENCES `member` (`id`) 
+    ON DELETE CASCADE 
+    ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- Migrate existing phone numbers from member.phone to member_contact
+INSERT INTO `member_contact` (`member_id`, `type`, `value`, `is_parent`, `parent_name`, `is_primary`, `created_at`, `updated_at`)
+SELECT 
+    `id` AS `member_id`,
+    'phone' AS `type`,
+    `phone` AS `value`,
+    FALSE AS `is_parent`,
+    NULL AS `parent_name`,
+    TRUE AS `is_primary`,
+    NOW() AS `created_at`,
+    NOW() AS `updated_at`
+FROM `member`
+WHERE `phone` IS NOT NULL 
+  AND `phone` != ''
+  AND TRIM(`phone`) != '';
+
+-- Migrate existing email addresses from member.email to member_contact
+INSERT INTO `member_contact` (`member_id`, `type`, `value`, `is_parent`, `parent_name`, `is_primary`, `created_at`, `updated_at`)
+SELECT 
+    `id` AS `member_id`,
+    'email' AS `type`,
+    `email` AS `value`,
+    FALSE AS `is_parent`,
+    NULL AS `parent_name`,
+    TRUE AS `is_primary`,
+    NOW() AS `created_at`,
+    NOW() AS `updated_at`
+FROM `member`
+WHERE `email` IS NOT NULL 
+  AND `email` != ''
+  AND TRIM(`email`) != '';
+

backend/migrations/add_mytischtennis_fields_to_league.sql

@@ -0,0 +1,19 @@
+-- Migration: Add myTischtennis fields to league table
+-- Date: 2025-01-27
+-- For MariaDB
+
+-- Add my_tischtennis_group_id column
+ALTER TABLE league 
+ADD COLUMN my_tischtennis_group_id VARCHAR(255) NULL COMMENT 'Group ID from myTischtennis (e.g. 504417)';
+
+-- Add association column
+ALTER TABLE league 
+ADD COLUMN association VARCHAR(255) NULL COMMENT 'Association/Verband (e.g. HeTTV)';
+
+-- Add groupname column
+ALTER TABLE league 
+ADD COLUMN groupname VARCHAR(255) NULL COMMENT 'Group name for URL (e.g. 1.Kreisklasse)';
+
+-- Create index for efficient querying
+CREATE INDEX idx_league_my_tischtennis_group_id ON league(my_tischtennis_group_id);
+

backend/migrations/add_mytischtennis_player_id_to_member.sql

@@ -0,0 +1,11 @@
+-- Migration: Add myTischtennis player ID to member table
+-- Date: 2025-01-27
+-- For MariaDB
+
+-- Add my_tischtennis_player_id column
+ALTER TABLE member 
+ADD COLUMN my_tischtennis_player_id VARCHAR(255) NULL COMMENT 'Player ID from myTischtennis (e.g. NU2705037)';
+
+-- Create index for efficient querying
+CREATE INDEX idx_member_my_tischtennis_player_id ON member(my_tischtennis_player_id);
+

backend/migrations/add_mytischtennis_team_id_to_club_team.sql

@@ -0,0 +1,11 @@
+-- Migration: Add myTischtennis team ID to club_team table
+-- Date: 2025-01-27
+-- For MariaDB
+
+-- Add my_tischtennis_team_id column
+ALTER TABLE club_team 
+ADD COLUMN my_tischtennis_team_id VARCHAR(255) NULL COMMENT 'Team ID from myTischtennis (e.g. 2995094)';
+
+-- Create index for efficient querying
+CREATE INDEX idx_club_team_my_tischtennis_team_id ON club_team(my_tischtennis_team_id);
+

backend/migrations/add_permissions_to_user_club.sql

@@ -0,0 +1,17 @@
+-- Add role and permissions columns to user_club table
+ALTER TABLE `user_club`
+ADD COLUMN `role` VARCHAR(50) DEFAULT 'member' COMMENT 'User role: admin, trainer, team_manager, member' AFTER `approved`,
+ADD COLUMN `permissions` JSON NULL COMMENT 'Specific permissions: {diary: {read: true, write: true}, members: {...}, ...}' AFTER `role`,
+ADD COLUMN `is_owner` BOOLEAN DEFAULT FALSE COMMENT 'True if user created the club' AFTER `permissions`;
+
+-- Create index for faster role lookups
+CREATE INDEX `idx_user_club_role` ON `user_club` (`role`);
+CREATE INDEX `idx_user_club_owner` ON `user_club` (`is_owner`);
+
+-- Set existing approved users as members
+UPDATE `user_club` SET `role` = 'member' WHERE `approved` = 1 AND `role` IS NULL;
+
+-- If there's a user who created the club (we need to identify them somehow)
+-- For now, we'll need to manually set the owner after migration
+
+

backend/migrations/add_player_tracking_to_match.sql

@@ -0,0 +1,8 @@
+-- Add player tracking fields to match table
+-- These fields store arrays of member IDs for different participation states
+
+ALTER TABLE `match` 
+ADD COLUMN `players_ready` JSON NULL COMMENT 'Array of member IDs who are ready to play' AFTER `pdf_url`,
+ADD COLUMN `players_planned` JSON NULL COMMENT 'Array of member IDs who are planned to play' AFTER `players_ready`,
+ADD COLUMN `players_played` JSON NULL COMMENT 'Array of member IDs who actually played' AFTER `players_planned`;
+

backend/migrations/add_season_to_teams.sql

@@ -0,0 +1,44 @@
+-- Migration: Add season_id to teams table
+-- First, add the column as nullable
+ALTER TABLE `team` ADD COLUMN `season_id` INT NULL;
+
+-- Get or create current season
+SET @current_season_id = (
+    SELECT id FROM `season` 
+    WHERE season = (
+        CASE 
+            WHEN MONTH(CURDATE()) >= 7 THEN CONCAT(YEAR(CURDATE()), '/', YEAR(CURDATE()) + 1)
+            ELSE CONCAT(YEAR(CURDATE()) - 1, '/', YEAR(CURDATE()))
+        END
+    )
+    LIMIT 1
+);
+
+-- If no season exists, create it
+INSERT IGNORE INTO `season` (season) VALUES (
+    CASE 
+        WHEN MONTH(CURDATE()) >= 7 THEN CONCAT(YEAR(CURDATE()), '/', YEAR(CURDATE()) + 1)
+        ELSE CONCAT(YEAR(CURDATE()) - 1, '/', YEAR(CURDATE()))
+    END
+);
+
+-- Get the season ID again (in case we just created it)
+SET @current_season_id = (
+    SELECT id FROM `season` 
+    WHERE season = (
+        CASE 
+            WHEN MONTH(CURDATE()) >= 7 THEN CONCAT(YEAR(CURDATE()), '/', YEAR(CURDATE()) + 1)
+            ELSE CONCAT(YEAR(CURDATE()) - 1, '/', YEAR(CURDATE()))
+        END
+    )
+    LIMIT 1
+);
+
+-- Update all existing teams to use the current season
+UPDATE `team` SET `season_id` = @current_season_id WHERE `season_id` IS NULL;
+
+-- Now make the column NOT NULL and add the foreign key constraint
+ALTER TABLE `team` MODIFY COLUMN `season_id` INT NOT NULL;
+ALTER TABLE `team` ADD CONSTRAINT `team_season_id_foreign_idx` 
+    FOREIGN KEY (`season_id`) REFERENCES `season` (`id`) 
+    ON DELETE CASCADE ON UPDATE CASCADE;

backend/migrations/add_table_fields_to_team.sql

@@ -0,0 +1,11 @@
+-- Migration: Add table fields to team table
+-- Add fields for league table calculations
+
+ALTER TABLE team ADD COLUMN matches_played INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN matches_won INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN matches_lost INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN sets_won INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN sets_lost INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN points_won INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN points_lost INT NOT NULL DEFAULT 0;
+ALTER TABLE team ADD COLUMN table_points INT NOT NULL DEFAULT 0;

backend/migrations/add_table_points_won_lost_to_team.sql

@@ -0,0 +1,5 @@
+-- Add table_points_won and table_points_lost columns to team table
+ALTER TABLE team
+ADD COLUMN table_points_won INTEGER NOT NULL DEFAULT 0 AFTER table_points,
+ADD COLUMN table_points_lost INTEGER NOT NULL DEFAULT 0 AFTER table_points_won;
+

backend/migrations/create_api_log_table.sql

@@ -0,0 +1,26 @@
+-- Migration: Create api_log table for comprehensive request/response and execution logging
+
+CREATE TABLE IF NOT EXISTS api_log (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  user_id INT NULL,
+  method VARCHAR(10) NOT NULL COMMENT 'HTTP method (GET, POST, PUT, DELETE, etc.)',
+  path VARCHAR(500) NOT NULL COMMENT 'Request path',
+  status_code INT NULL COMMENT 'HTTP status code',
+  request_body TEXT NULL COMMENT 'Request body (truncated if too long)',
+  response_body TEXT NULL COMMENT 'Response body (truncated if too long)',
+  execution_time INT NULL COMMENT 'Execution time in milliseconds',
+  error_message TEXT NULL COMMENT 'Error message if request failed',
+  ip_address VARCHAR(45) NULL COMMENT 'Client IP address',
+  user_agent VARCHAR(500) NULL COMMENT 'User agent string',
+  log_type ENUM('api_request', 'scheduler', 'cron_job', 'manual') NOT NULL DEFAULT 'api_request' COMMENT 'Type of log entry',
+  scheduler_job_type VARCHAR(50) NULL COMMENT 'Type of scheduler job (rating_updates, match_results, etc.)',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE SET NULL ON UPDATE CASCADE,
+  INDEX idx_api_log_user_id (user_id, created_at),
+  INDEX idx_api_log_path (path, created_at),
+  INDEX idx_api_log_log_type (log_type, created_at),
+  INDEX idx_api_log_created_at (created_at),
+  INDEX idx_api_log_status_code (status_code)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+

backend/migrations/create_my_tischtennis_fetch_log.sql

@@ -0,0 +1,20 @@
+-- Create my_tischtennis_fetch_log table for tracking data fetches
+CREATE TABLE IF NOT EXISTS my_tischtennis_fetch_log (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    user_id INT NOT NULL,
+    fetch_type ENUM('ratings', 'match_results', 'league_table') NOT NULL COMMENT 'Type of data fetch',
+    success BOOLEAN NOT NULL DEFAULT FALSE,
+    message TEXT,
+    error_details TEXT,
+    records_processed INT NOT NULL DEFAULT 0 COMMENT 'Number of records processed',
+    execution_time INT COMMENT 'Execution time in milliseconds',
+    is_automatic BOOLEAN NOT NULL DEFAULT FALSE COMMENT 'Automatic or manual fetch',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    
+    FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE ON UPDATE CASCADE,
+    
+    INDEX idx_user_fetch_type_created (user_id, fetch_type, created_at),
+    INDEX idx_created_at (created_at)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+

backend/migrations/create_my_tischtennis_update_history.sql

@@ -0,0 +1,23 @@
+-- Migration: Create my_tischtennis_update_history table
+-- Date: 2025-01-27
+-- For MariaDB
+
+CREATE TABLE IF NOT EXISTS my_tischtennis_update_history (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    user_id INT NOT NULL,
+    success BOOLEAN NOT NULL DEFAULT FALSE,
+    message TEXT,
+    error_details TEXT,
+    updated_count INT DEFAULT 0,
+    execution_time INT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    
+    CONSTRAINT fk_my_tischtennis_update_history_user_id 
+        FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- Create indexes for efficient querying
+CREATE INDEX idx_my_tischtennis_update_history_user_id ON my_tischtennis_update_history(user_id);
+CREATE INDEX idx_my_tischtennis_update_history_created_at ON my_tischtennis_update_history(created_at);
+CREATE INDEX idx_my_tischtennis_update_history_success ON my_tischtennis_update_history(success);

backend/migrations/make_location_optional_in_match.sql

@@ -0,0 +1,8 @@
+-- Migration: Make locationId optional in match table
+-- Date: 2025-01-27
+-- For MariaDB
+
+-- Modify locationId to allow NULL
+ALTER TABLE `match` 
+MODIFY COLUMN location_id INT NULL;
+

backend/migrations/update_existing_user_club_permissions.sql

@@ -0,0 +1,38 @@
+-- Update existing user_club entries with default permissions
+-- This migration sets default values for role and is_owner for existing club memberships
+
+-- Set default role to 'member' for all approved users who don't have a role yet
+UPDATE `user_club` 
+SET `role` = 'member' 
+WHERE `approved` = 1 
+  AND (`role` IS NULL OR `role` = '');
+
+-- Optionally: Set the first approved user of each club as owner
+-- This finds the user with the lowest user_id per club (oldest member) and marks them as owner
+UPDATE `user_club` AS uc1
+INNER JOIN (
+    SELECT `club_id`, MIN(`user_id`) as `first_user_id`
+    FROM `user_club`
+    WHERE `approved` = 1
+    GROUP BY `club_id`
+) AS uc2 ON uc1.`club_id` = uc2.`club_id` AND uc1.`user_id` = uc2.`first_user_id`
+SET 
+    uc1.`is_owner` = 1,
+    uc1.`role` = 'admin';
+
+-- Verify the changes
+SELECT 
+    uc.`club_id`,
+    c.`name` as club_name,
+    uc.`user_id`,
+    u.`email` as user_email,
+    uc.`role`,
+    uc.`is_owner`,
+    uc.`approved`
+FROM `user_club` uc
+LEFT JOIN `club` c ON c.`id` = uc.`club_id`
+LEFT JOIN `user` u ON u.`id` = uc.`user_id`
+WHERE uc.`approved` = 1
+ORDER BY uc.`club_id`, uc.`is_owner` DESC, uc.`user_id`;
+
+

backend/models/ApiLog.js

@@ -0,0 +1,102 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import User from './User.js';
+
+const ApiLog = sequelize.define('ApiLog', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false,
+  },
+  userId: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    references: {
+      model: User,
+      key: 'id',
+    },
+    onDelete: 'SET NULL',
+    onUpdate: 'CASCADE',
+  },
+  method: {
+    type: DataTypes.STRING(10),
+    allowNull: false,
+    comment: 'HTTP method (GET, POST, PUT, DELETE, etc.)'
+  },
+  path: {
+    type: DataTypes.STRING(500),
+    allowNull: false,
+    comment: 'Request path'
+  },
+  statusCode: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    comment: 'HTTP status code'
+  },
+  requestBody: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    comment: 'Request body (truncated if too long)'
+  },
+  responseBody: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    comment: 'Response body (truncated if too long)'
+  },
+  executionTime: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    comment: 'Execution time in milliseconds'
+  },
+  errorMessage: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    comment: 'Error message if completes failed'
+  },
+  ipAddress: {
+    type: DataTypes.STRING(45),
+    allowNull: true,
+    comment: 'Client IP address'
+  },
+  userAgent: {
+    type: DataTypes.STRING(500),
+    allowNull: true,
+    comment: 'User agent string'
+  },
+  logType: {
+    type: DataTypes.ENUM('api_request', 'scheduler', 'cron_job', 'manual'),
+    allowNull: false,
+    defaultValue: 'api_request',
+    comment: 'Type of log entry'
+  },
+  schedulerJobType: {
+    type: DataTypes.STRING(50),
+    allowNull: true,
+    comment: 'Type of scheduler job (rating_updates, match_results, etc.)'
+  },
+}, {
+  underscored: true,
+  tableName: 'api_log',
+  timestamps: true,
+  indexes: [
+    {
+      fields: ['user_id', 'created_at']
+    },
+    {
+      fields: ['path', 'created_at']
+    },
+    {
+      fields: ['log_type', 'created_at']
+    },
+    {
+      fields: ['created_at']
+    },
+    {
+      fields: ['status_code']
+    }
+  ]
+});
+
+export default ApiLog;
+

backend/models/Club.js

@@ -7,6 +7,16 @@ const Club = sequelize.define('Club', {
     allowNull: false,
     unique: true,
   },
+  greetingText: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'greeting_text'
+  },
+  associationMemberNumber: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'association_member_number'
+  },
 }, {
   tableName: 'clubs',
   underscored: true,

backend/models/ClubTeam.js

@@ -0,0 +1,60 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Club from './Club.js';
+import League from './League.js';
+import Season from './Season.js';
+
+const ClubTeam = sequelize.define('ClubTeam', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    clubId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: Club,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+    leagueId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+            model: League,
+            key: 'id',
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+    },
+    seasonId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+            model: Season,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+    myTischtennisTeamId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Team ID from myTischtennis (e.g. 2995094)',
+        field: 'my_tischtennis_team_id'
+    },
+}, {
+    underscored: true,
+    tableName: 'club_team',
+    timestamps: true,
+});
+
+export default ClubTeam;

backend/models/DiaryMemberActivity.js

@@ -0,0 +1,26 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const DiaryMemberActivity = sequelize.define('DiaryMemberActivity', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+  diaryDateActivityId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  participantId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+}, {
+  tableName: 'diary_member_activities',
+  timestamps: true,
+  underscored: true,
+});
+
+export default DiaryMemberActivity;
+
+

backend/models/League.js

@@ -34,6 +34,22 @@ const League = sequelize.define('League', {
         onDelete: 'CASCADE',
         onUpdate: 'CASCADE',
     },
+    myTischtennisGroupId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Group ID from myTischtennis (e.g. 504417)',
+        field: 'my_tischtennis_group_id'
+    },
+    association: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Association/Verband (e.g. HeTTV)',
+    },
+    groupname: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Group name for URL (e.g. 1.Kreisklasse)',
+    },
 }, {
     underscored: true,
     tableName: 'league',

backend/models/Match.js

@@ -3,7 +3,6 @@ import sequelize from '../database.js';
 import Club from './Club.js';
 import League from './League.js';
 import Team from './Team.js';
-import Season from './Season.js';
 import Location from './Location.js';
 
 const Match = sequelize.define('Match', {
@@ -21,21 +20,13 @@ const Match = sequelize.define('Match', {
         type: DataTypes.TIME,
         allowNull: true,
     },
-    seasonId: {
-        type: DataTypes.INTEGER,
-        references: {
-            model: Season,
-            key: 'id',
-        },
-        allowNull: false,
-    },
     locationId: {
         type: DataTypes.INTEGER,
         references: {
             model: Location,
             key: 'id',
         },
-        allowNull: false,
+        allowNull: true,
     },
     homeTeamId: {
         type: DataTypes.INTEGER,
@@ -69,6 +60,73 @@ const Match = sequelize.define('Match', {
         },
         allowNull: false,
     },
+    code: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Spiel-Code aus PDF-Parsing'
+    },
+    homePin: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Pin-Code für Heimteam aus PDF-Parsing'
+    },
+    guestPin: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Pin-Code für Gastteam aus PDF-Parsing'
+    },
+    myTischtennisMeetingId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        unique: true,
+        comment: 'Meeting ID from myTischtennis (e.g. 15440488)',
+        field: 'my_tischtennis_meeting_id'
+    },
+    homeMatchPoints: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+        comment: 'Match points won by home team',
+        field: 'home_match_points'
+    },
+    guestMatchPoints: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+        comment: 'Match points won by guest team',
+        field: 'guest_match_points'
+    },
+    isCompleted: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        comment: 'Whether the match is completed',
+        field: 'is_completed'
+    },
+    pdfUrl: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'PDF URL from myTischtennis',
+        field: 'pdf_url'
+    },
+    playersReady: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: 'Array of member IDs who are ready to play',
+        field: 'players_ready'
+    },
+    playersPlanned: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: 'Array of member IDs who are planned to play',
+        field: 'players_planned'
+    },
+    playersPlayed: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: 'Array of member IDs who actually played',
+        field: 'players_played'
+    },
 }, {
     underscored: true,
     tableName: 'match',

backend/models/Member.js

@@ -45,13 +45,14 @@ const Member = sequelize.define('Member', {
   },
   birthDate: {
     type: DataTypes.STRING, 
-    allowNull: false,
+    allowNull: true,
     set(value) {
-      const encryptedValue = encryptData(value);
+      const encryptedValue = encryptData(value || '');
       this.setDataValue('birthDate', encryptedValue);
     },
     get() {
       const encryptedValue = this.getDataValue('birthDate');
+      if (!encryptedValue) return null;
       return decryptData(encryptedValue);
     }
   },
@@ -91,6 +92,21 @@ const Member = sequelize.define('Member', {
       return decryptData(encryptedValue);
     }
   },
+  postalCode: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    set(value) {
+      const encryptedValue = encryptData(value || '');
+      this.setDataValue('postalCode', encryptedValue);
+    },
+    get() {
+      const encryptedValue = this.getDataValue('postalCode');
+      if (!encryptedValue) return null;
+      return decryptData(encryptedValue);
+    },
+    field: 'postal_code',
+    comment: 'Postal code (PLZ)'
+  },
   email: {
     type: DataTypes.STRING,
     allowNull: false,
@@ -122,6 +138,35 @@ const Member = sequelize.define('Member', {
     allowNull: false,
     default: false,
   }
+  ,
+  gender: {
+    type: DataTypes.ENUM('male','female','diverse','unknown'),
+    allowNull: true,
+    defaultValue: 'unknown'
+  },
+  ttr: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    defaultValue: null
+  },
+  qttr: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    defaultValue: null
+  },
+  memberFormHandedOver: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+    field: 'member_form_handed_over',
+    comment: 'Mitgliedsformular ausgehändigt'
+  },
+  myTischtennisPlayerId: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    comment: 'Player ID from myTischtennis (e.g. NU2705037)',
+    field: 'my_tischtennis_player_id'
+  }
 }, {
   underscored: true,
   sequelize,
@@ -135,13 +180,7 @@ const Member = sequelize.define('Member', {
       member.save();
     },
   }
-},
-  {
-    underscored: true,
-    tableName: 'log',
-    timestamps: true
-  }
-);
+});
 
 Member.belongsTo(Club, { as: 'club' });
 Club.hasMany(Member, { as: 'members' });

backend/models/MemberContact.js

@@ -0,0 +1,89 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Member from './Member.js';
+import { encryptData, decryptData } from '../utils/encrypt.js';
+
+const MemberContact = sequelize.define('MemberContact', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  memberId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    references: {
+      model: 'member',
+      key: 'id'
+    },
+    onDelete: 'CASCADE',
+    field: 'member_id'
+  },
+  type: {
+    type: DataTypes.ENUM('phone', 'email'),
+    allowNull: false,
+    comment: 'Type of contact: phone or email'
+  },
+  value: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    set(value) {
+      const encryptedValue = encryptData(value);
+      this.setDataValue('value', encryptedValue);
+    },
+    get() {
+      const encryptedValue = this.getDataValue('value');
+      if (!encryptedValue) return null;
+      try {
+        return decryptData(encryptedValue);
+      } catch (error) {
+        console.error('[MemberContact] Error decrypting value:', error);
+        return encryptedValue; // Fallback: return encrypted value if decryption fails
+      }
+    }
+  },
+  isParent: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+    field: 'is_parent',
+    comment: 'Whether this contact belongs to a parent'
+  },
+  parentName: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    set(value) {
+      if (value) {
+        const encryptedValue = encryptData(value);
+        this.setDataValue('parentName', encryptedValue);
+      } else {
+        this.setDataValue('parentName', null);
+      }
+    },
+    get() {
+      const encryptedValue = this.getDataValue('parentName');
+      return encryptedValue ? decryptData(encryptedValue) : null;
+    },
+    field: 'parent_name',
+    comment: 'Name of the parent (e.g. "Mutter", "Vater", "Elternteil 1")'
+  },
+  isPrimary: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+    field: 'is_primary',
+    comment: 'Whether this is the primary contact of this type'
+  }
+}, {
+  underscored: true,
+  sequelize,
+  modelName: 'MemberContact',
+  tableName: 'member_contact',
+  timestamps: true
+});
+
+// Associations are defined in models/index.js to avoid duplicate alias errors
+
+export default MemberContact;
+

backend/models/MemberImage.js

@@ -0,0 +1,40 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const MemberImage = sequelize.define('MemberImage', {
+  id: {
+    type: DataTypes.INTEGER,
+    autoIncrement: true,
+    primaryKey: true,
+    allowNull: false
+  },
+  memberId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    field: 'member_id',
+    references: {
+      model: 'member',
+      key: 'id'
+    },
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE'
+  },
+  fileName: {
+    type: DataTypes.STRING(255),
+    allowNull: false,
+    field: 'file_name'
+  },
+  sortOrder: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    defaultValue: 0,
+    field: 'sort_order'
+  }
+}, {
+  tableName: 'member_image',
+  underscored: true,
+  timestamps: true
+});
+
+export default MemberImage;
+

backend/models/MemberTransferConfig.js

@@ -0,0 +1,117 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Club from './Club.js';
+import { encryptData, decryptData } from '../utils/encrypt.js';
+
+const MemberTransferConfig = sequelize.define('MemberTransferConfig', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  clubId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    unique: true,
+    references: {
+      model: Club,
+      key: 'id'
+    },
+    onDelete: 'CASCADE'
+  },
+  server: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'server',
+    comment: 'Base URL des Servers (z.B. https://example.com)'
+  },
+  loginEndpoint: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'login_endpoint',
+    comment: 'Relativer Pfad zum Login-Endpoint (z.B. /api/auth/login)'
+  },
+  loginFormat: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    defaultValue: 'json',
+    field: 'login_format'
+  },
+  encryptedLoginCredentials: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'encrypted_login_credentials',
+    comment: 'Verschlüsselte Login-Daten als JSON-String'
+  },
+  transferEndpoint: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    field: 'transfer_endpoint',
+    comment: 'Relativer Pfad zum Übertragungs-Endpoint (z.B. /api/members/bulk)'
+  },
+  transferMethod: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    defaultValue: 'POST',
+    field: 'transfer_method'
+  },
+  transferFormat: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    defaultValue: 'json',
+    field: 'transfer_format'
+  },
+  transferTemplate: {
+    type: DataTypes.TEXT,
+    allowNull: false,
+    field: 'transfer_template'
+  },
+  useBulkMode: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+    field: 'use_bulk_mode'
+  },
+  bulkWrapperTemplate: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'bulk_wrapper_template',
+    comment: 'Optionales Template für die äußere Struktur im Bulk-Modus (z.B. {"data": {"members": "{{members}}"}})'
+  }
+}, {
+  underscored: true,
+  tableName: 'member_transfer_config',
+  timestamps: true
+});
+
+// Getter/Setter für verschlüsselte Login-Daten
+MemberTransferConfig.prototype.getLoginCredentials = function() {
+  if (!this.encryptedLoginCredentials) {
+    return null;
+  }
+  try {
+    const decrypted = decryptData(this.encryptedLoginCredentials);
+    return JSON.parse(decrypted);
+  } catch (error) {
+    console.error('[MemberTransferConfig] Error decrypting login credentials:', error);
+    return null;
+  }
+};
+
+MemberTransferConfig.prototype.setLoginCredentials = function(credentials) {
+  if (!credentials || Object.keys(credentials).length === 0) {
+    this.encryptedLoginCredentials = null;
+    return;
+  }
+  try {
+    const jsonString = JSON.stringify(credentials);
+    this.encryptedLoginCredentials = encryptData(jsonString);
+  } catch (error) {
+    console.error('[MemberTransferConfig] Error encrypting login credentials:', error);
+    this.encryptedLoginCredentials = null;
+  }
+};
+
+export default MemberTransferConfig;
+

backend/models/MyTischtennis.js

@@ -0,0 +1,133 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import { encryptData, decryptData } from '../utils/encrypt.js';
+
+const MyTischtennis = sequelize.define('MyTischtennis', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  userId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    unique: true,
+    references: {
+      model: 'user',
+      key: 'id'
+    },
+    onDelete: 'CASCADE'
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  encryptedPassword: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'encrypted_password'
+  },
+  savePassword: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'save_password'
+  },
+  autoUpdateRatings: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'auto_update_ratings'
+  },
+  accessToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'access_token'
+  },
+  refreshToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'refresh_token'
+  },
+  expiresAt: {
+    type: DataTypes.BIGINT,
+    allowNull: true,
+    field: 'expires_at'
+  },
+  cookie: {
+    type: DataTypes.TEXT,
+    allowNull: true
+  },
+  userData: {
+    type: DataTypes.JSON,
+    allowNull: true,
+    field: 'user_data'
+  },
+  clubId: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_id'
+  },
+  clubName: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_name'
+  },
+  fedNickname: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'fed_nickname'
+  },
+  lastLoginAttempt: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_attempt'
+  },
+  lastLoginSuccess: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_success'
+  },
+  lastUpdateRatings: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_update_ratings'
+  }
+}, {
+  underscored: true,
+  tableName: 'my_tischtennis',
+  timestamps: true,
+  hooks: {
+    beforeSave: async (instance) => {
+      // Wenn savePassword false ist, password auf null setzen
+      if (!instance.savePassword) {
+        instance.encryptedPassword = null;
+      }
+    }
+  }
+});
+
+// Virtuelle Felder für password handling
+MyTischtennis.prototype.setPassword = function(password) {
+  if (password && this.savePassword) {
+    this.encryptedPassword = encryptData(password);
+  } else {
+    this.encryptedPassword = null;
+  }
+};
+
+MyTischtennis.prototype.getPassword = function() {
+  if (this.encryptedPassword) {
+    try {
+      return decryptData(this.encryptedPassword);
+    } catch (error) {
+      console.error('Error decrypting myTischtennis password:', error);
+      return null;
+    }
+  }
+  return null;
+};
+
+export default MyTischtennis;
+

backend/models/MyTischtennisFetchLog.js

@@ -0,0 +1,72 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import User from './User.js';
+
+const MyTischtennisFetchLog = sequelize.define('MyTischtennisFetchLog', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    userId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: User,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+    fetchType: {
+        type: DataTypes.ENUM('ratings', 'match_results', 'league_table'),
+        allowNull: false,
+        comment: 'Type of data fetch: ratings, match_results, or league_table'
+    },
+    success: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+    },
+    message: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+    },
+    errorDetails: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+    },
+    recordsProcessed: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        comment: 'Number of records processed (e.g., players updated, matches fetched)'
+    },
+    executionTime: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        comment: 'Execution time in milliseconds'
+    },
+    isAutomatic: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        comment: 'Whether this was an automatic or manual fetch'
+    },
+}, {
+    underscored: true,
+    tableName: 'my_tischtennis_fetch_log',
+    timestamps: true,
+    indexes: [
+        {
+            fields: ['user_id', 'fetch_type', 'created_at']
+        },
+        {
+            fields: ['created_at']
+        }
+    ]
+});
+
+export default MyTischtennisFetchLog;
+

backend/models/MyTischtennisUpdateHistory.js

@@ -0,0 +1,63 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const MyTischtennisUpdateHistory = sequelize.define('MyTischtennisUpdateHistory', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  userId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    references: {
+      model: 'user',
+      key: 'id'
+    },
+    onDelete: 'CASCADE'
+  },
+  success: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false
+  },
+  message: {
+    type: DataTypes.TEXT,
+    allowNull: true
+  },
+  errorDetails: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'error_details'
+  },
+  updatedCount: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    defaultValue: 0,
+    field: 'updated_count'
+  },
+  executionTime: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    comment: 'Execution time in milliseconds',
+    field: 'execution_time'
+  }
+}, {
+  underscored: true,
+  tableName: 'my_tischtennis_update_history',
+  timestamps: true,
+  indexes: [
+    {
+      fields: ['user_id']
+    },
+    {
+      fields: ['created_at']
+    },
+    {
+      fields: ['success']
+    }
+  ]
+});
+
+export default MyTischtennisUpdateHistory;

backend/models/OfficialCompetition.js

@@ -0,0 +1,28 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const OfficialCompetition = sequelize.define('OfficialCompetition', {
+  id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+  tournamentId: { type: DataTypes.INTEGER, allowNull: false },
+  // Englische Attributnamen, gemappt auf bestehende DB-Spalten
+  ageClassCompetition: { type: DataTypes.STRING, allowNull: true, field: 'age_class_competition' },
+  performanceClass: { type: DataTypes.STRING, allowNull: true, field: 'performance_class' },
+  startTime: { type: DataTypes.STRING, allowNull: true, field: 'start_time' },
+  registrationDeadlineDate: { type: DataTypes.STRING, allowNull: true, field: 'registration_deadline_date' },
+  registrationDeadlineOnline: { type: DataTypes.STRING, allowNull: true, field: 'registration_deadline_online' },
+  cutoffDate: { type: DataTypes.STRING, allowNull: true, field: 'cutoff_date' },
+  ttrRelevant: { type: DataTypes.STRING, allowNull: true },
+  openTo: { type: DataTypes.STRING, allowNull: true, field: 'open_to' },
+  preliminaryRound: { type: DataTypes.STRING, allowNull: true, field: 'preliminary_round' },
+  finalRound: { type: DataTypes.STRING, allowNull: true, field: 'final_round' },
+  maxParticipants: { type: DataTypes.STRING, allowNull: true, field: 'max_participants' },
+  entryFee: { type: DataTypes.STRING, allowNull: true, field: 'entry_fee' },
+}, {
+  tableName: 'official_competitions',
+  timestamps: true,
+  underscored: true,
+});
+
+export default OfficialCompetition;
+
+

backend/models/OfficialCompetitionMember.js

@@ -0,0 +1,25 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const OfficialCompetitionMember = sequelize.define('OfficialCompetitionMember', {
+  id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+  tournamentId: { type: DataTypes.INTEGER, allowNull: false },
+  competitionId: { type: DataTypes.INTEGER, allowNull: false },
+  memberId: { type: DataTypes.INTEGER, allowNull: false },
+  wants: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+  registered: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+  participated: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+  placement: { type: DataTypes.STRING, allowNull: true },
+}, {
+  tableName: 'official_competition_members',
+  timestamps: true,
+  underscored: true,
+  indexes: [
+    { unique: true, fields: ['competition_id', 'member_id'] },
+    { fields: ['tournament_id'] },
+  ],
+});
+
+export default OfficialCompetitionMember;
+
+

backend/models/OfficialTournament.js

@@ -0,0 +1,23 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const OfficialTournament = sequelize.define('OfficialTournament', {
+  id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+  clubId: { type: DataTypes.INTEGER, allowNull: false },
+  title: { type: DataTypes.STRING, allowNull: true },
+  eventDate: { type: DataTypes.STRING, allowNull: true },
+  organizer: { type: DataTypes.STRING, allowNull: true },
+  host: { type: DataTypes.STRING, allowNull: true },
+  venues: { type: DataTypes.TEXT, allowNull: true }, // JSON.stringify(Array)
+  competitionTypes: { type: DataTypes.TEXT, allowNull: true }, // JSON.stringify(Array)
+  registrationDeadlines: { type: DataTypes.TEXT, allowNull: true }, // JSON.stringify(Array)
+  entryFees: { type: DataTypes.TEXT, allowNull: true }, // JSON.stringify(Object) - Teilnahmegebühren pro Spielklasse
+}, {
+  tableName: 'official_tournaments',
+  timestamps: true,
+  underscored: true,
+});
+
+export default OfficialTournament;
+
+

backend/models/Participant.js

@@ -2,6 +2,7 @@ import { DataTypes } from 'sequelize';
 import sequelize from '../database.js';
 import Member from './Member.js';
 import DiaryDate from './DiaryDates.js';
+import Group from './Group.js';
 import { encryptData, decryptData } from '../utils/encrypt.js';
 
 const Participant = sequelize.define('Participant', {
@@ -27,6 +28,16 @@ const Participant = sequelize.define('Participant', {
             key: 'id'
         }
     },
+    groupId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+            model: Group,
+            key: 'id'
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE'
+    },
     notes: {
         type: DataTypes.STRING(4096),
         allowNull: true,

backend/models/PredefinedActivity.js

@@ -11,10 +11,19 @@ const PredefinedActivity = sequelize.define('PredefinedActivity', {
         type: DataTypes.STRING,
         allowNull: false,
     },
+    code: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
     description: {
         type: DataTypes.TEXT,
         allowNull: true,
     },
+    drawingData: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: 'JSON string with metadata for Court Drawing Tool'
+    },
     durationText: {
         type: DataTypes.STRING,
         allowNull: true,
@@ -23,6 +32,10 @@ const PredefinedActivity = sequelize.define('PredefinedActivity', {
         type: DataTypes.INTEGER,
         allowNull: true,
     },
+    imageLink: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
 }, {
     tableName: 'predefined_activities',
     timestamps: true,

backend/models/PredefinedActivityImage.js

@@ -0,0 +1,35 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const PredefinedActivityImage = sequelize.define('PredefinedActivityImage', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+  predefinedActivityId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  imagePath: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  mimeType: {
+    type: DataTypes.STRING,
+    allowNull: true,
+  },
+  drawingData: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    comment: 'JSON string containing drawing metadata for Court Drawing Tool'
+  },
+}, {
+  tableName: 'predefined_activity_images',
+  timestamps: true,
+  underscored: true,
+});
+
+export default PredefinedActivityImage;
+
+

backend/models/Team.js

@@ -1,6 +1,8 @@
 import { DataTypes } from 'sequelize';
 import sequelize from '../database.js';
 import Club from './Club.js';
+import League from './League.js';
+import Season from './Season.js';
 
 const Team = sequelize.define('Team', {
     id: {
@@ -23,6 +25,82 @@ const Team = sequelize.define('Team', {
         onDelete: 'CASCADE',
         onUpdate: 'CASCADE',
     },
+    leagueId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+            model: League,
+            key: 'id',
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+    },
+    seasonId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+            model: Season,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+    // Tabellenfelder
+    matchesPlayed: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    matchesWon: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    matchesLost: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    matchesTied: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    setsWon: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    setsLost: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    pointsWon: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    pointsLost: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    tablePoints: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    tablePointsWon: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    tablePointsLost: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
 }, {
     underscored: true,
     tableName: 'team',

backend/models/TeamDocument.js

@@ -0,0 +1,52 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import ClubTeam from './ClubTeam.js';
+
+const TeamDocument = sequelize.define('TeamDocument', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    fileName: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    originalFileName: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    filePath: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    fileSize: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+    },
+    mimeType: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    documentType: {
+        type: DataTypes.ENUM('code_list', 'pin_list'),
+        allowNull: false,
+    },
+    clubTeamId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: ClubTeam,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+}, {
+    underscored: true,
+    tableName: 'team_document',
+    timestamps: true,
+});
+
+export default TeamDocument;

backend/models/Tournament.js

@@ -0,0 +1,38 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const Tournament = sequelize.define('Tournament', {
+    name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    date: {
+        type: DataTypes.DATEONLY,
+        allowNull: false,
+    },
+    type: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    advancingPerGroup: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+    },
+    numberOfGroups: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0, 
+    },
+    clubId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 1
+    },
+    advancingPerGroup:  { type: DataTypes.INTEGER, allowNull: false, defaultValue: 1 },
+}, {
+  underscored: true,
+  tableName: 'tournament',
+  timestamps: true,
+});
+
+export default Tournament;

backend/models/TournamentGroup.js

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+
+const TournamentGroup = sequelize.define('TournamentGroup', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    tournamentId : {
+        type: DataTypes.INTEGER,
+        allowNull: false
+    },
+  }, {
+  underscored: true,
+  tableName: 'tournament_group',
+  timestamps: true,
+});
+
+export default TournamentGroup;

backend/models/TournamentMatch.js

@@ -0,0 +1,59 @@
+// models/TournamentMatch.js
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Tournament from './Tournament.js';
+import TournamentGroup from './TournamentGroup.js';
+
+const TournamentMatch = sequelize.define('TournamentMatch', {
+  tournamentId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    references: {
+      model: Tournament,
+      key: 'id'
+    },
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE'
+  },
+  groupId: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    references: {
+      model: TournamentGroup,
+      key: 'id'
+    },
+    onDelete: 'SET NULL',
+    onUpdate: 'CASCADE'
+  },
+  groupRound: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+  },
+  round: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  player1Id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  player2Id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  isFinished: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+  },
+  result: {
+    type: DataTypes.STRING,
+    allowNull: true,
+  },
+}, {
+  underscored: true,
+  tableName: 'tournament_match',
+  timestamps: true,
+});
+
+export default TournamentMatch;