Author SHA1 Message Date
Trompi001 3d606a1a3d docs: Add detailed German comments to HTML templates 2026-06-09 18:21:46 +02:00
Trompi001 8aed9d5346 docs: Add comprehensive German comments to frontend codebase 2026-06-09 18:13:24 +02:00
Trompi001 9beec6e113 update team role 2026-06-09 18:04:10 +02:00
joostadrian 5c16f7296a Merge pull request 'impressum' (#10) from impressum into main
Reviewed-on: #10
2026-06-01 21:20:43 +02:00
Adrian Joost 447b12bed1 merge main into impressum, manual conflict resolve in custom.css 2026-06-01 21:17:43 +02:00
joostadrian 28335b32a6 Merge pull request 'message_challenges' (#9) from message_challenges into main
Reviewed-on: #9
2026-05-31 17:47:09 +02:00
DST81 96175ae699 Annpassung challenge-Logik, beide Spieler erhalten den selben Text 2026-05-31 14:53:16 +02:00
DST81 5199b32471 Challenge-Logik überarbeitet und fertig gestellt 2026-05-28 15:22:35 +02:00
Trompi001 909eb97bbb update styling 2026-05-25 17:41:51 +02:00
Trompi001 2d51443c94 Notifications only visible when logged in 2026-05-25 17:25:11 +02:00
Trompi001 6eaaa8d555 Update play.js to track input duration and adjust score timing 2026-05-25 16:09:47 +02:00
Trompi001 73c60f949d Add description paragraph to leaderboard section 2026-05-25 15:41:21 +02:00
Trompi001 cf4a07e4d0 add Meine Scores 2026-05-25 15:39:48 +02:00
DST81 be451f36ce Improve Challenge-Logik... aber noch nicht fertig 2026-05-25 13:25:34 +02:00
Trompi001 c060590a4a update Backend API 2026-05-25 11:55:54 +02:00
Trompi001 2488859dbf Update README so that it meets the evaluation criteria 2026-05-24 20:20:13 +02:00
DST81 c533198c38 Add Message/Challenge-Logik 2026-05-23 16:17:57 +02:00
joostadrian 57ae0ccda5 Merge pull request 'add prevention of ctrl+c ctrl + v' (#8) from prohibit-copy into main
Reviewed-on: #8
2026-05-18 14:32:00 +02:00
Adrian Joost 82f8e46cde add prevention of ctrl+c ctrl + v 2026-05-18 14:30:41 +02:00
joostadrian ad64bae67b Merge pull request 'impressum' (#7) from impressum into main
Reviewed-on: #7
2026-05-18 14:10:56 +02:00
DST81 cf36809d28 kleine Anpassungen css 2026-05-17 15:46:46 +02:00
DST81 d91d42f759 Add Spiellogik in play.html und play.js 2026-05-16 17:26:49 +02:00
DST81 66cee7e5e2 Add branch leaderboard to impressum 2026-05-13 10:26:59 +02:00
DST81 90ab402ca6 Add play.js 2026-05-13 10:22:06 +02:00
DST81 184f933a57 Merge branch 'leaderboard' into impressum 2026-05-13 10:15:44 +02:00
DST81 40e61c16a2 Add Impressum 2026-05-10 23:54:07 +02:00
Trompi001 9f995e213a creating leaderboard 2026-04-22 10:23:35 +02:00
joostadrian 3b16df35a4 Merge pull request 'daniela' (#6) from daniela into main
Reviewed-on: #6
2026-04-13 08:41:28 +02:00
Trompi001 bce833471f creating login function 2026-04-01 16:30:23 +02:00
DST81 ffd443b9dc Navigation Grundgerüst erstellt 2026-03-10 18:43:37 +01:00
DST81 8fb326cf87 Grundgerüst Navigation optimiert 2026-03-09 22:51:01 +01:00
DST81 c996777f45 Kleinigkeiten der Navigation optimiert 2026-03-08 23:49:10 +01:00
DST81 fa0bcf0af8 Erste Schritte der Navigation implementiert 2026-03-08 23:12:45 +01:00
DST81 5e1106b72a Spielen und Ausprobieren mit Responsive Design Teil 2 2026-03-08 21:13:40 +01:00
DST81 38f2c699b2 Spielen und Ausprobieren mit Responsive Design Teil 2 2026-03-08 21:13:40 +01:00
DST81 b430cb4d39 Spielen und Ausprobieren mit Responsive Design 2026-03-08 21:13:40 +01:00
joostadrian d55770bc40 Merge pull request 'Add example of using the API' (#5) from api-access into main
Reviewed-on: #5
2026-03-08 20:46:09 +01:00
Adrian Joost 25aa8864fd Add example of using the API 2026-03-08 20:45:00 +01:00
joostadrian 0cace24153 Merge pull request 'Add API Document draft' (#4) from early-documentation into main
Reviewed-on: #4
2026-02-13 19:43:43 +01:00
Adrian Joost fa85f856c0 Add API Document draft 2026-02-10 17:32:07 +01:00
34 changed files with 6077 additions and 25 deletions

No files matched your search

+1
View File
@@ -0,0 +1 @@
.vscode/
+417 -10
View File
@@ -1,17 +1,424 @@
# lorem_ipsum
# Lorem Ipsum – Memory Game Webanwendung
## Inhaltsverzeichnis
- [Projektbeschreibung](#projektbeschreibung)
- [Anforderungen & Features](#anforderungen--features)
- [Installation & Setup](#installation--setup)
- [Verwendung](#verwendung)
- [Projektstruktur](#projektstruktur)
- [Technologie-Stack](#technologie-stack)
- [Architektur & Technische Entscheidungen](#architektur--technische-entscheidungen)
- [Sicherheit](#sicherheit)
- [KI-Werkzeuge & deren Einsatz](#ki-werkzeuge--deren-einsatz)
- [Herausforderungen & Lerneffekte](#herausforderungen--lerneffekte)
- [Team](#team)
---
## Projektbeschreibung
Das Projekt Lorem Ipsum ist ein kleines Spiel, bei dem ein User einen Text für eine gewisse Zeit angezeigt bekommt. Der User soll sich in dieser Zeit möglichst viel des Textes auswendig merken. Nach Ablauf der Zeit kann der Nutzer den Text in einem Feld eingeben. Er oder sie erhält Punkte entsprechend dem, wieviele Wörter richtig eingetippt wurden.
Der User kann seinen Score auf ein globales Leaderboard hochladen und sich mit anderen Usern vergleichen. Der User kann sich eine Top10 Tabelle des globalen Leaderboards anzeigen lassen.
**Lorem Ipsum** ist eine interaktive Webanwendung, die das Kurzzeitgedächtnis trainiert. Nutzer werden mit zufälligen Texten präsentiert, die sie sich innerhalb einer definierten Zeitspanne einprägen müssen. Nach Ablauf der Zeit reproduzieren sie den Text so akkurat wie möglich. Das System bewertet die Leistung durch Wort-für-Wort-Vergleich und vergibt Punkte.
## Features
Die Anwendung ermöglicht soziale Interaktion durch ein globales Leaderboard, auf dem Nutzer ihre Scores veröffentlichen und sich mit anderen Spielern vergleichen können.
## Technologieen
Als CSS Framework wird Bootstrap 5.3.8 verwendet.
---
## Gruppenmitglieder
## Anforderungen & Features
* Florin Gartmann
* Daniela Studer-Müller
* Adrian Joost
### Funktionale Anforderungen
| Feature | Beschreibung |
|---------|-------------|
| **Benutzerverwaltung** | Benutzer können ein Konto erstellen und erhalten ein eindeutiges Passwort |
| **Spielmechanik** | Zufällige Texte werden angezeigt und müssen nach Ablauf einer Zeitspanne reproduziert werden |
| **Score-System** | Automatische Bewertung basierend auf korrekt eingegebenen Wörtern mit Punkt-Vergabe |
| **Persönliche Scores** | Nutzer können alle ihre bisherigen Scores ansehen und verwalten |
| **Globales Leaderboard** | Echtzeit-Anzeige der Top 10 Spieler mit ihren besten Scores |
| **Nachrichten-System** | Nutzer können sich gegenseitig Nachrichten/Challenges schreiben |
---
## Installation & Setup
### Voraussetzungen
- Moderner Webbrowser (Chrome, Firefox, Safari, Edge)
- Node.js (optional, nur für lokale Backend-Entwicklung)
- Zugriff auf die Backend-API (`config-service.js` für API-Konfiguration)
### Schnellstart
```bash
# 1. Repository klonen
git clone <repository-url>
cd lorem_ipsum
# 2. Abhängigkeiten installieren (falls Backend vorhanden)
npm install
# 3. Applikation starten
# Option A: Mit Live-Server (VS Code Extension)
# Rechtsklick auf index.html → "Open with Live Server"
# Option B: Mit Python (falls vorhanden)
python -m http.server 8000
# Dann öffnen: http://localhost:8000
# Option C: Mit Node.js
npx http-server
```
### Backend-Konfiguration
Die API-Endpoints sind in `assets/src/service/config-service.js` konfiguriert:
```javascript
// config-service.js
export const API_BASE_URL = "https://api.example.com";
export const API_VERSION = "v1";
```
---
## Verwendung
### Für neue Benutzer
1. **Account erstellen**: Auf der Startseite auf "Registrieren" klicken
2. **Login**: Mit dem erhaltenen Passwort anmelden
3. **Spiel spielen**: "Spiel Starten" wählen
- Text wird 15 Sekunden lang angezeigt
- Nach Ablauf Text reproduzieren
- Automatische Bewertung wird angezeigt
4. **Scores verwalten**: Persönliche Scores einsehen und ggf. auf Leaderboard hochladen
5. **Leaderboard**: Top 10 Spieler in Echtzeit betrachten
6. **Nachrichten**: Mit anderen Spielern kommunizieren oder Challenges stellen
### Beispiel-Workflows
**Workflow 1: Account erstellen**
```
Home → Login/Registrieren → Username eingeben → Username und Passwort speichern
```
**Workflow 2: Leaderboard ansehen**
```
Home → Leaderboard → Top 10 wird geladen und angezeigt
```
---
## Projektstruktur
```
lorem_ipsum/
├── index.html # Startseite
├── README.md # Dokumentation (diese Datei)
├── pages/
│ ├── login.html # Login/Registrierung
│ ├── home.html # Startseite nach Login
│ ├── play.html # Spielseite
│ ├── scores.html # Persönliche Scores
│ ├── leaderboard.html # Globales Leaderboard
│ └── messages.html # Nachrichts-/Challenge-System
├── js/
│ ├── login.js # Login-Logik & Event-Handler
│ ├── play.js # Spiel-Logik (Timer, Text-Vergleich)
│ ├── leaderboard.js # Leaderboard-Rendering
│ ├── navigation.js # Navigations-Controls
│ └── messages.js # Nachrichten-Funktionalität
├── assets/
│ ├── css/
│ │ └── custom.css # Custom-Styles
│ ├── src/
│ │ ├── service/
│ │ │ ├── user-service.js # User-API-Aufrufe (Login, Register)
│ │ │ ├── leaderboard-service.js # Leaderboard-API-Aufrufe
│ │ │ ├── score-service.js # Score-Management
│ │ │ ├── message-service.js # Nachrichten-API
│ │ │ ├── challenge-service.js # Challenge-API
│ │ │ └── config-service.js # API-Konfiguration & Konstanten
│ │ └── sites/
│ │ └── exampleAPI.js # API-Test/Beispiel
│ └── bootstrap-5.3.8-dist/ # Bootstrap Framework (v5.3.8)
└── pages/
└── [weitere Pages wie oben]
```
### Dateibenennungs-Konventionen
- **HTML-Dateien**: `kebab-case` (z.B. `login.html`, `play.html`)
- **JavaScript-Dateien**: `kebab-case` (z.B. `login.js`, `play.js`, `user-service.js`)
- **Service-Dateien**: Suffix `-service.js` (z.B. `score-service.js`, `leaderboard-service.js`)
- **CSS-Klassen**: Bootstrap-Utilities + Custom Selektoren; BEM bei komplexen Komponenten (z.B. `.play-challenge-result__title`)
---
## Technologie-Stack
| Layer | Technologie | Version | Begründung |
|-------|-------------|---------|-----------|
| **Markup** | HTML5 | 5 | Semantische Struktur, barrierefreundlich |
| **Styling** | Bootstrap CSS | 5.3.8 | Responsive Grid, vordefinierte Komponenten, Accessibility |
| **Custom CSS** | CSS3 | - | Flexbox/Grid für Layout-Feinheiten, Custom Properties |
| **Frontend-Logik** | Vanilla JavaScript | ES6+ | Keine externen Abhängigkeiten nötig, vollständige Kontrolle |
| **API-Kommunikation** | Fetch API | - | Modern, Promise-basiert, Error-Handling via try/catch |
| **Versionsverwaltung** | Git | - | Nachvollziehbarer Entwicklungsverlauf |
### Warum Vanilla JS statt Framework?
- Projekt-Anforderungen sind moderat (keine komplexe State-Verwaltung nötig)
- Fetch API mit async/await bietet ausreichende Abstraktionen
- Schnellere Ladezeiten ohne Framework-Overhead
- Volles Verständnis über den Code ohne "Black Box"-Effekte
### Warum Bootstrap?
- Responsive Design out-of-the-box (12er Grid-System)
- Umfangreiches Komponenten-Portfolio (Modals, Forms, Cards)
- WCAG Level A Compliance bereits implementiert
- Konsistentes Design über alle Seiten hinweg
---
## Architektur & Technische Entscheidungen
### Service-orientierte Architektur
Die Anwendung folgt einer **Service-orientierten Architektur**:
```
UI Layer (HTML/CSS)
↓
Event Handler (login.js, play.js, ...)
↓
Service Layer (user-service.js, score-service.js, ...)
↓
Fetch API → Backend REST API
```
**Vorteile:**
- **Separation of Concerns**: Jeder Service hat eine klare Verantwortung
- **Wiederverwendbarkeit**: Services können von mehreren Seiten genutzt werden
- **Testbarkeit**: Services können isoliert getestet werden
- **Wartbarkeit**: API-Änderungen erfordern nur Anpassung in einem Ort
### Datenfluss beim Spielen
```javascript
1. play.js: generateGameText() // Zufälligen Text lokal generieren
2. play.js: Timer starten (15s)
3. User tippt Text ein
4. play.js: Wort-für-Wort-Vergleich nach Position
5. score-service.postScore() // Score zum Server senden
6. UI zeigt Ergebnis sofort an, Speichern läuft asynchron
```
### Authentifizierungs-Design
**Besonderheit: Backend generiert Passwörter statt User-Input**
```
Konventionell (problematisch): Unser Ansatz (bewusst gewählt):
User gibt Passwort ein → Backend generiert zufälliges Passwort
Risiko: User nimmt häufig genutztes → Keine Passwort-Reuse-Gefahr
Passwort → Für diese Session gültig
```
**Begründung dieser Entscheidung:**
1. **Sicherheitsausrichtung**: Nutzer gefährden kein häufig genutztes Passwort (Lernaspekt: User-Sicherheit)
2. **Frontend-Fokus**: Komplexe Auth-Logik (Hashing, Salting) sind nicht im scope dieses Moduls
3. **Transparenz**: Diese Limitierung ist im Code und README dokumentiert – nicht versteckt
**Konsequenzen für OWASP:**
- ⚠️ localStorage speichert plaintext-Passwort (A07:2021 – nicht konform)
- ✅ Aber: Generierte Passwörter sind Wegwerf-Token, kein häufig genutztes Passwort
### HTML5 Semantik
Alle HTML-Dateien nutzen semantisch korrekte Elemente:
```html
<header> <!-- Navigation und Kopfzeile -->
<main>
<section> <!-- Logische Abschnitte -->
<article> <!-- Spielinhalte -->
<form> <!-- Benutzer-Input -->
<footer> <!-- Impressum, Credits -->
```
---
## Sicherheit
### OWASP-Risiken im Kontext dieser Anwendung
#### 1. **Cross-Site Scripting (XSS)** – A03:2021
**Risiko**: Nutzer-Input (Scores, Nachrichten) könnte als Code interpretiert werden
**Implementierte Maßnahmen:**
```javascript
// ✅ SICHER: Text-Encoding statt HTML-Parsing
const scoreElement = document.createElement('div');
scoreElement.textContent = userScore; // textContent encodiert automatisch
// ❌ NICHT SICHER: scoreElement.innerHTML = userScore
// ✅ SICHER: Template Literals mit textContent
const formattedScore = `User: ${userName}`; // nie mit innerHTML
```
**Begründung**: `textContent` und DOM-APIs encodieren automatisch; `innerHTML` mit Benutzerdaten ist ein XSS-Vektor.
#### 2. **Authentifizierung & Session-Management** – A07:2021
**Risiko**: Passwort-Speicherung im localStorage, plaintext-Übertragung als Custom-Header
**Implementierte Maßnahmen:**
- ✅ API nutzt HTTPS (TLS-Verschlüsselung für Übertragung)
- ✅ localStorage mit Auth-Daten nur clientseitig (nicht persistent auf Server)
**OWASP-Perspektive – nicht konform:**
```javascript
// ❌ Passwort unverschlüsselt im localStorage
localStorage.setItem('auth', JSON.stringify({
username: user,
password: generatedPassword
}));
// ✅ Produktiv würde man verwenden:
// - HTTP-Only Cookies (vom Server gesetzt, nicht via JS zugreifbar)
// - JWT mit Refresh-Token-Rotation
// - OAuth 2.0 / OpenID Connect
```
**Begründung dieser Limitierung**: Siehe Abschnitt [Authentifizierungs-Design](#authentifizierungs-design) in der Architektur. Die Designentscheidung, dass das Backend Passwörter generiert, minimiert das Reuse-Risiko. Auth-Komplexität ist Backend-Responsibility.
---
## KI-Werkzeuge & deren Einsatz
### ChatGPT / Claude – Code-Review & Debugging
**Einsatzbereiche:**
- Fehlersuche in asynchronen Promise-Ketten
- Code-Style-Verbesserungen (ES6+ Best Practices)
- Regex-Optimierungen für Text-Vergleich
- Generierung visueller Assets: Logo, Icon sowie Challenge-Grafiken für Gewonnen/Verloren/Unentschieden wurden mit ChatGPT erstellt und anschließend im Projekt eingebunden
**Kritische Bewertung:**
- ✅ **Effektiv für**: Schnelle Fehlerbehebung, Best-Practice-Vorschläge
- ⚠️ **Vorsicht**: KI-Vorschläge nicht blind übernehmen, Logik selbst verstehen
- ✅ **Angewendet**: Alle KI-Vorschläge wurden auf Korrektheit geprüft
### GitHub Copilot – Auto-Completion
**Einsatzbereiche:**
- Service-Boilerplate-Code (Fetch-Aufrufe, Error-Handling)
- Wiederholte DOM-Manipulationen
**Kritische Bewertung:**
- ✅ **Hilfreich für**: Reduktion von Boilerplate-Code
- ⚠️ **Problematisch**: Code-Qualität variiert, manchmal ineffiziente Patterns
- ✅ **Angewendet**: Nur nach manueller Prüfung und Refactoring integriert
---
## Herausforderungen & Lerneffekte
### 🔴 Herausforderungen
#### 1. **Text-Vergleich mit Sonderzeichen**
**Problem**: Unterschiedliche Behandlung von Umlauten, Leerzeichen, Satzzeichen
```
Original: "Café"
User-Input: "cafe" // Accent wird nicht erkannt
```
**Lösung**:
- Normalisierung mit `String.prototype.normalize('NFD')`
- Regelwerk für Sonderzeichen-Ignorieren
- **Gelernt**: Unicode-Handling in JavaScript ist komplex
#### 2. **Asynchrone State-Verwaltung**
**Problem**: Race-Conditions bei mehreren parallelen API-Calls
```javascript
// ❌ PROBLEMATISCH
const data1 = fetch('/users'); // Promise 1
const data2 = fetch('/scores'); // Promise 2
// Welche Promise löst sich zuerst auf?
```
**Lösung**:
- `Promise.all()` für parallele Aufrufe
- `async/await` für sequenzielle Aufrufe
- Globale Loading-States um UI zu synchronisieren
- **Gelernt**: Promise-Sequenzierung ist essentiell für konsistente UI
#### 3. **Responsive Design auf mobilen Geräten**
**Problem**: Bootstrap Grid bricht bei sehr kleinen Viewports zusammen
**Lösung**:
- Custom Breakpoints mit CSS Media Queries
- Flexbox für flexible Card-Layouts
- Touch-friendly Button-Größen (min 44x44px)
- **Gelernt**: Mobile-first Approach hätte von Anfang an helfen sollen
### 🟢 Lerneffekte
| Bereich | Erkenntnis |
|---------|-----------|
| **Fetch API & Error-Handling** | `try/catch` bei Async/Await ist unmissbar; HTTP 400/500 Responses sind nicht automatisch Exceptions |
| **DOM-Manipulation** | Event-Delegation spart Code; `querySelector` ist ausreichend für diese Projekt-Größe |
| **State Management** | Ohne centralized Store (Redux, Vuex) führt komplexe State schnell zu Bugs; globale Variablen sind anfällig |
| **Git Workflow** | Feature-Branches + aussagekräftige Commit-Messages machen Debugging später viel einfacher |
| **Accessibility** | WCAG nicht als "nice-to-have" sehen; frühe Integration spart viel Refactoring |
| **Testing-Ansatz** | Manuelles Testen auf mehreren Browsern/Geräten ist zeitaufwendig; automatisierte Tests würden helfen |
### 💡 Was würde anders gemacht werden
1. **Service Layer von Anfang an**: Hätte API-Changes sehr vereinfacht
2. **TypeScript**: Würde viele Typo-Fehler early-stage finden
3. **Unit-Tests**: Für Score-Logik und Text-Vergleich empfohlen
4. **CSS-Präprozessor** (SASS): Für komplexere Styling-Szenarien hilfreich
---
## Code-Kommentierung & Qualität
### Kommentierung-Standard
```javascript
// ✅ KURZ & AUSSAGEKRÄFTIG (bevorzugt)
// Vergleiche Texte zeichenweise und zähle korrekte Wörter
function compareTexts(original, userInput) { ... }
// ❌ ÜBERFLÜSSIG (code ist selbsterklärend)
// Inkrementiere counter um 1
counter++;
// ⚠️ NUR FÜR NON-OFFENSICHTLICHES
// Normalisiere Unicode-Sequenzen, da Nutzer-Input oft Umlaute enthält (z.B. "Café")
const normalized = str.normalize('NFD');
```
### Naming-Konventionen
- Funktionen: **Verb + Substantiv** → `getRandomText()`, `compareScores()`
- Variablen: **aussagekräftig** → `userInputText` (nicht `txt` oder `u`)
- Konstanten: **UPPER_SNAKE_CASE** → `MAX_TEXT_LENGTH = 5000`
- Private Funktionen: **Prefix `_`** → `_calculateScore()` (Convention only)
---
## Team
| Name | Rolle & Verantwortungsbereich |
|------|-------------------------------|
| *Adrian Joost* | *Projektleitung & Architektur*: Gesamtüberblick, Projektinitialisierung, Definition der Schnittstellen sowie Analyse von Sicherheitslücken und Edge-Cases (inkl. „Cheating“-Szenarien). |
| *Daniela Studer-Müller* | *Core-Game-Logic*: Implementierung der Spielmechanik, Text-Generierung sowie Entwicklung der Message- und Challenge-Logik. |
| *Florin Gartmann* | *Score-System & Ranking*: Entwicklung der Bewertungslogik (Scoring-Algorithmus) und Implementierung des globalen Leaderboards. |
---
## Lizenz
Dieses Projekt ist für Ausbildungszwecke entwickelt worden.
---
## Weitere Ressourcen
- [Bootstrap 5 Dokumentation](https://getbootstrap.com/docs/5.3/)
- [MDN: Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
- [OWASP Top 10](https://owasp.org/www-project-top-ten/)
**Zuletzt aktualisiert:** 2026-05-24
+575
View File
@@ -0,0 +1,575 @@
body {
background: #f0f4f8;
color: #1b1b2f;
font-family: 'Gill Sans', 'Gill Sans MT', 'Calibri', 'Trebuchet MS', sans-serif;
line-height: 1.6;
margin-bottom: 1rem;
padding: 0;
}
/* Navigation Styles */
.navbar {
background: linear-gradient(90deg, #1b1b2f, #4a6fa5)
}
.navbar .nav-link {
color: #fff;
transition: color 0.3s, background-color 0.3s, border-color 0.3s;
margin: 0 5px;
border: 2px solid transparent;
border-radius: 6px;
}
.navbar .nav-link:hover {
background-color: rgba(255, 209, 102, 0.7);
color: #1b1b2f;
border-color: rgba(255, 209, 102, 0.9);
padding: 5px 10px;
}
.navbar .nav-link.active {
background-color: #ffd166;
color: #1b1b2f;
font-weight: bold;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages {
background-color: #dc3545;
color: #ffffff;
font-weight: bold;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages {
background-color: #dc3545;
color: #ffffff;
font-weight: bold;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages::after {
content: "";
display: inline-block;
width: 8px;
height: 8px;
margin-left: 8px;
border-radius: 50%;
background: #ffffff;
}
/* Main content styles */
.container-dashboard {
flex-wrap: wrap;
justify-content: center;
gap: 20px;
padding: 20px;
}
/* Cards/Scores styles */
.container > div:not(.modal) {
background-color:#ffffff;
border-radius: 12px;
box-shadow: 0 4px 15px rgba(0,0,0,0.1);
padding: 25px;
flex: 1 1 100%;
transition: transform 0.3s, box-shadow 0.3s;
}
.container > div:not(.modal):hover {
transform: translateY(-5px);
box-shadow: 0 10px 25px rgba(0,0,0,0.2);
}
/* Keep Bootstrap modal sizing/layout intact */
#password-modal {
padding: 0;
background: transparent;
box-shadow: none;
border-radius: 0;
font-size: 1rem;
}
#password-modal .modal-dialog {
max-width: 560px;
}
/* Überschriften und Abstände */
h1, h2, h3, h4, h5, h6 {
margin-top: 1rem;
margin-bottom: 20px;
color: #1b1b2f;
}
p {
margin-top: 0.5rem;
margin-bottom: 1rem;
color: #333;
}
/* Button Styles */
.btn {
background-color: #4a6fa5;
color: #fff;
border: none;
padding: 10px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 16px;
transition: background-color 0.3s;
}
.btn:hover {
background-color: #2b4a7c;
}
.btn:disabled,
.btn.disabled {
background-color: #adb5bd;
color: #495057;
cursor: not-allowed;
opacity: 1;
}
.btn-danger {
background-color: #a84848;
color: #fff;
border: none;
padding: 10px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 16px;
transition: background-color 0.3s;
}
.btn-danger:hover {
background-color: #8a3b3b;
}
#page-wrapper {
display: flex;
min-height: 100vh;
font-family: 'Segoe UI', sans-serif;
}
/* Sidebar Styles */
#sidebar {
width: 240px;
min-height: auto;
background: linear-gradient(180deg, #1b1b2f, #4a6fa5);
color: white;
padding: 25px;
}
#sidebar .nav-link {
margin: 0.5rem 0;
transition: color 0.3s, background-color 0.3s, border-color 0.3s;
color: white;
padding: 5px 10px;
border: 2px solid transparent;
border-radius: 6px;
}
#sidebar .nav-link:hover {
color: #1b1b2f;
background-color: rgba(255, 209, 102, 0.7);
border-color: rgba(255, 209, 102, 0.9);
border-radius: 6px;
}
#sidebar .nav-link.active {
color: #1b1b2f;
font-weight: bold;
background-color: #ffd166;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
#logo_img {
max-width: 300px;
width: 50%;
height: auto;
}
#main-area {
flex: 1;
background: #f3f4f6;
display: flex;
flex-direction: column;
}
/* Topbar Styles */
#topbar {
height: 70px;
background: white;
padding: 0px 30px;
display: flex;
justify-content: space-between;
align-items: center;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
#main-content {
background-color: #f0f4f8;
padding: 30px;
}
/* Card Styles */
.card {
background: white;
border-radius: 12px;
box-shadow: 0 5px 15px rgba(0,0,0,0.08);
padding: 25px;
margin-bottom: 20px;
}
.card h2 {
margin-bottom: 10px;
}
/* Responsive Styles */
@media (max-width: 768px) {
body {
font-size: 0.9rem;
}
.container > div:not(.modal) {
flex: 1 1 calc(50% - 40px);
}
#page-wrapper {
flex-direction: column;
}
#sidebar {
width: 100%;
display: flex;
overflow-x: auto;
}
#sidebar .nav-link {
flex: 0 0 auto;
margin: 0 10px;
}
}
@media (min-width: 1200px) {
body {
font-size: 1.1rem;
}
.container > div:not(.modal) {
flex: 1 1 calc(25% - 40px);
}
p.columns{
column-count: 2;
column-gap: 2rem;
}
#sidebar .nav-link {
flex: 0 0 auto;
margin: 0 15px;
}
}
/* Table styles leaderboard */
.leaderboard-table {
border-collapse: collapse;
width: 100%;
background: #ffffff;
border-radius: 10px;
overflow: hidden;
font-size: 1rem;
}
.leaderboard-table th,
.leaderboard-table td {
padding: 8px;
text-align: left;
border-bottom: 1px solid #ddd;
font-size: 16px;
}
.leaderboard-table thead th {
background: #1b1b2f;
color: #ffffff;
font-weight: 600;
letter-spacing: 0.02em;
}
.leaderboard-table tbody tr {
transition: background-color 0.2s ease;
}
.leaderboard-table tbody tr:nth-child(even) {
background-color: #f7f9fc;
}
.leaderboard-table tbody tr:hover {
background-color: #dbe6f7;
}
.leaderboard-table tbody tr.leaderboard-row-current-user,
.leaderboard-table tbody tr.leaderboard-row-current-user:nth-child(even),
.leaderboard-table tbody tr.leaderboard-row-current-user:hover {
background-color: #dff3df;
}
.leaderboard-table tbody tr.leaderboard-row-current-user td {
font-weight: 600;
}
.leaderboard-table tbody tr.leaderboard-row-gap td {
border-bottom: none;
padding: 0;
height: 16px;
background: transparent;
}
.leaderboard-table tbody tr.leaderboard-row-gap:hover,
.leaderboard-table tbody tr.leaderboard-row-gap:hover td {
background: transparent;
}
.leaderboard-table tbody tr.leaderboard-row-current-user-extra td {
border-top: 2px solid #b8dfb8;
}
.leaderboard-table tbody tr:last-child td {
border-bottom: none;
}
/* Messages */
.container > .messages-card:not(.modal),
.messages-card {
text-align: left;
font-size: 1rem;
}
.container > .messages-card:not(.modal):hover,
.messages-card:hover {
transform: none;
}
.messages-header,
.messages-inbox-title {
display: flex;
align-items: center;
justify-content: space-between;
gap: 1rem;
}
.messages-panel {
background: #f8f9fa;
border: 1px solid #dbe3ef;
border-radius: 8px;
padding: 18px;
}
.messages-panel h3 {
font-size: 1.1rem;
margin: 0 0 14px;
}
.messages-user-list {
display: grid;
gap: 10px;
}
.messages-user-button {
width: 100%;
border: 1px solid #c9d6e8;
border-radius: 6px;
background: #ffffff;
color: #1b1b2f;
padding: 10px 12px;
text-align: left;
transition: background-color 0.2s, border-color 0.2s;
}
.messages-user-button:hover {
background: #e8f0fb;
border-color: #4a6fa5;
}
.message-form textarea {
resize: vertical;
}
.message-list {
display: grid;
gap: 12px;
}
.message-item {
border-left: 4px solid #4a6fa5;
border-radius: 8px;
background: #ffffff;
padding: 12px 14px;
}
.message-item-unread {
border-left-color: #dc3545;
background: #fff4f4;
}
.challenge-message-group {
border-left-color: #6f7fb7;
}
.challenge-thread {
display: grid;
gap: 8px;
margin-top: 12px;
border-top: 1px solid #e5e7eb;
padding-top: 10px;
}
.challenge-thread.d-none {
display: none;
}
.challenge-thread-toggle {
border: none;
background: transparent;
color: #4a6fa5;
display: inline-flex;
font-size: 0.9rem;
font-weight: 600;
margin-top: 10px;
padding: 0;
}
.challenge-thread-toggle:hover {
color: #2b4a7c;
text-decoration: underline;
}
.challenge-thread-item {
border-radius: 6px;
background: #f8fafc;
padding: 8px 10px;
}
.challenge-thread-item span {
display: block;
color: #64748b;
font-size: 0.82rem;
margin-bottom: 4px;
}
.message-meta {
display: flex;
justify-content: space-between;
gap: 1rem;
color: #1b1b2f;
font-size: 0.9rem;
margin-bottom: 8px;
}
.message-meta span,
.messages-empty {
color: #667085;
}
.message-item p,
.messages-empty {
margin: 0;
}
.challenge-status-button:disabled {
background-color: #e5e7eb;
border: 1px solid #cbd5e1;
color: #64748b;
}
.challenge-result-graphic,
.play-challenge-result {
margin-top: 12px;
border-radius: 8px;
border: 1px solid #dbe3ef;
background: #ffffff;
overflow: hidden;
}
.challenge-result-headline,
.play-challenge-result-title {
padding: 10px 14px;
font-weight: 700;
color: #ffffff;
}
.challenge-outcome {
align-items: center;
background: #f8fafc;
display: flex;
gap: 12px;
padding: 14px;
}
.challenge-outcome img {
border-radius: 8px;
height: 72px;
object-fit: cover;
width: 72px;
}
.challenge-outcome strong {
color: #1b1b2f;
font-size: 1.5rem;
}
.challenge-outcome-win {
background: #e8f7ee;
}
.challenge-outcome-loss {
background: #fdecec;
}
.challenge-outcome-draw {
background: #eef3fb;
}
.challenge-result-win,
.play-challenge-result-winner .play-challenge-result-title {
background: #198754;
}
.challenge-result-draw,
.play-challenge-result-draw .play-challenge-result-title {
background: #4a6fa5;
}
.play-challenge-result-loser .play-challenge-result-title {
background: #a84848;
}
.challenge-result-scores,
.play-challenge-result-scores {
display: grid;
grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 1px;
background: #dbe3ef;
}
.challenge-result-score,
.play-challenge-result-score {
display: grid;
gap: 4px;
background: #ffffff;
padding: 12px;
}
.challenge-result-score span,
.play-challenge-result-score span {
color: #4a6fa5;
font-size: 1.25rem;
font-weight: 700;
}
.challenge-hint {
display: inline-block;
margin-top: 8px;
border-radius: 6px;
background: #fff4cc;
color: #1b1b2f;
padding: 6px 10px;
font-size: 0.95rem;
font-weight: 600;
}
@media (max-width: 768px) {
.messages-header,
.messages-inbox-title,
.message-meta {
align-items: flex-start;
flex-direction: column;
}
.challenge-result-scores,
.play-challenge-result-scores {
grid-template-columns: 1fr;
}
}
+4 -4
View File
@@ -1,7 +1,7 @@
var exampleLog = () => {
console.log('This is an example log message.');
}
console.log("This is an example log message.");
};
var aFunctionCall = () => {
alert('You have clicked the primary button!');
}
alert("You have clicked the primary button!");
};
+95
View File
@@ -0,0 +1,95 @@
/**
* Service-Klasse für Duelle/Herausforderungen (Challenge Service).
* Ermöglicht das Erstellen und Abschließen von direkt verlinkten Challenges im Backend.
*/
class ChallengeService {
/**
* Erstellt eine Instanz des ChallengeService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "challenges";
}
/**
* Erstellt eine neue Herausforderung für einen gegnerischen Spieler.
* @param {string} username - Name des herausfordernden Spielers.
* @param {string} password - Passwort des herausfordernden Spielers.
* @param {string} opponent - Name des herausgeforderten Spielers.
* @param {string} text - Der Rundentext und optionale Zusatznachrichten.
* @returns {Promise<Object>} Ein Promise mit den erstellten Challenge-Details im Body.
*/
async postChallenge(username, password, opponent, text) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
opponent: opponent,
text: text,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postChallenge");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Schließt eine bestehende Herausforderung ab, indem das Spielergebnis übermittelt wird.
* @param {string} username - Name des Spielers, der die Challenge abschließt.
* @param {string} password - Passwort des Spielers.
* @param {string|number} challengeId - Eindeutige ID der Challenge im Backend.
* @param {number} score - Die erreichte Punktzahl.
* @param {number} time - Die benötigte Zeit in Sekunden.
* @param {string} text - Der Originaltext der Challenge-Runde.
* @param {string} userWrittenText - Der vom Spieler eingegebene Text.
* @returns {Promise<Object>} Ein Promise mit der Bestätigung und dem berechneten Ergebnis.
*/
async completeChallenge(username, password, challengeId, score, time, text, userWrittenText) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${challengeId}/complete`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
score: score,
time: time,
text: text,
userWrittenText: userWrittenText,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in completeChallenge");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.ChallengeService = ChallengeService;
+12
View File
@@ -0,0 +1,12 @@
/**
* Konfiguration für die Backend-Verbindung.
* Enthält die Basis-URL für alle API-Anfragen der Anwendung.
*/
const config = {
// Die Basis-URL des Backends, an die alle REST-Anfragen gesendet werden.
API_BASE_URL: "https://webdev.iten-web.ch/10001/api/"
}
// Globales Konfigurationsobjekt im window-Scope registrieren,
// damit alle anderen Service-Klassen darauf zugreifen können.
window.config = config;␍
+45
View File
@@ -0,0 +1,45 @@
/**
* Service-Klasse für die Bestenliste (Leaderboard Service).
* Kapselt den REST-API-Aufruf zur Abfrage der globalen Highscore-Liste.
*/
class LeaderboardService {
/**
* Erstellt eine Instanz des LeaderboardService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "leaderboard";
}
/**
* Ruft einen Ausschnitt der globalen Bestenliste ab (Paging).
* @param {number} offset - Der Startindex der abzufragenden Einträge (0-basiert).
* @param {number} limit - Die maximale Anzahl der zurückzugebenden Einträge (z.B. 10 für Top 10).
* @returns {Promise<Object>} Ein Promise mit der Liste der Top-Spieler im Body.
*/
async getLeaderboard(offset, limit) {
const response = await fetch(
`${this.baseUrl}${this.urlTail}?offset=${offset}&limit=${limit}`,
{
method: "GET",
},
);
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getLeaderboard");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.LeaderboardService = LeaderboardService;
+145
View File
@@ -0,0 +1,145 @@
/**
* Service-Klasse für das Nachrichtensystem (Message Service).
* Ermöglicht den Abruf und Versand von Systemnachrichten und Herausforderungen (Challenges)
* sowie das Ändern des Gelesen-Status von Nachrichten.
*/
class MessageService {
/**
* Erstellt eine Instanz des MessageService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "messages";
}
/**
* Lädt alle Nachrichten (eingehend und ausgehend) für den authentifizierten Benutzer.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit der Liste aller Nachrichten im Body.
*/
async getMessages(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "GET",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getMessages");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Sendet eine Nachricht (oder eine eingebettete Challenge) an einen anderen Benutzer.
* @param {string} username - Der Benutzername des Senders.
* @param {string} password - Das Passwort des Senders.
* @param {string} recipient - Der Empfänger der Nachricht.
* @param {string} type - Der Typ der Nachricht (z. B. "standard" oder "challenge").
* @param {string} text - Der eigentliche Textinhalt (kann eingebettete Challenge-JSON-Daten enthalten).
* @returns {Promise<Object>} Ein Promise mit der Antwort des Servers im Body.
*/
async postMessage(username, password, recipient, type, text) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
recipient: recipient,
type: type,
text: text,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postMessage");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Markiert eine spezifische Nachricht als gelesen.
* @param {string} username - Der Benutzername des Empfängers.
* @param {string} password - Das Passwort des Empfängers.
* @param {string|number} messageId - Eindeutige ID der Nachricht.
* @returns {Promise<Object>} Ein Promise mit dem Resultat der PATCH-Anfrage.
*/
async markMessageAsRead(username, password, messageId) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${messageId}/read`, {
method: "PATCH",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in markMessageAsRead");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Markiert alle ungelesenen Nachrichten des Benutzers auf einmal als gelesen.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit dem Status der Bulk-Operation.
*/
async markAllMessagesAsRead(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/read`, {
method: "PATCH",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in markAllMessagesAsRead");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.MessageService = MessageService;
+112
View File
@@ -0,0 +1,112 @@
/**
* Service-Klasse für die Spielstände (Score Service).
* Kapselt alle REST-Anfragen an das Backend zur Speicherung und zum Laden von Scores.
*/
class ScoreService {
/**
* Erstellt eine Instanz des ScoreService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "score";
}
/**
* Lädt alle Scores eines bestimmten Benutzers.
* @param {string} username - Der Name des Benutzers, dessen Scores geladen werden sollen.
* @returns {Promise<Object>} Ein Promise mit der Liste aller Benutzer-Scores im Body.
*/
async getScoreByName(username) {
// Hinweis: Wenn der Benutzer nicht existiert, liefert das Backend einen Status 200
// mit einem leeren Array statt eines 404-Fehlers.
const response = await fetch(`${this.baseUrl}${this.urlTail}/${username}`, {
method: "GET",
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getScoreByName");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Speichert einen neu erzielten Score im Backend.
* @param {string} username - Benutzername des Spielers.
* @param {string} password - Passwort des Spielers zur Autorisierung.
* @param {number} score - Die erreichte Punktzahl (Anzahl korrekter Wörter).
* @param {number} time - Die für die Eingabe benötigte Zeit in Sekunden.
* @param {string} text - Der vorgegebene Originaltext der Spielrunde.
* @param {string} userWrittenText - Der vom Benutzer eingegebene Text.
* @returns {Promise<Object>} Ein Promise mit der Antwort des Servers (inkl. vergebenem Rang im Body).
*/
async postScore(username, password, score, time, text, userWrittenText) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
score: score,
time: time,
text: text,
userWrittenText: userWrittenText,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postScore");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Löscht ein bestimmtes Score-Ergebnis anhand seiner ID (falls vom Backend unterstützt).
* @param {string} username - Benutzername des Spielers.
* @param {string} password - Passwort des Spielers zur Autorisierung.
* @param {string|number} scoreId - Die eindeutige ID des zu löschenden Scores.
* @returns {Promise<Object>} Ein Promise mit dem Resultat der Löschung.
*/
async deleteScore(username, password, scoreId) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${scoreId}`, {
method: "DELETE",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in deleteScore");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.ScoreService = ScoreService;
+134
View File
@@ -0,0 +1,134 @@
/**
* Service-Klasse für die Benutzerverwaltung (User Service).
* Kapselt alle REST-Anfragen an das Backend bezüglich Login, Registrierung,
* Abfrage aller Benutzer und Löschung von Konten.
*/
class UserService {
/**
* Erstellt eine Instanz des UserService.
* @param {Object} config - Das globale Konfigurationsobjekt (enthält API_BASE_URL).
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "user";
}
/**
* Authentifiziert einen Benutzer und ruft dessen Kontoinformationen ab.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit dem HTTP-Status, dem OK-Flag und den Benutzerdaten (Body).
*/
async getUser(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "GET",
headers: {
// Authentifizierung erfolgt über benutzerdefinierte HTTP-Header
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getUser");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Ruft eine Liste aller im System registrierten Benutzer ab (z. B. für die Challenge-Auswahl).
* @param {string} username - Der Benutzername des anfragenden Benutzers.
* @param {string} password - Das Passwort des anfragenden Benutzers.
* @returns {Promise<Object>} Ein Promise mit der Benutzerliste im Response-Body.
*/
async getUsers(username, password) {
const response = await fetch(`${this.baseUrl}users`, {
method: "GET",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getUsers");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Löscht das eigene Benutzerkonto unwiderruflich aus dem System.
* @param {string} username - Der Benutzername des zu löschenden Kontos.
* @param {string} password - Das Passwort des Kontos.
* @returns {Promise<Object>} Ein Promise mit dem Status der Löschoperation.
*/
async deleteUser(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "DELETE",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in deleteUser");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Registriert einen neuen Benutzer im System. Das Passwort wird vom Backend generiert und zurückgegeben.
* @param {string} username - Der gewünschte neue Benutzername.
* @returns {Promise<Object>} Ein Promise mit den erstellten Account-Daten (inkl. generiertem Passwort) im Body.
*/
async postUser(username) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
username: username,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postUser");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.UserService = UserService;
+122
View File
@@ -0,0 +1,122 @@
const userService = new UserService(config);
const scoreService = new ScoreService(config);
const leaderboardService = new LeaderboardService(config);
document.addEventListener("DOMContentLoaded", () => {
const usernameForm = document.getElementById("usernameForm");
const loginForm = document.getElementById("loginForm");
const postFormScore = document.getElementById("postScoreForm");
const getScoreForm = document.getElementById("getScoreForm");
const deleteScoreForm = document.getElementById("deleteScoreForm");
const getLeaderboardForm = document.getElementById("getLeaderboardForm");
usernameForm.addEventListener("submit", handleUsernameSubmit);
loginForm.addEventListener("submit", handleLoginSubmit);
postFormScore.addEventListener("submit", handlePostScoreSubmit);
getScoreForm.addEventListener("submit", handleGetScoreSubmit);
deleteScoreForm.addEventListener("submit", handleDeleteScoreSubmit);
getLeaderboardForm.addEventListener("submit", handleGetLeaderboardSubmit);
});
async function handleUsernameSubmit(event) {
event.preventDefault();
const username = document.getElementById("desiredUsername").value;
console.log("Username form submitted:", username);
const result = userService.postUser(username);
console.log("API response:", result);
}
async function handleLoginSubmit(event) {
event.preventDefault();
const username = document.getElementById("username").value;
const password = document.getElementById("password").value;
console.log("Login form submitted:", username, password);
const result = await userService.getUser(username, password);
console.log("API response:", result);
}
async function handleDeleteUserSubmit(event) {
event.preventDefault();
const username = document.getElementById("username").value;
const password = document.getElementById("password").value;
console.log("Delete User form submitted:", username, password);
const result = await userService.deleteUser(username, password);
console.log("API response:", result);
}
async function handlePostScoreSubmit(event) {
event.preventDefault();
const username = document.getElementById("username").value;
const password = document.getElementById("password").value;
const score = document.getElementById("score").value;
const time = document.getElementById("time").value;
const text = document.getElementById("text").value;
const userWrittenText = document.getElementById("userWrittenText").value;
console.log(
"Post Score form submitted:",
username,
password,
score,
time,
text,
userWrittenText,
);
const result = await scoreService.postScore(
username,
password,
score,
time,
text,
userWrittenText,
);
console.log("API response:", result);
}
async function handleGetScoreSubmit(event) {
event.preventDefault();
const username = document.getElementById("scoreUsername").value;
console.log("Get Score form submitted:", username);
const result = await scoreService.getScoreByName(username);
console.log("API response:", result);
}
async function handleDeleteScoreSubmit(event) {
event.preventDefault();
const username = document.getElementById("username").value;
const password = document.getElementById("password").value;
const scoreId = document.getElementById("scoreId").value;
console.log("Delete Score form submitted:", username, password, scoreId);
const result = await scoreService.deleteScore(username, password, scoreId);
console.log("API response:", result);
}
async function handleGetLeaderboardSubmit(event) {
event.preventDefault();
const offset = document.getElementById("offset").value;
const limit = document.getElementById("limit").value;
console.log("Get Leaderboard form submitted:", offset, limit);
const result = await leaderboardService.getLeaderboard(offset, limit);
console.log("API response:", result);
}
Binary file not shown.
+494
View File
@@ -0,0 +1,494 @@
# API Specification
This document describes the REST API endpoints for user creation, score
submission, and leaderboard access.
## Authentification
The password for an account must exclusivly be generated by the backend server and the user is never allowed to change or recover it. If they loose the password, they loose access to the account. This is done, in order to avoid any legal issues or bad consequences for the user as the authentification is never encrypted. (This is a design choice, because the focus of the project is not authentification, but frontend desgin.)
Authentification is done via the headers, that send username and password as plain strings.
**Authentication Headers (required)**
- X-Username
- X-Password
## Base URL
/api
------------------------------------------------------------------------
## 1. User
### GET
**Endpoint**
GET /user
**Description** Authorizes on the server with the header, and returns 201 if successfull or 401 if unauthorized.
**Response**
Status: 201 if authentificated successfully,
Status: 401 if authentification failed
### POST
**Endpoint**
POST /user
**Request Body**
``` json
{
"username": "string"
}
```
**Description** Creates a new user with the given username. The backend
generates a password automatically (or sets it to "1234"). Does not require authentification.
**Response (UserDTO)**
``` json
{
"name": "string",
"password": "string"
}
```
**Error Response (ErrorDTO)**
If a user with that name already exists, it should return a 400.
``` json
{
"status": 400,
"message": "Nutzer mit Name {username} existiert bereits."
}
```
### DELETE
**Endpoint**
DELETE /user
**Description** Deletes the user and all the scores submitted by them. The user to delete should be the one who authentificates themselfs in the header.
**Response**
``` json
{
"message": "User {username} existiert nicht mehr.",
}
```
### GET all users
**Endpoint**
GET /users
**Description** Returns all existing users so the frontend can show a list of possible challenge recipients. Requires authentication.
**Authentication Headers (required)**
- X-Username
- X-Password
**Response (List\<UserListItemDTO\>)**
``` json
[
{
"username": "string"
}
]
```
Alternative response shape accepted by the frontend:
``` json
[
{
"name": "string"
}
]
```
**Status Codes**
- 200 if users were loaded successfully
- 401 if authentication failed
------------------------------------------------------------------------
## 2. Score
### GET
**Endpoint**
GET /score/{username}
**Description** Returns all score entries for the specified user. Does not require authentification.
**Response List\<ScoreDTO\>**
``` json
[
{
"username": "string",
"score": 0,
"time": 0,
"text": "string",
"userWrittenText": "string",
"place": 0,
}
]
```
### POST
**Endpoint**
POST /score
**Request Body**
``` json
{
"score": 0,
"time": 0,
"text": "string",
"userWrittenText": "string"
}
```
**Description** Submits a new score entry for a user. The score is a float (the higher, the better). If two scores are the same, the entity with the lower time is better. If time is also the same, the first entity submitted is better. In race-conditions, we don't care.
**Response (ScoreDTO)**
The response should return the created object. It should give the place, the score lands on.
``` json
{
"username": "string",
"id": 0,
"score": 0,
"time": 0,
"text": "string",
"userWrittenText": "string",
"place": 0,
}
```
### DELETE
**Endpoint**
DELETE /score/{id}
**Description** Deletes a score with the given id. Only the user that submitted the score can delete it. If the score does not exist, the response should return successfully, if the user is authenticated. Otherwise, it should return a 401.
**Response**
``` json
{
"message": "Score mit Id {Id} existiert nicht mehr.",
}
```
------------------------------------------------------------------------
## 3. Get Leaderboard
**Endpoint**
GET /leaderboard?offset={offset}&limit={limit}
**Query Parameters** - `offset` (number): Starting position - `limit`
(number): Number of results to return
**Description** Returns leaderboard entries ordered by: 1. Score
(descending) 2. Time (ascending) 3. Date of submition (ascending). Does not require authentification.
**Response (List\<ScoreDTO\>)** Returns a list of the same objects submitted via
`/submitScore`.
``` json
[
{
"username": "string",
"id": 0,
"score": 0,
"time": 0,
"text": "string",
"userWrittenText": "string",
"place": 0,
}
]
```
------------------------------------------------------------------------
## 4. Messages / Challenges
Messages are used for user-to-user challenges. A challenge is just a message with `type: "challenge"`.
All message endpoints require authentication via the existing headers.
**Authentication Headers (required)**
- X-Username
- X-Password
### GET messages
**Endpoint**
GET /messages
**Description** Returns all messages relevant for the authenticated user. The response should include received messages and may also include sent messages, so the frontend can show a complete conversation history. The frontend uses this endpoint on page load and polls it regularly to turn the navbar item "Nachrichten" red when unread messages exist.
**Response (List\<MessageDTO\>)**
``` json
[
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": false,
"createdAt": "2026-05-23T15:42:00",
"challenge": null
},
{
"id": 1,
"sender": "System",
"recipient": "string",
"type": "challenge-result",
"text": "Daniela gewinnt gegen Florin mit 18 zu 14 Punkten.",
"read": false,
"createdAt": "2026-05-23T15:48:00",
"challenge": {
"id": 5,
"challenger": "Florin",
"opponent": "Daniela",
"challengerScore": 14,
"opponentScore": 18,
"winner": "Daniela"
}
}
]
```
**Status Codes**
- 200 if messages were loaded successfully
- 401 if authentication failed
### POST message
**Endpoint**
POST /messages
**Description** Creates a new message from the authenticated user to another existing user. The sender must be taken from the authentication headers, not from the request body.
**Request Body (CreateMessageDTO)**
``` json
{
"recipient": "string",
"type": "challenge",
"text": "string"
}
```
**Response (MessageDTO)**
``` json
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": false,
"createdAt": "2026-05-23T15:42:00"
}
```
**Status Codes**
- 201 if the message was created successfully
- 400 if recipient, type, or text is missing or invalid
- 401 if authentication failed
- 404 if the recipient user does not exist
### PATCH single message as read
**Endpoint**
PATCH /messages/{id}/read
**Description** Marks one received message as read. Only the recipient of the message is allowed to mark it as read.
**Response (MessageDTO)**
``` json
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": true,
"createdAt": "2026-05-23T15:42:00"
}
```
**Status Codes**
- 200 if the message was marked as read
- 401 if authentication failed
- 403 if the authenticated user is not the recipient
- 404 if the message does not exist
### PATCH all messages as read
**Endpoint**
PATCH /messages/read
**Description** Marks all received messages of the authenticated user as read. This endpoint is optional, but recommended. If it is not implemented, the frontend can call `PATCH /messages/{id}/read` for each unread message.
**Response**
``` json
{
"message": "Alle Nachrichten wurden als gelesen markiert."
}
```
**Status Codes**
- 200 if all received messages were marked as read
- 401 if authentication failed
------------------------------------------------------------------------
## 5. Challenges
Challenges are competitive rounds between two users. The challenged user's current reference result is sent back when the challenge is created. The challenger then plays a round. When the round is completed, the backend compares both scores and creates result messages for both users.
All challenge endpoints require authentication via the existing headers.
**Authentication Headers (required)**
- X-Username
- X-Password
### POST challenge
**Endpoint**
POST /challenges
**Description** Creates a challenge from the authenticated user against another user. The backend should determine the opponent's reference result, ideally the opponent's best score from `/score/{opponent}`. The response is used by the frontend to start the challenger into the game with the opponent score visible.
**Request Body (CreateChallengeDTO)**
``` json
{
"opponent": "string",
"text": "Ich fordere dich zu einer Lorem-Ipsum-Challenge heraus!"
}
```
**Response (ChallengeDTO)**
``` json
{
"id": 0,
"challenger": "string",
"opponent": "string",
"opponentScore": 18,
"opponentScoreId": 42,
"status": "open",
"createdAt": "2026-05-23T15:42:00"
}
```
**Backend behavior**
- The sender/challenger must be taken from the authentication headers.
- `opponentScore` should be the opponent's best available score.
- If the opponent has no score yet, return `opponentScore: 0` or reject with 409. Returning 0 is easier for the frontend.
- The backend may also create an informational message for the opponent that they were challenged.
**Status Codes**
- 201 if the challenge was created successfully
- 400 if opponent is missing or invalid
- 401 if authentication failed
- 404 if the opponent user does not exist
- 409 optional, if the opponent has no score and the backend does not want to use 0
### POST complete challenge
**Endpoint**
POST /challenges/{id}/complete
**Description** Completes an open challenge with the authenticated user's played result. The backend compares challenger and opponent scores and creates a `challenge-result` message for both users.
**Request Body (CompleteChallengeDTO)**
``` json
{
"score": 14,
"time": 15,
"text": "string",
"userWrittenText": "string"
}
```
**Response (ChallengeResultDTO)**
``` json
{
"id": 0,
"challenger": "Florin",
"opponent": "Daniela",
"challengerScore": 14,
"opponentScore": 18,
"winner": "Daniela",
"status": "completed",
"completedAt": "2026-05-23T15:48:00",
"messages": [
{
"id": 10,
"recipient": "Florin",
"type": "challenge-result"
},
{
"id": 11,
"recipient": "Daniela",
"type": "challenge-result"
}
]
}
```
For a draw, `winner` can be `null` or `"draw"`.
**Backend behavior**
- Only the original challenger should be allowed to complete the challenge.
- The backend should persist the challenger's new result or link to the already persisted score if `/score` is called separately.
- After comparing the scores, the backend must create one unread result message for the challenger and one unread result message for the opponent.
- The result message should have `type: "challenge-result"` and include the nested `challenge` result object shown in `GET /messages`, so the frontend can render the winner/loser graphic.
**Status Codes**
- 200 if the challenge was completed successfully
- 400 if score data is missing or invalid
- 401 if authentication failed
- 403 if the authenticated user is not allowed to complete the challenge
- 404 if the challenge does not exist
- 409 if the challenge was already completed
+310
View File
@@ -0,0 +1,310 @@
<!doctype html>
<html lang="de">
<head>
<title>My Web Page</title>
<meta charset="UTF-8" />
<link
rel="stylesheet"
href="assets/bootstrap-5.3.8-dist/css/bootstrap.min.css"
/>
<link
rel="stylesheet"
href="assets/css/custom.css"
/>
</head>
<body class="bg-light">
<div class="container mt-5">
<div class="row">
<!-- AuthForm-->
<div class="col-md-12">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Login Form</h4>
<form id="loginForm">
<div class="mb-3">
<label
for="username"
class="form-label"
>Username</label
>
<input
type="text"
class="form-control"
id="username"
placeholder="Enter username"
/>
</div>
<div class="mb-3">
<label
for="password"
class="form-label"
>Password</label
>
<input
type="password"
class="form-control"
id="password"
placeholder="Enter password"
/>
</div>
<button
type="submit"
class="btn btn-success"
>
Login
</button>
</form>
</div>
</div>
</div>
</div>
<!-- User Endpoint -->
<div class="container mt-5">
<h2 class="text-center mb-4">User endpoint</h2>
<div class="row">
<!-- Post User -->
<div class="col-md-6">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Username Form</h4>
<form id="usernameForm">
<div class="mb-3">
<label
for="desiredUsername"
class="form-label"
>Username</label
>
<input
type="text"
class="form-control"
id="desiredUsername"
placeholder="Enter username"
/>
</div>
<button
type="submit"
class="btn btn-primary"
>
Submit
</button>
</form>
</div>
</div>
<!-- Delete User -->
<div class="col-md-6">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Delete User</h4>
<button
class="btn btn-danger"
onclick="handleDeleteUserSubmit(event)"
>
Delete User
</button>
</form>
</div>
</div>
</div>
</div>
<!-- Score Endpoint -->
<div class="container mt-5">
<h2 class="text-center mb-4">Score endpoint</h2>
<div class="row">
<!-- Post Score -->
<div class="col-md-4">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Post Score</h4>
<form id="postScoreForm">
<div class="mb-3">
<label
for="score"
class="form-label"
>Score</label
>
<input
type="number"
class="form-control"
id="score"
placeholder="Enter score"
/>
</div>
<div class="mb-3">
<label
for="time"
class="form-label"
>Time</label
>
<input
type="number"
class="form-control"
id="time"
placeholder="Enter time"
/>
</div>
<div class="mb-3">
<label
for="text"
class="form-label"
>Text</label
>
<input
type="text"
class="form-control"
id="text"
placeholder="Enter text"
/>
</div>
<div class="mb-3">
<label
for="userWrittenText"
class="form-label"
>User Written Text</label
>
<input
type="text"
class="form-control"
id="userWrittenText"
placeholder="Enter text"
/>
</div>
<button
type="submit"
class="btn btn-primary"
>
Submit
</button>
</form>
</div>
</div>
<!-- Get Score -->
<div class="col-md-4">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Get Score</h4>
<form id="getScoreForm">
<div class="mb-3">
<label
for="scoreUsername"
class="form-label"
>Score Username</label
>
<input
type="text"
class="form-control"
id="scoreUsername"
placeholder="Enter score username"
/>
</div>
<button
type="submit"
class="btn btn-primary"
>
Get Score
</button>
</form>
</div>
</div>
<!-- Delete Score -->
<div class="col-md-4">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Delete Score</h4>
<form id="deleteScoreForm">
<div class="mb-3">
<label
for="scoreId"
class="form-label"
>ScoreId</label
>
<input
type="number"
class="form-control"
id="scoreId"
placeholder="Enter score ID"
/>
</div>
<button
type="submit"
class="btn btn-danger"
>
Delete Score
</button>
</form>
</div>
</div>
</div>
</div>
<!-- Leaderboard Endpoint -->
<div class="container mt-5">
<h2 class="text-center mb-4">Leaderboard endpoint</h2>
<div class="row">
<!-- Get Leaderboard -->
<div class="col-md-12">
<div class="card p-4 shadow-sm">
<h4 class="mb-3">Get Leaderboard</h4>
<form id="getLeaderboardForm">
<div class="mb-3">
<label
for="offset"
class="form-label"
>Offset</label
>
<input
type="number"
class="form-control"
id="offset"
placeholder="Enter offset"
/>
</div>
<div class="mb-3">
<label
for="limit"
class="form-label"
>Limit</label
>
<input
type="number"
class="form-control"
id="limit"
placeholder="Enter Limit for Leaderboard"
/>
</div>
<button
type="submit"
class="btn btn-primary"
>
Get Leaderboard
</button>
</form>
</div>
</div>
</div>
</div>
<script src="assets/bootstrap-5.3.8-dist/js/bootstrap.bundle.min.js"></script>
<script src="assets/src/service/user-service.js"></script>
<script src="assets/src/service/score-service.js"></script>
<script src="assets/src/service/leaderboard-service.js"></script>
<script src="assets/src/service/config-service.js"></script>
<script src="assets/src/sites/exampleAPI.js"></script>
</body>
</html>
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.1 MiB

BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 441 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 635 KiB

BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 111 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 144 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 118 KiB

+145 -11
View File
@@ -1,21 +1,155 @@
<!DOCTYPE html>
<html lang="de">
<head>
<title>My Web Page</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lorem Ipsum - Das Spiel</title>
<!-- Favicon -->
<link class="icon" type="image/png" href="image/icon_l.png">
<!-- Bootstrap CSS (Lokale Distribution) -->
<link rel="stylesheet" href="assets/bootstrap-5.3.8-dist/css/bootstrap.min.css">
<link rel="stylesheet" href="assets/css/custom.css">
<!-- Eigene Styles für Design-Anpassungen -->
<link rel="stylesheet" href="assets/css/custom.css?v=challenge-flow-20260528e">
<!-- Inline-CSS-Anpassungen zur Behebung von Flexbox-Layout-Verschiebungen -->
<style>
/* Sicherstellen, dass der Main-Area den ganzen Platz einnimmt */
#main-area {
display: flex;
flex-direction: column;
flex: 1; /* Füllt den verbleibenden Platz im page-wrapper */
}
/* Content soll wachsen, Footer wird nach unten gedrückt */
#main-content {
flex: 1;
}
/* Footer immer unten im Flex-Container */
footer {
margin-top: auto;
}
/* Body Padding entfernen für sauberes Dashboard-Layout */
body {
padding: 0;
overflow-x: hidden; /* Verhindert horizontales Scrollen durch Sidebar */
}
</style>
</head>
<body class="p-4">
<h1 class="text-primary">Hello From Main Page</h1>
<a href="index.html">Go to Main Page</a>
<a href="secondSite.html">Go to Second Page</a>
<br />
<button class="btn btn-primary">Primary Button</button>
<button class="btn btn-secondary" onclick="exampleLog()">Secondary Button</button>
<body>
<!-- Navigation: Navbar am oberen Bildschirmrand -->
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<div class="container-fluid">
<a class="navbar-brand" href="#">Lorem Ipsum - Das Spiel</a>
<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarNav">
<ul class="navbar-nav ms-auto">
<!-- Navigationslinks für Nachrichten (Inbox) und den Login/Registrierungsstatus -->
<li class ="nav-item"><a class="nav-link" href="#" id="navbar-messages">Nachrichten</a></li>
<li class="nav-item"><a class="nav-link" href="#" id="navbar-login">Login / Registrieren</a></li>
</ul>
</div>
</div>
</nav>
<!-- Hauptseiten-Wrapper für das Flexbox-Layout -->
<div id="page-wrapper">
<!-- Sidebar Navigation auf der linken Seite (oder einklappbar auf Mobilgeräten) -->
<nav id="sidebar" class="bg-dark text-white p-3">
<ul class="nav flex-column">
<li class="nav-item"><a class="nav-link" href="#" id="nav-home">Home</a></li>
<li class="nav-item"><a class="nav-link" href="#" id="nav-play">Spiel Starten</a></li>
<li class="nav-item"><a class="nav-link" href="#" id="nav-my-scores">Meine Scores</a></li>
<li class="nav-item"> <a class="nav-link" href="#" id="nav-leaderboard">Leaderboard</a></li>
</ul>
</nav>
<!-- Hauptbereich: Enthält Topbar, Content und Footer -->
<div id="main-area">
<!-- Topbar (Seiten-Überschrift) -->
<header id="topbar">
<h1 class="text-center mb-4">Dashboard</h1>
</header>
<!-- Dynamischer Inhalts-Container: Hier werden die HTML-Dateien aus pages/ hineingeladen -->
<main class="container mt-4" id="main-content">
<!-- Hier werden die pages.html geladen -->
</main>
<!-- Footer-Bereich mit Impressums- und Urheberrechtsangaben -->
<footer class="bg-dark text-black py-4 border-top border-secondary">
<div class="container">
<!-- Modul-Informationen -->
<div class="row mb-3">
<div class="col-12">Made with <span class="text-danger">♥</span> für das Modul Frontend
<h5 class="text-warning">Made with Bootstrap 5.3.8.</h5>
<p class="text-black small mb-0 fst-italic">
<em>„Unser Impressum ist länger als der Text, den Sie sich merken müssen.“</em>
</p>
</div>
</div>
<!-- Impressumsdetails -->
<div class="row mt-2">
<div class="col-12">
<span class="text-warning fw-bold d-block mb-2" style="font-size: 0.7rem;">Impressum</span>
<div class="text-black-50" style="font-size: 0.7rem; line-height: 1.4;">
<div class="row g-1">
<div class="col-12 col-md-6 col-lg-4">
<strong>Betreiber</strong>:&nbsp;Das Team FAD (Florin, Adi, Daniela)
</div>
<div class="col-12 col-md-6 col-lg-4">
<strong>Adresse</strong>:&nbsp;Irgendwo im Internet, Schweiz
</div>
<div class="col-12 col-md-6 col-lg-4">
<strong>Kontakt</strong>:&nbsp;schreibuns@lorem-ipsum-spiel.ch
</div>
<div class="col-12 col-md-6 col-lg-4">
<strong>Inhalt</strong>:&nbsp;Der letzte Committer
</div>
<div class="col-12 col-md-6 col-lg-4">
<strong>Datenschutz</strong>:&nbsp;Wir speichern nur Scores.
</div>
</div>
</div>
<!-- Copyright-Angabe -->
<div class="text-center mt-2">
<p class="mb-0 text-black-50" style="font-size: 0.65rem;">
&copy; 2026 Modul Frontend Projekt. Alle Rechte vorbehalten.
</p>
</div>
</div>
</div>
</div>
</footer>
</div>
</div>
<!-- JavaScript-Einbindungen -->
<!-- Bootstrap JS Bundle (Lokale Distribution) -->
<script src="assets/bootstrap-5.3.8-dist/js/bootstrap.bundle.min.js"></script>
<script src="assets/src/example.js"></script>
<!-- Backend API Services -->
<script src="assets/src/service/config-service.js"></script>
<script src="assets/src/service/user-service.js"></script>
<script src="assets/src/service/score-service.js"></script>
<script src="assets/src/service/leaderboard-service.js"></script>
<script src="assets/src/service/message-service.js"></script>
<script src="assets/src/service/challenge-service.js"></script>
<!-- Frontend Logik-Skripte -->
<script src="js/login.js"></script>
<script src="js/leaderboard.js"></script>
<script src="js/scores.js"></script>
<script src="js/messages.js?v=challenge-flow-20260531b"></script>
<script src="js/play.js?v=challenge-flow-20260531b"></script>
<!-- Hauptnavigations-Steuerung -->
<script src="js/navigation.js?v=challenge-flow-20260528"></script>
</body>
</html>
</html>
+225
View File
@@ -0,0 +1,225 @@
/**
* Bestenliste (Leaderboard) verwalten und anzeigen.
* Dieses Modul lädt die Top-10-Spieler vom Server. Falls der aktuell angemeldete
* Benutzer nicht in diesen Top-10 vertreten ist, lädt es zusätzlich dessen
* persönliches Bestergebnis und zeigt dieses optisch getrennt darunter an.
*/
/**
* Formatiert Sekunden in ein lesbares MM:SS Format (z.B. 75 Sekunden -> "1:15").
* Bei ungültigen Werten wird ein Strich ausgegeben.
* @param {number} seconds - Anzahl Sekunden.
* @returns {string} Formatiertes Zeit-String.
*/
function formatTime(seconds) {
if (typeof seconds !== "number" || Number.isNaN(seconds)) {
return "-";
}
const minutes = Math.floor(seconds / 60);
const remainingSeconds = Math.floor(seconds % 60);
return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
}
/**
* Holt die aktuellen Authentifizierungsdaten aus dem globalen Auth-Modul.
* @returns {Object|null} Auth-Objekt (mit username) oder null.
*/
function getLoggedInAuth() {
if (!window.AppAuth || typeof window.AppAuth.getAuth !== "function") {
return null;
}
const auth = window.AppAuth.getAuth();
if (!auth || !auth.username) {
return null;
}
return auth;
}
/**
* Normalisiert einen Benutzernamen (Trimming und Kleinschreibung) für robuste Vergleiche.
* @param {string} username - Der Benutzername.
* @returns {string} Der bereinigte Benutzername.
*/
function normalizeUsername(username) {
return String(username ?? "").trim().toLowerCase();
}
/**
* Ermittelt den normalisierten Benutzernamen des aktuell angemeldeten Benutzers.
* @returns {string|null} Der bereinigte Name oder null.
*/
function getLoggedInUsername() {
const auth = getLoggedInAuth();
if (!auth) {
return null;
}
return normalizeUsername(auth.username);
}
/**
* Ermittelt den anzuzeigenden Rang eines Bestenlisten-Eintrags.
* Nutzt vorrangig den vom Backend gelieferten Platz ("place"), andernfalls den Listenindex.
* @param {Object} entry - Der Listeneintrag.
* @param {number} index - Der Listenindex.
* @returns {number} Der anzuzeigende Rang.
*/
function getDisplayedRank(entry, index) {
const place = Number(entry?.place);
if (!Number.isNaN(place) && place > 0) {
return place;
}
return index + 1;
}
/**
* Ermittelt das beste Ergebnis aus einer Liste von Scores.
* Sortiert nach Score (absteigend) und bei Gleichstand nach Zeit (aufsteigend).
* @param {Array<Object>} entries - Eine Liste von Score-Einträgen.
* @returns {Object|null} Der beste Score-Eintrag.
*/
function getBestScoreEntry(entries) {
return entries
.slice()
.sort((a, b) => {
const scoreA = Number(a.score ?? 0);
const scoreB = Number(b.score ?? 0);
if (scoreB !== scoreA) {
return scoreB - scoreA;
}
const timeA = Number(a.time ?? Number.MAX_SAFE_INTEGER);
const timeB = Number(b.time ?? Number.MAX_SAFE_INTEGER);
return timeA - timeB;
})[0] ?? null;
}
/**
* Holt das beste Ergebnis des aktuell angemeldeten Benutzers aus dem Backend.
* @param {string} username - Der Benutzername des eingeloggten Spielers.
* @returns {Promise<Object|null>} Das beste Spielergebnis oder null.
*/
async function getCurrentUserLeaderboardEntry(username) {
if (!window.ScoreService || !username) {
return null;
}
const scoreService = new window.ScoreService(window.config);
const result = await scoreService.getScoreByName(username);
if (!result.ok || !Array.isArray(result.body) || result.body.length === 0) {
return null;
}
return getBestScoreEntry(result.body);
}
/**
* Rendert die Bestenliste im DOM.
* Hebt die Zeile des aktuell angemeldeten Benutzers farblich hervor.
* Falls extraUserEntry übergeben wird (wenn der User nicht in den Top-10 ist),
* wird am Ende eine Trennzeile und der Eintrag des Benutzers angehängt.
* @param {Array<Object>} entries - Die Top-10 Leaderboard-Einträge.
* @param {Object|null} extraUserEntry - Der separate Bestenlisten-Eintrag des angemeldeten Benutzers.
*/
function renderLeaderboard(entries, extraUserEntry = null) {
const tableBody = document.getElementById("leaderboard-body");
if (!tableBody) {
return;
}
const loggedInUsername = getLoggedInUsername();
tableBody.innerHTML = "";
// Rendern der Top-10
entries.forEach((entry, index) => {
const row = document.createElement("tr");
const rowUsername = normalizeUsername(entry.username);
// Zeile grün hervorheben, wenn es sich um den eigenen Account handelt
if (loggedInUsername && rowUsername === loggedInUsername) {
row.classList.add("leaderboard-row-current-user");
}
row.innerHTML = `
<td>${getDisplayedRank(entry, index)}</td>
<td>${entry.username ?? "-"}</td>
<td>${formatTime(entry.time)} min</td>
<td>${entry.score ?? "-"}</td>
`;
tableBody.appendChild(row);
});
// Wenn der User eingeloggt ist, aber nicht in den Top-10 vertreten war, hängen wir ihn unten an
if (extraUserEntry) {
// Optische Lücke (Leerzeile) einfügen
const spacerRow = document.createElement("tr");
spacerRow.classList.add("leaderboard-row-gap");
spacerRow.innerHTML = '<td colspan="4"></td>';
tableBody.appendChild(spacerRow);
// Zeile des angemeldeten Benutzers anhängen
const userRow = document.createElement("tr");
userRow.classList.add("leaderboard-row-current-user");
userRow.classList.add("leaderboard-row-current-user-extra");
userRow.innerHTML = `
<td>${getDisplayedRank(extraUserEntry, 0)}</td>
<td>${extraUserEntry.username ?? "-"}</td>
<td>${formatTime(extraUserEntry.time)} min</td>
<td>${extraUserEntry.score ?? "-"}</td>
`;
tableBody.appendChild(userRow);
}
}
/**
* Lädt die Top-10-Bestenliste vom Backend und prüft,
* ob der angemeldete Benutzer separat geladen werden muss.
*/
async function loadTopTenLeaderboard() {
const leaderboardService = new window.LeaderboardService(window.config);
// Holt die Bestenliste beginnend bei Rang 1 (Offset 0) mit maximal 10 Einträgen
const result = await leaderboardService.getLeaderboard(0, 10);
if (!result.ok || !Array.isArray(result.body)) {
renderLeaderboard([]);
return;
}
const auth = getLoggedInAuth();
let extraUserEntry = null;
if (auth && auth.username) {
const loggedInUsername = normalizeUsername(auth.username);
// Prüfen, ob der angemeldete Benutzer bereits in den Top-10 vorhanden ist
const isInTopTen = result.body.some(
(entry) => normalizeUsername(entry.username) === loggedInUsername,
);
// Wenn er nicht in den Top-10 ist, rufen wir sein bestes Ergebnis separat ab
if (!isInTopTen) {
extraUserEntry = await getCurrentUserLeaderboardEntry(auth.username);
}
}
renderLeaderboard(result.body, extraUserEntry);
}
/**
* Globale Initialisierungsfunktion, die von navigation.js aufgerufen wird,
* sobald die leaderboard.html-Teilseite geladen wurde.
*/
window.initLeaderboardPage = function initLeaderboardPage() {
loadTopTenLeaderboard().catch((error) => {
console.error("Fehler beim Laden des Leaderboards:", error);
renderLeaderboard([]);
});
};
+407
View File
@@ -0,0 +1,407 @@
/**
* Benutzer-Authentifizierung und Account-Verwaltung.
* Verwaltet den Login-Status über den LocalStorage, steuert die Anzeige im Header,
* verarbeitet Login- und Registrierungsformulare und ermöglicht das Löschen des Kontos.
*/
(function () {
// Der Schlüssel, unter dem die Benutzerdaten im LocalStorage abgelegt werden.
const AUTH_STORAGE_KEY = "loremIpsumAuth";
/**
* Liest die aktuellen Anmeldedaten aus dem LocalStorage des Browsers.
* @returns {Object|null} Ein Objekt mit {username, password} oder null, falls nicht angemeldet oder ungültig.
*/
function readAuth() {
const raw = localStorage.getItem(AUTH_STORAGE_KEY);
if (!raw) {
return null;
}
try {
const parsed = JSON.parse(raw);
// Validieren, dass die Pflichtfelder vorhanden sind
if (!parsed.username || !parsed.password) {
return null;
}
return parsed;
} catch {
// Fehler beim JSON-Parsen (z.B. manipulierte Daten) -> als nicht angemeldet behandeln
return null;
}
}
/**
* Speichert die Benutzerdaten verschlüsselt als JSON-String im LocalStorage.
* @param {string} username - Der Benutzername.
* @param {string} password - Das generierte/eingegebene Passwort.
*/
function saveAuth(username, password) {
localStorage.setItem(
AUTH_STORAGE_KEY,
JSON.stringify({ username: username, password: password }),
);
}
/**
* Entfernt die Anmeldedaten aus dem LocalStorage (Logout).
*/
function clearAuth() {
localStorage.removeItem(AUTH_STORAGE_KEY);
}
/**
* Aktualisiert die Anzeige des Benutzernamens im Header und den Login-Button.
*/
function updateHeaderUsername() {
const usernameDisplay = document.getElementById("username-display");
const navbarLogin = document.getElementById("navbar-login");
const auth = readAuth();
// Text im Header anpassen ("User: Guest" oder "User: <Name>")
if (usernameDisplay) {
usernameDisplay.textContent = auth ? "User: " + auth.username : "User: Guest";
}
// Text des Login-Links in der Navbar anpassen
if (navbarLogin) {
navbarLogin.textContent = auth ? auth.username : "Login / Registrieren";
}
}
/**
* Zeigt dem Benutzer Feedback (z. B. Fehlermeldungen) auf der Login-Seite an.
* @param {string} message - Die anzuzeigende Nachricht.
* @param {string} type - Der Bootstrap-Alert-Typ (danger, warning, success, info).
*/
function setFeedback(message, type) {
const feedback = document.getElementById("auth-feedback");
if (!feedback) {
return;
}
feedback.className = "alert alert-" + type;
feedback.textContent = message;
feedback.classList.remove("d-none"); // Alert einblenden
}
/**
* Aktualisiert den Zustand der Session-Box (Anzeige der aktuellen Anmeldung).
* Blendet die Forms aus bzw. ein und aktiviert/deaktiviert die Buttons.
*/
function updateSessionBox() {
const sessionText = document.getElementById("current-session-text");
const logoutButton = document.getElementById("logout-button");
const deleteAccountButton = document.getElementById("delete-account-button");
const currentSessionBox = document.getElementById("current-session-box");
const authFormsRow = document.getElementById("auth-forms-row");
if (!sessionText || !logoutButton || !deleteAccountButton || !currentSessionBox || !authFormsRow) {
return;
}
const auth = readAuth();
if (auth) {
// Wenn eingeloggt: Session-Info anzeigen und Buttons aktivieren
sessionText.textContent = "Eingeloggt als " + auth.username + ".";
logoutButton.disabled = false;
deleteAccountButton.disabled = false;
currentSessionBox.classList.remove("d-none");
authFormsRow.classList.remove("d-none");
} else {
// Wenn nicht eingeloggt: Info setzen und Session-Box verbergen
sessionText.textContent = "Nicht eingeloggt.";
logoutButton.disabled = true;
deleteAccountButton.disabled = true;
currentSessionBox.classList.add("d-none");
authFormsRow.classList.remove("d-none");
}
}
/**
* Hilfsfunktion zum Instanziieren des UserService.
* @returns {UserService|null} Eine UserService-Instanz oder null.
*/
function getUserService() {
if (!window.config || !window.UserService) {
return null;
}
return new window.UserService(window.config);
}
/**
* Behandelt das Absenden des Login-Formulars.
* Authentifiziert den Benutzer beim Backend und speichert die Session bei Erfolg.
* @param {Event} event - Das Submit-Event des Formulars.
*/
async function handleLoginSubmit(event) {
event.preventDefault();
const userService = getUserService();
if (!userService) {
setFeedback("User-Service konnte nicht geladen werden.", "danger");
return;
}
const usernameInput = document.getElementById("login-username");
const passwordInput = document.getElementById("login-password");
const submitButton = event.submitter; // Der geklickte Button
const username = usernameInput.value.trim();
const password = passwordInput.value.trim();
if (!username || !password) {
setFeedback("Bitte Username und Passwort eingeben.", "warning");
return;
}
// Button während der Anfrage sperren und Ladeindikator zeigen
if (submitButton) {
submitButton.disabled = true;
submitButton.textContent = "Einloggen...";
}
let result;
try {
result = await userService.getUser(username, password);
} catch (error) {
console.error("Login fehlgeschlagen:", error);
setFeedback("Login fehlgeschlagen: Backend ist nicht erreichbar.", "danger");
if (submitButton) {
submitButton.disabled = false;
submitButton.textContent = "Einloggen";
}
return;
}
// Button wieder freigeben
if (submitButton) {
submitButton.disabled = false;
submitButton.textContent = "Einloggen";
}
if (result.ok) {
// Login erfolgreich: Daten speichern, Ansicht aktualisieren und zur Startseite leiten
saveAuth(username, password);
setFeedback("Login erfolgreich.", "success");
updateSessionBox();
updateHeaderUsername();
// Falls das Navigationsmenü geöffnet ist, dessen Status aktualisieren
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
// Kurze Verzögerung für visuelles Feedback vor dem Seitenwechsel
setTimeout(function() {
if (typeof window.loadPage === "function") {
window.loadPage("home", "nav-home");
}
}, 500);
return;
}
if (result.status === 401) {
setFeedback("Login fehlgeschlagen: Username oder Passwort ist falsch.", "danger");
return;
}
setFeedback("Login fehlgeschlagen (Status " + result.status + ").", "danger");
}
/**
* Behandelt das Absenden des Registrierungsformulars.
* Sendet den gewünschten Benutzernamen ans Backend, welches das Passwort generiert.
* Zeigt das Passwort anschließend in einem Bootstrap-Modal an, da es nur einmalig sichtbar ist.
* @param {Event} event - Das Submit-Event des Formulars.
*/
async function handleRegisterSubmit(event) {
event.preventDefault();
const userService = getUserService();
if (!userService) {
setFeedback("User-Service konnte nicht geladen werden.", "danger");
return;
}
const usernameInput = document.getElementById("register-username");
const username = usernameInput.value.trim();
if (!username) {
setFeedback("Bitte einen Username eingeben.", "warning");
return;
}
const result = await userService.postUser(username);
if (result.ok && result.body) {
// Registrierung erfolgreich: Antwortdaten auslesen
const createdName = result.body.name || username;
const createdPassword = result.body.password || "";
// Direkt einloggen mit den erhaltenen Daten
saveAuth(createdName, createdPassword);
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
// Modal mit den generierten Zugangsdaten befüllen
const modalUsername = document.getElementById("modal-username");
const modalPassword = document.getElementById("modal-password");
if (modalUsername) modalUsername.textContent = createdName;
if (modalPassword) modalPassword.textContent = createdPassword;
// Das Passwort-Modal anzeigen
const passwordModalElement = document.getElementById("password-modal");
if (passwordModalElement) {
const passwordModal = new window.bootstrap.Modal(passwordModalElement);
// Nach Schließen des Modals automatisch auf die Startseite weiterleiten
passwordModalElement.addEventListener("hidden.bs.modal", function handleClose() {
if (typeof window.loadPage === "function") {
window.loadPage("home", "nav-home");
}
passwordModalElement.removeEventListener("hidden.bs.modal", handleClose);
});
passwordModal.show();
} else {
// Fallback, falls das Bootstrap-Modal im DOM nicht gefunden wurde
setFeedback(
"Account erstellt. Username: " + createdName + ", Passwort: " + createdPassword,
"success",
);
setTimeout(function() {
if (typeof window.loadPage === "function") {
window.loadPage("home", "nav-home");
}
}, 1500);
}
// Formularfelder für eventuelle spätere Logins vorausfüllen
const loginUsernameInput = document.getElementById("login-username");
const loginPasswordInput = document.getElementById("login-password");
if (loginUsernameInput && loginPasswordInput) {
loginUsernameInput.value = createdName;
loginPasswordInput.value = createdPassword;
}
return;
}
// Fehlerbehandlung
if (result.status === 400) {
const errorMessage = result.body && result.body.message
? result.body.message
: "Dieser Username existiert bereits.";
setFeedback(errorMessage, "danger");
return;
}
setFeedback(
"Account konnte nicht erstellt werden (Status " + result.status + ").",
"danger",
);
}
/**
* Loggt den aktuellen Benutzer aus (löscht Auth-Daten aus LocalStorage und aktualisiert UI).
*/
function handleLogout() {
clearAuth();
setFeedback("Du wurdest ausgeloggt.", "info");
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
}
/**
* Behandelt das Löschen des eigenen Accounts.
* Fordert eine Sicherheitsbestätigung an, sendet die Löschanfrage ans Backend
* und führt bei Erfolg einen automatischen Logout aus.
*/
async function handleDeleteAccount() {
const auth = readAuth();
if (!auth) {
setFeedback("Du bist nicht eingeloggt.", "warning");
return;
}
// Sicherheitsabfrage im Browser
const wantsDelete = window.confirm(
"Möchtest du den Account \"" + auth.username + "\" wirklich löschen?",
);
if (!wantsDelete) {
return;
}
const userService = getUserService();
if (!userService) {
setFeedback("User-Service konnte nicht geladen werden.", "danger");
return;
}
const result = await userService.deleteUser(auth.username, auth.password);
if (result.ok) {
// Account erfolgreich gelöscht: Lokal ausloggen und Feedback geben
clearAuth();
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
setFeedback("Account wurde gelöscht.", "success");
return;
}
if (result.status === 401) {
setFeedback("Account konnte nicht gelöscht werden: nicht autorisiert.", "danger");
return;
}
setFeedback(
"Account konnte nicht gelöscht werden (Status " + result.status + ").",
"danger",
);
}
/**
* Initialisiert die Login-Seite.
* Bindet alle Event-Listener an die Formulare und Buttons nach dem Laden des HTML-Inhalts.
*/
function initLoginPage() {
const loginForm = document.getElementById("login-form");
const registerForm = document.getElementById("register-form");
const logoutButton = document.getElementById("logout-button");
const deleteAccountButton = document.getElementById("delete-account-button");
if (!loginForm || !registerForm || !logoutButton || !deleteAccountButton) {
return;
}
loginForm.addEventListener("submit", handleLoginSubmit);
registerForm.addEventListener("submit", handleRegisterSubmit);
logoutButton.addEventListener("click", handleLogout);
deleteAccountButton.addEventListener("click", handleDeleteAccount);
// Initialen UI-Zustand herstellen
updateSessionBox();
updateHeaderUsername();
}
// Bindet die Initialisierungsfunktion an das globale Fensterobjekt für navigation.js
window.initLoginPage = initLoginPage;
// Stellt Authentifizierungsfunktionen global bereit, damit andere Module (z. B. play.js)
// prüfen können, ob und wer eingeloggt ist.
window.AppAuth = {
getAuth: readAuth,
clearAuth: clearAuth,
};
// Beim allerersten Laden der Anwendung direkt den Header anpassen
document.addEventListener("DOMContentLoaded", updateHeaderUsername);
})();
+1188
View File
File diff suppressed because it is too large. Load diff
+95
View File
@@ -0,0 +1,95 @@
/**
* Navigation und dynamisches Laden von Einzelseiten (Single Page App Verhalten).
* Dieses Skript reagiert auf Klicks im Menü/Sidebar, lädt die gewünschte HTML-Teilseite
* per Fetch-API nach und führt die jeweilige Seite-Initialisierungsfunktion aus.
*/
document.addEventListener("DOMContentLoaded", () => {
/**
* Setzt die "active"-Klasse im Menü für die ausgewählte Seite,
* damit der Benutzer sieht, in welchem Bereich er sich befindet.
* @param {string} id - Die ID des Menü-Links (z.B. "nav-home").
*/
function setActiveMenu(id) {
// Alle Sidebar-Links zurücksetzen
document.querySelectorAll("#sidebar .nav-link").forEach(link => link.classList.remove("active"));
// Alle Navbar-Links zurücksetzen
document.querySelectorAll(".navbar-nav .nav-link").forEach(link => link.classList.remove("active"));
// Aktiven Link anhand seiner ID suchen und hervorheben
const activeLink = document.getElementById(id);
if (activeLink) activeLink.classList.add("active");
}
/**
* Lädt eine Teilseite (.html) dynamisch aus dem "pages/"-Ordner in den Hauptbereich.
* Nach dem Laden werden die DOM-Elemente initialisiert (z.B. Event-Listener gebunden),
* indem die entsprechende globale "init..."-Funktion aufgerufen wird.
* @param {string} page - Der Name der HTML-Datei (ohne Endung, z.B. "play").
* @param {string} menuId - Die ID des zugehörigen Menüpunkts zur visuellen Aktivierung.
*/
window.loadPage = function loadPage(page, menuId) {
// fetch lädt das HTML-Snippet. cache: "no-store" verhindert veraltete Stände im Browser-Cache.
fetch("pages/" + page + ".html", { cache: "no-store" })
.then(response => {
if (!response.ok) {
throw new Error("HTTP-Fehler " + response.status);
}
return response.text();
})
.then(data => {
// Das geladene HTML-Fragment in den Haupt-Container rendern
document.getElementById("main-content").innerHTML = data;
// Aktiven Menüpunkt visuell kennzeichnen
setActiveMenu(menuId);
// Da das DOM nun neu aufgebaut wurde, müssen wir die Event-Handler
// für die jeweilige Seite neu registrieren (Init-Funktionen).
if (page === "login" && typeof window.initLoginPage === "function") {
window.initLoginPage();
}
if (page === "leaderboard" && typeof window.initLeaderboardPage === "function") {
window.initLeaderboardPage();
}
if (page === "scores" && typeof window.initScoresPage === "function") {
window.initScoresPage();
}
if (page === "play" && typeof window.initPlayPage === "function") {
window.initPlayPage();
}
if (page === "messages" && typeof window.initMessagesPage === "function") {
window.initMessagesPage();
}
})
.catch(error => {
console.error("Fehler beim Laden von " + page + ":", error);
// Fehlermeldung für den Benutzer in den Hauptbereich einbetten
document.getElementById("main-content").innerHTML = "<div class='alert alert-danger'>Fehler beim Laden der Seite: " + error.message + "</div>";
});
};
// --- Menü-Verkabelung ---
// Alle Navigations-Elemente aus dem DOM abrufen
const navHome = document.getElementById("nav-home");
const navPlay = document.getElementById("nav-play");
const navMyScores = document.getElementById("nav-my-scores");
const navLeaderboard = document.getElementById("nav-leaderboard");
const navbarLogin = document.getElementById("navbar-login");
const navbarMessages = document.getElementById("navbar-messages");
// Standard-Verhalten der Links (Seiten-Reload) verhindern und loadPage() aufrufen
if (navHome) navHome.onclick = (e) => { e.preventDefault(); loadPage("home", "nav-home"); };
if (navPlay) navPlay.onclick = (e) => { e.preventDefault(); loadPage("play", "nav-play"); };
if (navMyScores) navMyScores.onclick = (e) => { e.preventDefault(); loadPage("scores", "nav-my-scores"); };
if (navLeaderboard) navLeaderboard.onclick = (e) => { e.preventDefault(); loadPage("leaderboard", "nav-leaderboard"); };
if (navbarLogin) navbarLogin.onclick = (e) => { e.preventDefault(); loadPage("login", "navbar-login"); };
if (navbarMessages) navbarMessages.onclick = (e) => { e.preventDefault(); loadPage("messages", "navbar-messages"); };
// Prüfen, ob neue ungelesene Nachrichten vorliegen, um den Nachrichten-Link rot zu markieren
if (typeof window.updateMessagesNavState === "function") window.updateMessagesNavState();
// Beim allerersten Aufruf der App die Startseite ("home") laden
loadPage("home", "nav-home");
});
+1017
View File
File diff suppressed because it is too large. Load diff
+210
View File
@@ -0,0 +1,210 @@
/**
* Eigene Ergebnisse (Scores) verwalten und anzeigen.
* Dieses Modul lädt nach der Initialisierung die bisherigen Spielergebnisse des
* eingeloggten Benutzers und stellt diese sortiert in einer Tabelle dar.
*/
(function () {
/**
* Formatiert Sekunden in ein lesbares MM:SS Format (z.B. 75 Sekunden -> "1:15").
* @param {number} seconds - Anzahl Sekunden.
* @returns {string} Formatiertes Zeit-String oder "-" bei ungültigem Wert.
*/
function formatTime(seconds) {
if (typeof seconds !== "number" || Number.isNaN(seconds)) {
return "-";
}
const minutes = Math.floor(seconds / 60);
const remainingSeconds = Math.floor(seconds % 60);
// padStart stellt sicher, dass Sekunden immer zweistellig ausgegeben werden (z.B. "05" statt "5")
return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
}
/**
* Normalisiert einen Benutzernamen (Trimming und Kleinschreibung) für robuste Vergleiche.
* @param {string} username - Der Benutzername.
* @returns {string} Der bereinigte Benutzername.
*/
function normalizeUsername(username) {
return String(username ?? "").trim().toLowerCase();
}
/**
* Holt die aktuellen Authentifizierungsdaten aus dem globalen Auth-Modul.
* @returns {Object|null} Auth-Objekt (mit username/password) oder null, falls nicht angemeldet.
*/
function getLoggedInAuth() {
if (!window.AppAuth || typeof window.AppAuth.getAuth !== "function") {
return null;
}
const auth = window.AppAuth.getAuth();
if (!auth || !auth.username || !auth.password) {
return null;
}
return auth;
}
/**
* Initialisiert und liefert eine Instanz des ScoreService.
* @returns {ScoreService|null} Eine ScoreService-Instanz oder null, falls Konfiguration fehlt.
*/
function getScoreService() {
if (!window.config || !window.ScoreService) {
return null;
}
return new window.ScoreService(window.config);
}
/**
* Ermittelt den anzuzeigenden Rang eines Score-Eintrags.
* Falls das Backend keinen Platz/Rang liefert, wird die Position in der Liste (+1) als Fallback genutzt.
* @param {Object} entry - Der Score-Eintrag.
* @param {number} index - Der Listenindex des Eintrags.
* @returns {number} Der anzuzeigende Rang (1-basiert).
*/
function getDisplayedRank(entry, index) {
const place = Number(entry?.place);
if (!Number.isNaN(place) && place > 0) {
return place;
}
return index + 1;
}
/**
* Blendet eine Feedback-Nachmeldung (Erfolg/Fehler/Info) auf der Oberfläche ein.
* @param {string} message - Der anzuzeigende Text.
* @param {string} type - Der Bootstrap-Alert-Typ (danger, warning, info, success).
*/
function setFeedback(message, type) {
const feedback = document.getElementById("scores-feedback");
if (!feedback) {
return;
}
feedback.className = "alert alert-" + type + " mb-4";
feedback.textContent = message;
feedback.classList.remove("d-none");
}
/**
* Generiert die HTML-Zeilen für die Score-Tabelle aus den geladenen Einträgen.
* Sortiert die Einträge: 1. nach Platzierung (falls vorhanden), 2. nach Score (absteigend), 3. nach Zeit (aufsteigend).
* @param {Array<Object>} entries - Liste von Score-Einträgen vom Backend.
*/
function renderScores(entries) {
const tableBody = document.getElementById("scores-body");
if (!tableBody) {
return;
}
tableBody.innerHTML = "";
// Falls keine Einträge vorhanden sind, Hinweistext ausgeben
if (!Array.isArray(entries) || entries.length === 0) {
tableBody.innerHTML = '<tr><td colspan="4" class="text-center text-muted py-4">Keine eigenen Scores gefunden.</td></tr>';
return;
}
// Kopie des Arrays anlegen und sortieren
const sortedEntries = entries.slice().sort((a, b) => {
// 1. Priorität: Offizielle Platzierung (falls vorhanden)
const placeA = Number(a?.place);
const placeB = Number(b?.place);
if (!Number.isNaN(placeA) && !Number.isNaN(placeB) && placeA !== placeB) {
return placeA - placeB;
}
// 2. Priorität: Höhere Punktzahl gewinnt
const scoreA = Number(a?.score ?? 0);
const scoreB = Number(b?.score ?? 0);
if (scoreB !== scoreA) {
return scoreB - scoreA;
}
// 3. Priorität: Bei Punktgleichheit gewinnt die schnellere Zeit
const timeA = Number(a?.time ?? Number.MAX_SAFE_INTEGER);
const timeB = Number(b?.time ?? Number.MAX_SAFE_INTEGER);
return timeA - timeB;
});
// Für jeden sortierten Eintrag eine Tabellenzeile erstellen und anhängen
sortedEntries.forEach((entry, index) => {
const row = document.createElement("tr");
row.innerHTML = `
<td>${getDisplayedRank(entry, index)}</td>
<td>${entry.username ?? "-"}</td>
<td>${formatTime(entry.time)} min</td>
<td>${entry.score ?? "-"}</td>
`;
tableBody.appendChild(row);
});
}
/**
* Fordert die Scores des Benutzers vom Backend an und filtert sie.
*/
async function loadMyScores() {
const auth = getLoggedInAuth();
// Prüfen, ob der Benutzer überhaupt eingeloggt ist
if (!auth || !auth.username) {
setFeedback("Bitte logge dich ein, um deine Scores zu sehen.", "warning");
renderScores([]);
return;
}
const scoreService = getScoreService();
if (!scoreService) {
setFeedback("Score-Service konnte nicht geladen werden.", "danger");
renderScores([]);
return;
}
try {
// Scores für diesen Namen vom Backend abrufen
const result = await scoreService.getScoreByName(auth.username);
if (!result.ok || !Array.isArray(result.body)) {
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
return;
}
// Sicherheits-Filterung: Nur Scores behalten, die exakt zum aktuell eingeloggten User passen
const ownScores = result.body.filter((entry) => {
if (!entry || !entry.username) {
return false;
}
return normalizeUsername(entry.username) === normalizeUsername(auth.username);
});
if (ownScores.length === 0) {
setFeedback("Für deinen Account wurden noch keine Scores gefunden.", "info");
}
// Scores rendern
renderScores(ownScores);
} catch (error) {
console.error("Fehler beim Laden der eigenen Scores:", error);
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
}
}
/**
* Globale Initialisierungsfunktion, die von navigation.js aufgerufen wird,
* sobald die scores.html-Teilseite erfolgreich geladen wurde.
*/
window.initScoresPage = function initScoresPage() {
loadMyScores().catch((error) => {
console.error("Fehler beim Initialisieren der Scores-Seite:", error);
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
});
};
})();␍
+14
View File
@@ -0,0 +1,14 @@
<!-- Startseite der Anwendung -->
<div class="card mb-4 text-start">
<!-- Willkommens-Überschrift und Kurzbeschreibung des Spiels -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Willkommen beim Lorem Ipsum Game</h2>
<p class="text-muted mb-0 fs-6">Teste deine Fähigkeiten im Umgang mit Lorem Ipsum Texten! Je schneller und genauer du bist, desto höher ist dein Score.</p>
</div>
<!-- Handlungsaufforderung an den Spieler -->
<p class="card-text fs-6">Wähle eine Option aus der Navigation, um zu starten. Viel Spaß beim Spielen!</p>
<!-- Projekt-Logo zentriert im unteren Bereich -->
<img id="logo_img" src="image/Logo_loremIpsum.png" alt="Lorem Ipsum Game" class="img-fluid mt-3 d-block mx-auto">
</div>
+24
View File
@@ -0,0 +1,24 @@
<!-- Rangliste (Leaderboard) - Zeigt die globalen Top-10 Spieler an -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Titel und Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Leaderboard</h2>
<p class="text-muted mb-0 fs-6">Hier siehst du ein Leaderboard mit den 10 besten Usern.</p>
</div>
<!-- Tabellarische Darstellung der besten Einträge -->
<table class="leaderboard-table">
<thead>
<!-- Spaltenköpfe für Rang, Benutzername, benötigte Zeit und Punktzahl -->
<tr>
<th>Rank</th>
<th>User</th>
<th>time</th>
<th>Score</th>
</tr>
</thead>
<!-- Tabellenkörper: Wird dynamisch zur Laufzeit durch js/leaderboard.js mit Zeilen befüllt -->
<tbody id="leaderboard-body"></tbody>
</table>
</div>
+81
View File
@@ -0,0 +1,81 @@
<!-- Account-Verwaltung (Login, Registrierung, Sitzungsanzeige) -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Account</h2>
<p class="text-muted mb-0 fs-6">Verwalte deine Sitzung und Account-Details.</p>
</div>
<!-- Alert-Box für Fehlermeldungen und Erfolgsmeldungen (wird per js/login.js gesteuert) -->
<div id="auth-feedback" class="alert d-none" role="status" aria-live="polite"></div>
<!-- Aktuelle Sitzung: Zeigt den Login-Status und bietet Buttons für Logout und Account löschen -->
<div class="card bg-light mb-3" id="current-session-box">
<h3 class="mb-2">Aktuelle Sitzung</h3>
<p class="h5 mb-2" id="current-session-text">Nicht eingeloggt.</p>
<div class="d-flex gap-2">
<button id="logout-button" type="button" class="btn btn-outline-secondary btn-sm" disabled>Logout</button>
<button id="delete-account-button" type="button" class="btn btn-danger btn-sm" disabled>Account löschen</button>
</div>
</div>
<!-- Formular-Bereich: Login und Registrierung nebeneinander (auf Desktop) -->
<div class="row g-3" id="auth-forms-row">
<!-- Linke Spalte: Login-Formular -->
<div class="col-12 col-lg-6">
<div class="card h-100">
<h3 class="mb-3">Login</h3>
<form id="login-form">
<div class="h5 mb-3">
<label for="login-username" class="form-label">Username</label>
<input id="login-username" class="form-control" type="text" required maxlength="40" autocomplete="username" />
</div>
<div class="h5 mb-3">
<label for="login-password" class="form-label">Passwort</label>
<input id="login-password" class="form-control" type="password" required maxlength="100" autocomplete="current-password" />
</div>
<button type="submit" class="btn btn-primary">Einloggen</button>
</form>
</div>
</div>
<!-- Rechte Spalte: Registrierungs-Formular -->
<div class="col-12 col-lg-6">
<div class="card h-100">
<h3 class="mb-3">Neuen Account erstellen</h3>
<form id="register-form">
<div class="h5 mb-3">
<label for="register-username" class="form-label">Gewünschter Username</label>
<input id="register-username" class="form-control" type="text" required maxlength="40" autocomplete="username" />
</div>
<button type="submit" class="btn btn-success">Account anlegen</button>
</form>
<p class="text-muted mb-0 fs-6 mt-2">Hinweis: Das Passwort wird vom Backend erstellt und bei Erfolg angezeigt.</p>
</div>
</div>
</div>
</div>
<!-- Bootstrap Modal: Zeigt das einmalig generierte Passwort nach erfolgreicher Account-Erstellung an -->
<div class="modal fade" id="password-modal" tabindex="-1" aria-labelledby="password-modal-label" aria-hidden="true">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title" id="password-modal-label">Account erfolgreich erstellt!</h5>
<button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
</div>
<div class="modal-body">
<!-- Anzeige der generierten Zugangsdaten -->
<div class="alert alert-info mb-3">
<strong>Username:</strong> <span id="modal-username"></span><br/>
<strong>Passwort:</strong> <span id="modal-password" style="font-family: monospace; background-color: #f0f0f0; padding: 4px 8px; border-radius: 4px;"></span>
</div>
<p class="text-muted small mb-0">Bitte speichere das Passwort. Du benötigst es zum Einloggen.</p>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-primary" data-bs-dismiss="modal">Weiter zur Startseite</button>
</div>
</div>
</div>
</div>␍
+61
View File
@@ -0,0 +1,61 @@
<!-- Nachrichten- und Challenge-Dashboard -->
<div class="card messages-card mb-4 text-start">
<!-- Header-Bereich mit Aktualisierungs-Button -->
<div class="messages-header mb-4">
<div>
<h2 class="fw-bold mb-1">Nachrichten</h2>
<p class="text-muted mb-0 fs-6">Fordere andere User heraus und lies eingehende Antworten.</p>
</div>
<button class="btn btn-sm" id="refresh-messages-button" type="button">Aktualisieren</button>
</div>
<!-- Platzhalter: Wird angezeigt, wenn der Benutzer nicht angemeldet ist -->
<div id="messages-login-placeholder" class="alert alert-warning mt-3 d-none">
Melde dich zuerst an, bevor du eine Nachricht verschicken kannst.
</div>
<!-- Hauptbereich der Inbox (Sichtbar wenn eingeloggt) -->
<div id="messages-content" class="d-none">
<!-- Status- und Feedbackanzeige -->
<div id="messages-feedback" class="alert d-none mt-3 mb-0" role="alert"></div>
<div class="row g-4 mt-2">
<!-- Linke Spalte: Sidebar mit der Liste aller verfügbaren Benutzer -->
<div class="col-lg-4">
<section class="messages-panel">
<h3>User</h3>
<!-- Wird zur Laufzeit per js/messages.js mit User-Schaltflächen befüllt -->
<div id="messages-user-list" class="messages-user-list"></div>
</section>
</div>
<!-- Rechte Spalte: Formular zum Erstellen von Challenges und die Inbox -->
<div class="col-lg-8">
<!-- Sektion: Challenge senden -->
<section class="messages-panel mb-4">
<h3>Challenge senden</h3>
<form id="challenge-form" class="message-form">
<label for="challenge-recipient" class="form-label">Empfaenger</label>
<select id="challenge-recipient" class="form-select mb-3"></select>
<label for="challenge-text" class="form-label">Nachricht</label>
<textarea id="challenge-text" class="form-control mb-3" rows="3">Kannst du mich schlagen? Spiel eine Runde, dann bin ich dran.</textarea>
<button class="btn" type="submit">Challenge senden</button>
</form>
</section>
<!-- Sektion: Posteingang (Liste der empfangenen/gesendeten Nachrichten) -->
<section class="messages-panel">
<div class="messages-inbox-title">
<h3>Posteingang</h3>
<button class="btn btn-sm" id="mark-read-button" type="button">Als gelesen markieren</button>
</div>
<!-- Wird dynamisch durch js/messages.js gerendert (normale Messages & Challenge-Karten) -->
<div id="message-list" class="message-list"></div>
</section>
</div>
</div>
</div>
</div>
+113
View File
@@ -0,0 +1,113 @@
<!-- Spielseite: Die vier Phasen werden dynamisch per play.js ein- und ausgeblendet. -->
<div class="game-container text-start">
<!-- Status-Header: Zeigt Titel, Challenge-Hinweise und das Status-Badge der aktuellen Spielphase (Bereit, Lernphase, Eingabe, Abgeschlossen) -->
<div class="d-flex justify-content-between align-items-md-center flex-column flex-md-row mb-4">
<div class="mb-3 mb-md-0">
<h2 class="fw-bold mb-1">Lorem Ipsum - Challenge your brain</h2>
<!-- Challenge-Hinweis: Zeigt an, gegen wen und um welchen Score gespielt wird (wird per JS eingeblendet) -->
<div id="challengeHint" class="challenge-hint d-none"></div>
<p class="text-muted mb-0 fs-6">Merken Sie sich den Text so gut wie möglich.</p>
</div>
<!-- Status-Badge der aktuellen Spielphase -->
<div id="gameStatus" class="badge bg-secondary fs-6 px-3 py-2" style="width: fit-content;">
Bereit
</div>
</div>
<!-- Phase 1: Startbildschirm vor der Textanzeige -->
<div id="phaseStart" class="card">
<div class="card-body text-center py-5">
<h3 class="mb-3">Sind Sie bereit?</h3>
<p class="mb-4" style="max-width: 600px; margin: 0 auto; font-size: 1.1rem;">
Sie sehen gleich einen Text für <strong style="color: #4a6fa5;">15 Sekunden</strong>.<br>
Versuchen Sie, sich so viele Wörter wie möglich zu merken!
</p>
<button id="btnStartGame" class="btn btn-lg px-5">
Spiel Starten
</button>
</div>
</div>
<!-- Phase 2: Lern-/Einprägephase. Der Runden-Text wird per JS in #targetTextDisplay eingefügt. -->
<div id="phaseMemorize" class="d-none">
<div class="card border-warning" style="border-left: 5px solid #ffd166; background-color: #fffbf0;">
<div class="card-body text-center py-4">
<h4 class="text-warning-emphasis mb-3" style="color: #b58900;">Lernphase läuft...</h4>
<!-- Rundentext-Anzeige -->
<p id="targetTextDisplay" class="lead fw-bold mb-4 fst-italic" style="color: #1b1b2f; font-size: 1.4rem; line-height: 1.6;">
<!-- Text wird per JS eingefügt -->
</p>
<!-- Countdown-Anzeige -->
<div class="mt-3">
<span class="badge bg-danger fs-6 px-3 py-2 blink-animation">
Verbleibende Zeit: <span id="timerDisplay">15</span>s
</span>
</div>
</div>
</div>
</div>
<!-- Phase 3: Eingabephase. Der Originaltext wird ausgeblendet und das Textfeld wird fokussiert. -->
<div id="phaseInput" class="d-none">
<div class="card">
<div class="card-body">
<label for="userTextInput" class="form-label fw-bold mb-2">Geben Sie den Text aus dem Gedächtnis ein:</label>
<!-- Eingabefeld für den gemerkten Text (Cheating-Sperren in play.js verhindern Copy/Paste) -->
<textarea id="userTextInput" class="form-control mb-3" rows="8" placeholder="Tippen Sie hier den gemerkten Text ein..."></textarea>
<div class="d-grid">
<button id="btnSubmitScore" class="btn btn-success btn-lg" style="background-color: #28a745; border: none;">
Auswerten & Absenden
</button>
</div>
</div>
</div>
</div>
<!-- Phase 4: Auswertungs- und Ergebnisphase (inklusive API-Feedback und farbigem Wortvergleich) -->
<div id="phaseResult" class="d-none">
<div class="card text-center" style="border-top: 5px solid #28a745;">
<div class="card-body py-5">
<h3 class="text-success mb-2">Ergebnis</h3>
<!-- Erzielte Punktzahl -->
<div class="display-1 fw-bold my-4" id="resultScore" style="color: #4a6fa5;">0</div>
<p class="text-muted mb-5">Punkte (korrekte Wörter an der richtigen Position)</p>
<!-- Feedback-Box für API-Antworten (wird per JS befüllt) -->
<div id="scoreSaveFeedback" class="alert d-none mb-4" role="alert"></div>
<!-- Wortvergleich: Gegenüberstellung des Originaltexts und der Eingabe -->
<div class="row g-4 text-start mb-5">
<!-- Originaltext mit rot/grünen Wort-Badges -->
<div class="col-md-6">
<div class="p-3 h-100" style="background: #f8f9fa; border-radius: 8px;">
<small class="text-muted d-block mb-2 text-uppercase fw-bold" style="font-size: 0.75rem;">Originaltext</small>
<p class="mb-0 fst-italic" id="resultOriginal" style="font-size: 0.95rem; line-height: 1.5;"></p>
</div>
</div>
<!-- Benutzereingabe mit rot/grünen Wort-Badges -->
<div class="col-md-6">
<div class="p-3 h-100" style="background: #f8f9fa; border-radius: 8px;">
<small class="text-muted d-block mb-2 text-uppercase fw-bold" style="font-size: 0.75rem;">Ihre Eingabe</small>
<p class="mb-0 fst-italic" id="resultInput" style="font-size: 0.95rem; line-height: 1.5;"></p>
</div>
</div>
</div>
<!-- Navigation nach dem Spiel -->
<div class="d-flex justify-content-center gap-3">
<button id="btnRestart" class="btn px-4">
Nochmal spielen
</button>
<button id="btnLeaderboard" class="btn px-4" style="background-color: #4a6fa5;">
Zum Leaderboard
</button>
</div>
</div>
</div>
</div>
</div>
</div>
+31
View File
@@ -0,0 +1,31 @@
<!-- Eigene Scores-Ansicht des angemeldeten Benutzers -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Titel und Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Meine Scores</h2>
<p class="text-muted mb-0 fs-6">Hier siehst du alle gespeicherten Scores deines Accounts.</p>
</div>
<!-- Alert-Box für Rückmeldungen (wird bei Fehlern/Info-Meldungen per js/scores.js eingeblendet) -->
<div id="scores-feedback" class="alert d-none mb-4" role="alert"></div>
<!-- Tabelle zur Auflistung der eigenen Scores -->
<div class="table-responsive">
<table class="table leaderboard-table mb-0">
<thead>
<tr>
<th scope="col">Rang</th>
<th scope="col">User</th>
<th scope="col">time</th>
<th scope="col">Score</th>
</tr>
</thead>
<!-- Tabellenkörper: Wird per js/scores.js mit den eigenen Ergebnissen des Users befüllt -->
<tbody id="scores-body">
<tr>
<td colspan="4" class="text-center text-muted py-4">Lade Scores ...</td>
</tr>
</tbody>
</table>
</div>
</div>␍