feat(match3): Erweiterung der Match3-Admin-Funktionalitäten und -Modelle

- Implementierung neuer Endpunkte für die Verwaltung von Match3-Kampagnen, Levels, Objectives und Tile-Typen im Admin-Bereich.
- Anpassung der Admin-Services zur Unterstützung von Benutzerberechtigungen und Fehlerbehandlung.
- Einführung von neuen Modellen und Assoziationen für Match3-Levels und Tile-Typen in der Datenbank.
- Verbesserung der Internationalisierung für Match3-spezifische Texte in Deutsch und Englisch.
- Aktualisierung der Frontend-Routen und -Komponenten zur Verwaltung von Match3-Inhalten.

backend/README_SCHEMA_UPDATES.md

@@ -0,0 +1,177 @@
+# Datenbank-Schema-Updates
+
+## Problem
+Sequelize erstellt bei jedem `sync()` mit `alter: true` die Constraints neu, was zu Duplikaten und Problemen führen kann.
+
+## Lösung
+
+### 1. Intelligente Schema-Synchronisation (Standard)
+```javascript
+// In utils/sequelize.js - syncModelsWithUpdates()
+// Prüft automatisch ob Schema-Updates nötig sind
+// Verwendet alter: true nur bei Bedarf
+await syncModelsWithUpdates(models);
+```
+- **Automatische Erkennung** von Schema-Updates
+- **alter: true nur bei Bedarf** - verhindert Duplikate
+- **Fallback** zu alter: false wenn keine Updates nötig
+- **Sicher und effizient**
+
+### 2. Normale Synchronisation (ohne Updates)
+```javascript
+// In utils/sequelize.js - syncModels()
+await model.sync({ alter: false, force: false });
+```
+- **Keine Schema-Änderungen**
+- **Keine Constraints werden neu erstellt**
+- **Schnell und sicher**
+
+### 3. Manuelle Schema-Updates (nur bei Bedarf)
+```javascript
+// In utils/sequelize.js - updateSchema()
+await model.sync({ alter: true, force: false });
+```
+- **Nur bei expliziten Schema-Änderungen verwenden**
+- **Kann zu Duplikaten führen**
+- **Nach Update: Zurück zu intelligenter Synchronisation**
+
+### 4. Vollständiger Reset (nur in Entwicklung)
+```javascript
+await model.sync({ force: true });
+```
+- **Löscht alle Daten!**
+- **Nur in Entwicklungsumgebung verwenden**
+
+## Aktuelle Implementierung
+
+### Intelligente Synchronisation
+```javascript
+// syncModelsWithUpdates() prüft automatisch:
+// 1. Alle verfügbaren Schemas (community, falukant_data, match3, etc.)
+// 2. Alle Tabellen in jedem Schema
+// 3. Alle Spalten in jeder Tabelle
+// 4. Datentypen, Constraints und Standardwerte
+// 5. Verwendet alter: true nur wenn nötig
+```
+
+### Universelle Schema-Prüfung
+```javascript
+// checkSchemaUpdates() prüft alle Schemas:
+// - community (Benutzer, Rechte, etc.)
+// - falukant_data (Spieldaten)
+// - falukant_type (Spieltypen)
+// - falukant_predefine (Vordefinierte Daten)
+// - falukant_log (Spiel-Logs)
+// - chat (Chat-System)
+// - forum (Forum-System)
+// - match3 (Match3-Spiel)
+// - logs (Allgemeine Logs)
+// - type (Allgemeine Typen)
+// - service (Service-Daten)
+```
+
+### Detaillierte Tabellen-Prüfung
+```javascript
+// checkTableForUpdates() prüft jede Tabelle:
+// - Fehlende Spalten
+// - Neue Spalten
+// - Geänderte Spalten
+// - Model-zu-Tabelle-Zuordnung
+```
+
+### Umfassende Spalten-Prüfung
+```javascript
+// checkColumnForUpdates() prüft jede Spalte:
+// - Datentyp-Änderungen (INTEGER → BIGINT)
+// - NULL/NOT NULL Constraints
+// - Standardwerte
+// - Längen-Änderungen (VARCHAR)
+```
+
+## Workflow für Schema-Updates
+
+### Schritt 1: Schema ändern
+```javascript
+// In models/.../model.js
+// Neue Felder, Constraints, etc. hinzufügen
+```
+
+### Schritt 2: Automatische Erkennung
+```javascript
+// syncModelsWithUpdates() erkennt automatisch:
+// - Welche Updates nötig sind
+// - Verwendet alter: true nur bei Bedarf
+// - Läuft bei jedem Start sicher
+```
+
+### Schritt 3: Keine manuellen Änderungen nötig
+```javascript
+// Die intelligente Synchronisation:
+// - Erkennt Änderungen automatisch
+// - Wendet sie sicher an
+// - Verhindert Duplikate
+```
+
+## Constraint-Bereinigung
+
+### Analyse ausführen
+```bash
+cd backend
+node utils/cleanupDatabaseConstraints.js
+```
+
+### Manuelle Bereinigung
+```sql
+-- Doppelte Foreign Keys entfernen
+ALTER TABLE schema.table_name DROP CONSTRAINT constraint_name;
+
+-- Doppelte Indexe entfernen
+DROP INDEX IF EXISTS index_name;
+```
+
+## Best Practices
+
+1. **Intelligente Synchronisation verwenden** - `syncModelsWithUpdates()`
+2. **Keine manuellen Schema-Updates** bei jedem Start
+3. **updateSchema() nur bei komplexen Änderungen** verwenden
+4. **Constraints regelmäßig prüfen** auf Duplikate
+5. **Backup vor Schema-Updates** erstellen
+
+## Aktuelle Konfiguration
+
+- **Standard-Synchronisation**: `syncModelsWithUpdates()` (intelligent)
+- **Schema-Updates**: Automatisch erkannt und angewendet
+- **Manuelle Updates**: Separate `updateSchema()` Funktion
+- **Automatische Updates**: Aktiviert und sicher
+- **Manuelle Kontrolle**: Verfügbar bei Bedarf
+
+## Troubleshooting
+
+### Problem: Duplizierte Constraints
+```bash
+# Analyse ausführen
+node utils/cleanupDatabaseConstraints.js
+
+# Manuell bereinigen
+# Siehe SQL-Beispiele oben
+```
+
+### Problem: Schema-Synchronisation schlägt fehl
+```javascript
+// Intelligente Synchronisation sollte das automatisch handhaben
+// Bei Problemen: updateSchema() verwenden
+await updateSchema(models);
+```
+
+### Problem: Performance-Probleme
+- **Intelligente Synchronisation** läuft nur bei Bedarf
+- **alter: true** wird nur verwendet wenn nötig
+- **Normale Starts** sind schnell und sicher
+
+## Vorteile der neuen Lösung
+
+1. **Automatisch**: Erkennt Schema-Updates automatisch
+2. **Sicher**: Verwendet alter: true nur bei Bedarf
+3. **Effizient**: Normale Starts ohne Schema-Updates
+4. **Flexibel**: Kann für verschiedene Modelle erweitert werden
+5. **Wartbar**: Klare Trennung zwischen Update-Logik und Synchronisation