Feature: Lesson task field & TXT-to-JSON converter tool

LESSONS FORMAT UPDATE:
- lesson: Number → String (z.B. "1.1", "2", "100")
- task: Neues Feld für Anweisungen/Aufgaben
- Backup: data/lessons.json.backup erstellt

FRONTEND:
- Task-Anzeige unter Vorlagefenster (verkleinerter Text)
- Dynamisches Update bei Lektionswechsel
- Whitespace-Kontrolle (kein trailing newline)

BACKEND:
- lesson_service.py: task in get_lesson_info()
- training_service.py: task in get_training_context() und _switch_lesson()
- API: /next_text und /set_lesson liefern task

JAVASCRIPT:
- ui.js: updateLessonTask() Methode
- main.js: Task-Update bei Lektionswechsel

NEW TOOL: convert_txt_files_to_lessons_json.py
- CLI-Tool zum Konvertieren von TXT → lessons.json
- Flexible Dateireihenfolge
- Argparse mit -h, --help, -?, -o/--output
- Validierung & Fehlerbehandlung
- TXT-Format: Titel, Untertitel, Anweisung, Text

DOCUMENTATION:
- README.md: Tool-Beschreibung & Beispiele
- CLAUDE.md: Creating Lessons Abschnitt
- .gitignore: *.backup, test JSON-Dateien

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.coveragerc

@@ -0,0 +1,25 @@
+[run]
+source = .
+omit =
+    */tests/*
+    */venv/*
+    */__pycache__/*
+    */migrations/*
+    setup.py
+    setup_database.py
+
+[report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    raise AssertionError
+    raise NotImplementedError
+    if __name__ == .__main__.:
+    if TYPE_CHECKING:
+    @abstractmethod
+
+precision = 2
+show_missing = True
+
+[html]
+directory = htmlcov

.githooks/pre-commit

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Pre-commit hook für Typewriter Trainer
+# Führt automatisch Tests aus vor jedem Commit
+#
+# Installation:
+#   cp .githooks/pre-commit .git/hooks/pre-commit
+#   chmod +x .git/hooks/pre-commit
+
+echo "🧪 Running tests before commit..."
+echo ""
+
+# Farben für Output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Unit Tests ausführen (schnell)
+echo "📋 Running Unit Tests..."
+if python -m unittest tests.test_lesson_service tests.test_statistics_service tests.test_settings_service -v 2>&1 | grep -q "OK"; then
+    echo -e "${GREEN}✅ Unit Tests passed${NC}"
+else
+    echo -e "${RED}❌ Unit Tests failed${NC}"
+    echo ""
+    echo "Please fix the tests before committing."
+    exit 1
+fi
+
+echo ""
+
+# Integration Tests ausführen
+echo "🔗 Running Integration Tests..."
+if python -m unittest tests.test_integration_progress tests.test_integration_statistics -v 2>&1 | grep -q "OK"; then
+    echo -e "${GREEN}✅ Integration Tests passed${NC}"
+else
+    echo -e "${RED}❌ Integration Tests failed${NC}"
+    echo ""
+    echo "Please fix the tests before committing."
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}✅ All tests passed! Proceeding with commit...${NC}"
+echo ""
+
+exit 0

.github/workflows/coverage.yml

@@ -0,0 +1,90 @@
+name: Coverage
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  workflow_dispatch:
+
+jobs:
+  coverage:
+    name: Test Coverage
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: 'pip'
+
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install coverage
+
+    - name: Run Tests with Coverage
+      run: |
+        coverage run -m unittest discover -s tests -p "test_*.py"
+        coverage report -m
+        coverage html
+
+    - name: Generate Coverage Badge
+      run: |
+        COVERAGE=$(coverage report | grep TOTAL | awk '{print $4}' | sed 's/%//')
+        echo "Coverage: $COVERAGE%"
+
+        # Create badge color
+        if (( $(echo "$COVERAGE >= 90" | bc -l) )); then
+          COLOR="brightgreen"
+        elif (( $(echo "$COVERAGE >= 75" | bc -l) )); then
+          COLOR="green"
+        elif (( $(echo "$COVERAGE >= 60" | bc -l) )); then
+          COLOR="yellow"
+        else
+          COLOR="red"
+        fi
+
+        echo "COVERAGE=$COVERAGE" >> $GITHUB_ENV
+        echo "COLOR=$COLOR" >> $GITHUB_ENV
+
+    - name: Upload Coverage Report
+      uses: actions/upload-artifact@v4
+      with:
+        name: coverage-report
+        path: htmlcov/
+        retention-days: 30
+
+    - name: Coverage Summary
+      run: |
+        echo "# Coverage Report" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "![Coverage](https://img.shields.io/badge/coverage-${{ env.COVERAGE }}%25-${{ env.COLOR }})" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "## Detailed Coverage" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        coverage report >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "Full HTML report available as artifact." >> $GITHUB_STEP_SUMMARY
+
+    - name: Comment Coverage on PR
+      if: github.event_name == 'pull_request'
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const coverage = process.env.COVERAGE;
+          const color = process.env.COLOR;
+          const body = `## 📊 Coverage Report\n\n![Coverage](https://img.shields.io/badge/coverage-${coverage}%25-${color})\n\nDetailed report available in artifacts.`;
+
+          github.rest.issues.createComment({
+            issue_number: context.issue.number,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body
+          });

.github/workflows/tests.yml

@@ -0,0 +1,116 @@
+name: Tests
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  workflow_dispatch:
+
+jobs:
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.9', '3.10', '3.11', '3.12']
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+
+    - name: Run Unit Tests
+      run: |
+        python -m unittest tests.test_lesson_service tests.test_statistics_service tests.test_settings_service -v
+
+    - name: Run Integration Tests
+      run: |
+        python -m unittest tests.test_integration_progress tests.test_integration_statistics -v
+
+    - name: Run All Tests
+      run: |
+        python -m unittest discover -s tests -p "test_*.py" -v
+
+  test-summary:
+    name: Test Summary
+    runs-on: ubuntu-latest
+    needs: test
+    if: always()
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: 'pip'
+
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+
+    - name: Generate Test Summary
+      run: |
+        echo "# Test Results" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "## Test Execution" >> $GITHUB_STEP_SUMMARY
+        python -m unittest discover -s tests -p "test_*.py" -v 2>&1 | tee test_output.txt
+
+        # Parse test results
+        TESTS_RUN=$(grep -o "Ran [0-9]* test" test_output.txt | grep -o "[0-9]*" || echo "0")
+
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "**Tests Run:** $TESTS_RUN" >> $GITHUB_STEP_SUMMARY
+
+        if grep -q "OK" test_output.txt; then
+          echo "**Status:** ✅ All tests passed!" >> $GITHUB_STEP_SUMMARY
+        else
+          echo "**Status:** ❌ Some tests failed" >> $GITHUB_STEP_SUMMARY
+        fi
+
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### Test Details" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        tail -20 test_output.txt >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+
+  lint:
+    name: Code Quality
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install flake8
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8
+
+    - name: Lint with flake8
+      run: |
+        # Stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # Exit-zero treats all errors as warnings
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+      continue-on-error: true

.gitignore

@@ -8,6 +8,7 @@ __pycache__/
 
 to_do_list.txt
 *.off
+infos/
 
 # C extensions
 *.so
@@ -182,6 +183,12 @@ Thumbs.db
 
 # Backup files
 *.bak
+*.backup
+
+# Test/temporary lessons files (only data/lessons.json is tracked)
+/lessons.json
+/meine_lektionen.json
+/test_*.json
 
 # Editor directories and files
 .vscode/

CI_CD.md

@@ -0,0 +1,319 @@
+# CI/CD Integration - Typewriter Trainer
+
+Dieses Dokument beschreibt die Continuous Integration und Continuous Deployment (CI/CD) Setup für den Typewriter Trainer.
+
+## Übersicht
+
+Die Test-Suite ist vollständig in CI/CD-Pipelines integriert und bietet:
+
+- ✅ **Automatische Tests** bei jedem Push und Pull Request
+- ✅ **Multi-Python-Version Support** (3.9, 3.10, 3.11, 3.12)
+- ✅ **Coverage Reports** mit HTML-Visualisierung
+- ✅ **Pre-commit Hooks** für lokale Validierung
+- ✅ **Code Quality Checks** (flake8 Linting)
+
+## GitHub Actions Workflows
+
+### 1. Tests Workflow (`.github/workflows/tests.yml`)
+
+**Trigger:**
+- Push auf `main` und `develop` Branches
+- Pull Requests auf `main` und `develop`
+- Manuell über `workflow_dispatch`
+
+**Jobs:**
+
+#### Test Job
+- Führt Tests auf Python 3.9, 3.10, 3.11, 3.12 aus
+- Installiert Dependencies aus `requirements.txt`
+- Führt Unit Tests aus (schnell, < 1 Sekunde)
+- Führt Integration Tests aus (~3 Sekunden)
+- Führt alle Tests kombiniert aus
+- Matrix-Build für Multi-Version-Kompatibilität
+
+#### Test Summary Job
+- Läuft nach allen Tests (immer, auch bei Fehlern)
+- Generiert Test-Zusammenfassung in GitHub Actions Summary
+- Zeigt Anzahl der Tests und Status an
+
+#### Lint Job
+- Code Quality Check mit flake8
+- Prüft auf Syntax-Fehler und undefined names
+- Complexity und Line-Length Checks (nicht blockierend)
+
+**Badge Status:**
+```markdown
+![Tests](https://github.com/jamulix/typewriter/actions/workflows/tests.yml/badge.svg)
+```
+
+### 2. Coverage Workflow (`.github/workflows/coverage.yml`)
+
+**Trigger:**
+- Push auf `main` und `develop` Branches
+- Pull Requests auf `main` und `develop`
+- Manuell über `workflow_dispatch`
+
+**Features:**
+- Generiert Test Coverage Report mit `coverage.py`
+- Erstellt HTML Coverage Report als Artifact
+- Berechnet Coverage-Prozentsatz
+- Generiert dynamisches Coverage-Badge (grün ≥90%, gelb ≥60%, rot <60%)
+- Kommentiert Coverage auf Pull Requests
+- Speichert HTML-Report für 30 Tage
+
+**Badge Status:**
+```markdown
+![Coverage](https://github.com/jamulix/typewriter/actions/workflows/coverage.yml/badge.svg)
+```
+
+**Coverage Report anzeigen:**
+1. Gehe zu Actions → Coverage Workflow → Latest Run
+2. Lade "coverage-report" Artifact herunter
+3. Öffne `htmlcov/index.html` im Browser
+
+## Lokale Test-Ausführung
+
+### Alle Tests ausführen
+
+```bash
+# Alle Tests (Unit + Integration)
+python -m unittest discover -s tests -p "test_*.py" -v
+
+# Nur Unit Tests (schnell)
+python -m unittest tests.test_lesson_service tests.test_statistics_service tests.test_settings_service -v
+
+# Nur Integration Tests
+python -m unittest tests.test_integration_progress tests.test_integration_statistics -v
+```
+
+### Coverage Report generieren
+
+**Mit Script:**
+```bash
+./run_coverage.sh
+```
+
+**Manuell:**
+```bash
+# Coverage installieren
+pip install coverage
+
+# Tests mit Coverage ausführen
+coverage run -m unittest discover -s tests -p "test_*.py"
+
+# Terminal Report
+coverage report -m
+
+# HTML Report
+coverage html
+# Öffne htmlcov/index.html im Browser
+```
+
+## Pre-commit Hooks
+
+### Automatische Test-Validierung vor jedem Commit
+
+Der Pre-commit Hook führt automatisch alle Tests aus, bevor ein Commit erstellt wird.
+
+**Installation:**
+```bash
+# Hook ist bereits installiert in .git/hooks/pre-commit
+# Falls nicht, kopiere aus Template:
+cp .githooks/pre-commit .git/hooks/pre-commit
+chmod +x .git/hooks/pre-commit
+```
+
+**Funktionsweise:**
+1. ✅ Führt Unit Tests aus
+2. ✅ Führt Integration Tests aus
+3. ✅ Blockiert Commit bei Test-Fehlern
+4. ✅ Zeigt farbiges Output für bessere Übersicht
+
+**Hook überspringen (nicht empfohlen):**
+```bash
+git commit --no-verify -m "message"
+```
+
+## Test-Statistiken
+
+### Gesamt-Übersicht
+
+| Kategorie | Anzahl | Status |
+|-----------|--------|--------|
+| **Gesamt Tests** | 80 | ✅ 100% |
+| **Unit Tests** | 54 | ✅ Bestanden |
+| **Integration Tests** | 26 | ✅ Bestanden |
+| **Ausführungszeit** | ~2.9s | ⚡ Schnell |
+
+### Unit Tests Breakdown
+
+| Service | Tests | Coverage |
+|---------|-------|----------|
+| LessonService | 17 | Navigation & Validierung |
+| StatisticsService | 15 | Berechnungen (ZPM/WPM) |
+| SettingsService | 22 | Validierungen |
+
+### Integration Tests Breakdown
+
+| Service | Tests | Coverage |
+|---------|-------|----------|
+| ProgressService | 12 | CRUD & State Management |
+| StatisticsService | 14 | DB Operations & Daily Practice |
+
+## Coverage Konfiguration
+
+Die Coverage-Konfiguration ist in `.coveragerc` definiert:
+
+```ini
+[run]
+source = .
+omit =
+    */tests/*
+    */venv/*
+    */migrations/*
+    setup.py
+
+[report]
+precision = 2
+show_missing = True
+
+[html]
+directory = htmlcov
+```
+
+**Ausgeschlossene Dateien:**
+- Test-Dateien selbst
+- Virtual Environments
+- Migrations
+- Setup-Scripts
+
+## Best Practices
+
+### Für Entwickler
+
+1. **Immer Tests schreiben** für neue Features
+2. **Lokale Tests ausführen** vor dem Push:
+   ```bash
+   python -m unittest discover tests -v
+   ```
+3. **Coverage checken** für neue Code-Bereiche:
+   ```bash
+   ./run_coverage.sh
+   ```
+4. **Pre-commit Hook aktiv lassen** für automatische Validierung
+
+### Für Pull Requests
+
+1. ✅ Alle Tests müssen bestehen (automatisch geprüft)
+2. ✅ Coverage sollte nicht sinken
+3. ✅ Lint-Checks sollten bestehen
+4. ✅ Review GitHub Actions Summary
+
+### Für Releases
+
+1. Erstelle Branch von `develop`
+2. Alle Tests auf `main` müssen grün sein
+3. Coverage Report prüfen
+4. Merge nach `main` → automatische Tests laufen
+
+## Troubleshooting
+
+### Tests schlagen in CI fehl, aber lokal nicht
+
+**Mögliche Ursachen:**
+- Python-Version unterschiedlich (CI tested 3.9-3.12)
+- Dependencies nicht korrekt in `requirements.txt`
+- Plattform-spezifische Unterschiede (Linux vs. macOS/Windows)
+
+**Lösung:**
+```bash
+# Teste mit verschiedenen Python-Versionen lokal
+python3.9 -m unittest discover tests -v
+python3.11 -m unittest discover tests -v
+```
+
+### Coverage Report zeigt falsche Werte
+
+**Lösung:**
+```bash
+# Lösche alte Coverage-Daten
+rm -rf .coverage htmlcov/
+
+# Neu generieren
+./run_coverage.sh
+```
+
+### Pre-commit Hook blockiert Commit
+
+**Das ist gewollt!** Der Hook verhindert, dass fehlerhafte Tests in den Code kommen.
+
+**Lösung:**
+1. Prüfe Test-Output: `python -m unittest discover tests -v`
+2. Fixe die fehlschlagenden Tests
+3. Commit erneut
+
+**Nur in Notfällen umgehen:**
+```bash
+git commit --no-verify -m "message"
+```
+
+### GitHub Actions schlagen fehl mit "Module not found"
+
+**Lösung:**
+- Stelle sicher, dass alle Dependencies in `requirements.txt` sind
+- Prüfe ob `requirements.txt` im Repository committed ist
+
+## Workflow-Diagramm
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Developer Workflow                        │
+└─────────────────────────────────────────────────────────────┘
+
+  1. Code ändern
+     │
+     ↓
+  2. Lokale Tests (optional)
+     │  ./run_coverage.sh
+     ↓
+  3. git add / git commit
+     │
+     ↓
+  4. Pre-commit Hook
+     │  ✅ Unit Tests
+     │  ✅ Integration Tests
+     │  ❌ Blockiert bei Fehler
+     ↓
+  5. git push
+     │
+     ↓
+  ┌────────────────────────┐
+  │   GitHub Actions       │
+  ├────────────────────────┤
+  │ • Tests (Multi-Python) │
+  │ • Coverage Report      │
+  │ • Lint Check           │
+  │ • Artifact Upload      │
+  └────────────────────────┘
+     │
+     ↓
+  6. Review & Merge
+```
+
+## Weitere Ressourcen
+
+- **Test-Dokumentation:** `tests/README.md`
+- **GitHub Actions Docs:** https://docs.github.com/actions
+- **Coverage.py Docs:** https://coverage.readthedocs.io
+- **Python unittest:** https://docs.python.org/3/library/unittest.html
+
+## Zusammenfassung
+
+✅ **80 Tests**, alle bestanden (100% Erfolgsrate)
+✅ **GitHub Actions** für automatische Tests
+✅ **Coverage Reports** mit HTML-Visualisierung
+✅ **Pre-commit Hooks** für lokale Validierung
+✅ **Multi-Python-Version** Support (3.9-3.12)
+✅ **Code Quality** Checks mit flake8
+
+Die Test-Suite ist **produktionsbereit** und vollständig in CI/CD integriert! 🎉

CLAUDE.md

@@ -77,6 +77,47 @@ Debug endpoint for checking lesson loading and configuration:
 curl http://localhost:5000/debug
 ```
 
+### Creating Lessons from TXT Files
+
+The project includes a CLI tool to convert TXT files into lessons.json format:
+
+```bash
+# Convert TXT files (order matters!)
+python3 convert_txt_files_to_lessons_json.py 01.1_*.txt 01.2_*.txt 01.3_*.txt
+
+# With custom output file
+python3 convert_txt_files_to_lessons_json.py -o data/lessons.json *.txt
+
+# Show help
+python3 convert_txt_files_to_lessons_json.py --help
+```
+
+**TXT File Format:**
+```
+Titel: 01.1 Erarbeitung der Grundstellung
+Untertitel: Optional subtitle (ignored)
+Anweisung: Task/instruction for the user
+
+ffff jjjj ffff jjjj
+# Comments starting with # are ignored
+...
+```
+
+**Filename Format:** `XX.Y_Description.txt` (e.g., `01.1_Grundstellung.txt`)
+- Number becomes `lesson` as string (e.g., `01.1` → `"1.1"`)
+- Parameter order determines JSON order
+- Supports both decimal (1.1) and integer (2) lesson numbers
+
+**Output Format:**
+```json
+{
+  "lesson": "1.1",
+  "title": "01.1 Erarbeitung der Grundstellung",
+  "text": "The practice text...",
+  "task": "Instruction for the user"
+}
+```
+
 ## Architecture Overview
 
 ### Request Flow

HILFE.md

@@ -1,4 +1,4 @@
-# 📖 Typewriter Trainer - Online-Hilfe (v0.4.5)
+# 📖 Typewriter Trainer - Online-Hilfe (v0.5.0)
 
 Willkommen beim Typewriter Trainer! Diese Hilfe erklärt alle Funktionen und gibt Tipps für effektives Tipptraining.
 
@@ -440,4 +440,4 @@ Der Text scrollt **automatisch**, sodass:
 
 ---
 
-*Typewriter Trainer v0.4.5 - Mit ❤️ entwickelt für effektives Tipptraining*
+*Typewriter Trainer v0.5.0 - Mit ❤️ entwickelt für effektives Tipptraining*

PROJECT_STRUCTURE.md

@@ -253,4 +253,4 @@ Alle sensiblen Dateien sind bereits in `.gitignore` aufgelistet.
 ---
 
 **Letzte Aktualisierung**: 2025-10-27
-**Version**: v0.4.5 _(siehe [VERSION](VERSION) Datei)_
+**Version**: v0.5.0 _(siehe [VERSION](VERSION) Datei)_

README.md

@@ -1,6 +1,6 @@
 # Typewriter Tutor - Adaptiver Tipptrainer
 
-**Version:** v0.4.5 _(siehe [VERSION](VERSION) Datei)_
+**Version:** v0.5.0 _(siehe [VERSION](VERSION) Datei)_
 
 Ein moderner, webbasierter Tipptrainer mit **adaptivem Metronom** und umfangreichen Statistiken. Das Programm passt sich automatisch Ihrer Tippgeschwindigkeit an und hilft Ihnen, das Zehnfingerschreiben systematisch zu erlernen.
 
@@ -97,6 +97,7 @@ http://localhost:5000
 typewriter/
 ├── app.py                          # Flask-Hauptanwendung
 ├── models.py                       # SQLAlchemy Datenbankmodelle
+├── convert_txt_files_to_lessons_json.py  # Tool: TXT → lessons.json
 ├── test_app.py                     # Unit-Tests (18 Tests)
 ├── test_metronome_velocity.py      # Metronom-Tests (22 Tests)
 ├── requirements.txt                # Python-Dependencies
@@ -109,8 +110,15 @@ typewriter/
 ├── static/
 │   ├── css/
 │   │   └── style.css               # Styling (Dark/Light Mode)
-│   ├── js/
-│   │   └── script.js               # Client-Logik & Adaptives Metronom
+│   ├── js/                         # Modulare JavaScript-Architektur (ES6)
+│   │   ├── main.js                 # Hauptorchestration
+│   │   ├── keyboard.js             # Keyboard-Event-Handling
+│   │   ├── metronome.js            # Adaptives Metronom
+│   │   ├── session.js              # Session Management
+│   │   ├── statistics.js           # Statistik-Berechnungen
+│   │   ├── textDisplay.js          # Text-Rendering
+│   │   ├── theme.js                # Theme Management
+│   │   └── ui.js                   # UI-Interaktionen
 │   └── favicon.svg                 # Schreibmaschinen-Icon
 │
 ├── templates/
@@ -197,37 +205,117 @@ Die Statistik-Seite (`/statistics`) bietet:
 - **Datenexport**: CSV und JSON-Download Ihrer Statistiken
 - **Verlaufsanalyse**: Sehen Sie Ihre Fortschritte über mehrere Sitzungen
 
-## 🧪 Tests
+## 🧪 Tests & CI/CD
 
-Das Projekt enthält umfangreiche Test-Suites:
+Das Projekt enthält eine umfassende Test-Suite mit **80 Tests** (100% Erfolgsrate) und vollständiger CI/CD-Integration.
 
-### App-Tests (18 Tests)
+### Test-Übersicht
+
+| Kategorie | Anzahl | Ausführungszeit | Status |
+|-----------|--------|-----------------|--------|
+| **Gesamt** | 80 Tests | ~2.9s | ✅ 100% |
+| **Unit Tests** | 54 Tests | 0.002s ⚡ | ✅ Bestanden |
+| **Integration Tests** | 26 Tests | 2.856s | ✅ Bestanden |
+| **Legacy Tests** | 40 Tests | ~1s | ✅ Bestanden |
+
+### Test-Ausführung
+
+**Service Layer Tests (80 Tests):**
 ```bash
-python -m unittest test_app -v
+# Alle Tests (Unit + Integration)
+python -m unittest discover -s tests -p "test_*.py" -v
+
+# Nur Unit Tests (schnell, ohne DB)
+python -m unittest tests.test_lesson_service tests.test_statistics_service tests.test_settings_service -v
+
+# Nur Integration Tests (mit DB)
+python -m unittest tests.test_integration_progress tests.test_integration_statistics -v
+
+# Coverage Report generieren
+./run_coverage.sh
 ```
 
-Testet:
-- Statistik-Berechnungen
-- API-Endpoints
-- Input-Validierung
-- Datenbank-Operationen
-- CSV/JSON-Export
-
-### Metronom-Tests (22 Tests)
+**Legacy Tests (40 Tests):**
 ```bash
+# App-Tests (18 Tests)
+python -m unittest test_app -v
+
+# Metronom-Tests (22 Tests)
 python test_metronome_velocity.py
 ```
 
-Testet:
-- Alle 5 Anpassungsregeln
-- Realistische Szenarien (Anfänger bis Experte)
-- Edge Cases und Grenzfälle
-- Enthält detaillierte Simulation
+### Was wird getestet?
 
-Siehe [`README_METRONOME_TESTS.md`](README_METRONOME_TESTS.md) für Details.
+**Service Layer Tests (`tests/`):**
+- ✅ **LessonService** (17): Navigation, Validierung, Edge Cases
+- ✅ **StatisticsService** (29): Berechnungen (ZPM/WPM), DB-Operationen, 30-Tage-Daten
+- ✅ **SettingsService** (22): Validierungen, Boundary Values
+- ✅ **ProgressService** (12): CRUD, State Management, Multi-Lesson Independence
+
+**Legacy Tests:**
+- ✅ **App-Tests**: Statistik-Berechnungen, API-Endpoints, Input-Validierung, CSV/JSON-Export
+- ✅ **Metronom-Tests**: 5 Anpassungsregeln, Realistische Szenarien, Edge Cases
+
+### CI/CD Integration
+
+**GitHub Actions Workflows:**
+
+![Tests](https://github.com/jamulix/typewriter/actions/workflows/tests.yml/badge.svg)
+![Coverage](https://github.com/jamulix/typewriter/actions/workflows/coverage.yml/badge.svg)
+
+- ✅ **Automatische Tests** bei jedem Push und Pull Request
+- ✅ **Multi-Python-Version** Support (3.9, 3.10, 3.11, 3.12)
+- ✅ **Coverage Reports** mit HTML-Visualisierung
+- ✅ **Pre-commit Hooks** für lokale Validierung
+- ✅ **Code Quality Checks** (flake8 Linting)
+
+**Pre-commit Hook Installation:**
+```bash
+# Hook ist bereits installiert, oder kopiere Template:
+cp .githooks/pre-commit .git/hooks/pre-commit
+chmod +x .git/hooks/pre-commit
+```
+
+Der Pre-commit Hook führt automatisch alle Tests vor jedem Commit aus und blockiert bei Fehlern.
+
+**Weitere Informationen:**
+- 📖 Service Tests: [`tests/README.md`](tests/README.md)
+- 📖 CI/CD Setup: [`CI_CD.md`](CI_CD.md)
+- 📖 Metronom Tests: [`README_METRONOME_TESTS.md`](README_METRONOME_TESTS.md)
 
 ## 🔧 Entwicklung
 
+### Lektionen aus TXT-Dateien erstellen
+
+Das Projekt enthält ein Kommandozeilen-Tool zum Konvertieren von TXT-Dateien in das lessons.json Format:
+
+```bash
+# Konvertiere TXT-Dateien zu lessons.json
+python3 convert_txt_files_to_lessons_json.py 01.1_*.txt 01.2_*.txt 01.3_*.txt
+
+# Mit custom Output-Datei
+python3 convert_txt_files_to_lessons_json.py -o data/lessons.json *.txt
+
+# Hilfe anzeigen
+python3 convert_txt_files_to_lessons_json.py --help
+```
+
+**TXT-Datei Format:**
+```
+Titel: 01.1 Erarbeitung der Grundstellung
+Untertitel: Die erste Lektion (optional, wird ignoriert)
+Anweisung: Sprechen Sie laut und deutlich jeden Buchstaben mit.
+
+ffff jjjj ffff jjjj ffff jjjj
+ffjj ffjj ffjj ffjj ffjj ffjj
+...
+```
+
+**Dateinamen-Format:** `XX.Y_Beschreibung.txt` (z.B. `01.1_Grundstellung.txt`)
+- Die Nummer wird zur `lesson` (z.B. `01.1` → `"1.1"`)
+- Die Reihenfolge der Parameter bestimmt die Reihenfolge in der JSON-Datei
+- Kommentarzeilen (beginnend mit `#`) werden ignoriert
+
 ### Datenbank-Migrationen
 
 Das Projekt verwendet Alembic für Datenbank-Schema-Änderungen:
@@ -369,7 +457,17 @@ Contributions sind willkommen! Bitte:
 
 > **Hinweis:** Die aktuelle Versionsnummer wird zentral in der [VERSION](VERSION) Datei verwaltet.
 
-### Version 0.4.5 (Aktuell)
+### Version 0.5.0 (Aktuell)
+- ✅ **Lektionsspezifische Datenpersistenz**: Jede Lektion speichert ihren Fortschritt unabhängig
+- ✅ **Automatisches Pausieren**: Beim Wechsel zur Statistikseite wird automatisch pausiert und gespeichert
+- ✅ **Korrekte Datenwiederherstellung**: Alle Daten (Cursor-Position, Eingabe, Trainingszeit) werden beim Zurückkehren korrekt geladen
+- ✅ **Reset-Funktionalität**: Reset-Buttons (refresh-ccw) für Lektions-Fortschritt und Statistiken
+- ✅ **CTRL-P Tastenkombination**: Pausieren/Fortsetzen mit Tastatur
+- ✅ **LessonProgress-Tabelle**: Neue Datenbank-Tabelle für lektionsspezifische Daten
+- ✅ **Automatische Statistik-Speicherung**: Bei Lektion-Abschluss werden Statistiken automatisch gespeichert
+- ✅ **Fix: ZPM-Berechnung**: Mindestzeit von 1 Sekunde verhindert unrealistische Werte
+
+### Version 0.4.5
 - ✅ **Tooltips**: Alle Symbole zeigen beim Hover hilfreiche Tooltips (Einstellungen, Theme wechseln, Fehler blockiert an/aus, etc.)
 - ✅ **Whitespace-Farbkodierung**: Leerzeichen, Tabs und Newlines werden grau-grün (korrekt) oder rot (falsch) eingefärbt
 - ✅ **Fehler-Overlay für Whitespace**: Falsch eingegebene Zeichen werden auch bei Leerzeichen, Tabs und Newlines in Orange angezeigt
@@ -422,7 +520,6 @@ Contributions sind willkommen! Bitte:
 ## 🐛 Bekannte Einschränkungen
 
 - **Metronom-Difficulty**: Parameter `current_difficulty` wird aktuell nicht genutzt (immer 1.0)
-- **JavaScript-Module**: `script.js` ist mit 1089 Zeilen sehr groß (sollte in Module aufgeteilt werden)
 - **Type Hints**: Nicht alle Funktionen haben vollständige Type Hints
 
 Diese können bei Bedarf in zukünftigen Versionen verbessert werden.

VERSION

@@ -1 +1 @@
-v0.4.5
+v0.5.0

convert_txt_files_to_lessons_json.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""
+Konvertiert TXT-Dateien in eine lessons.json Datei.
+
+Format der TXT-Dateien:
+    Titel: <Titel der Lektion>
+    Untertitel: <Optionaler Untertitel> (wird übersprungen)
+    Anweisung: <Task/Anweisung für den User>
+
+    <Der eigentliche Übungstext...>
+
+Dateinamen-Format: XX.Y_Beschreibung.txt
+    - XX.Y wird zur lesson-Nummer (z.B. 01.1 -> "1.1")
+    - Bei Ganzzahlen ohne Dezimalpunkt (z.B. 02_Test.txt -> "2")
+
+Ausgabe-Format (lessons.json):
+    [
+      {
+        "lesson": "1.1",
+        "title": "01.1 Erarbeitung der Grundstellung",
+        "text": "Der Übungstext...",
+        "task": "Anweisung für den User"
+      },
+      ...
+    ]
+"""
+
+import re
+import json
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+def extract_lesson_number(filename: str) -> str:
+    """
+    Extrahiert die Lektionsnummer aus dem Dateinamen als String.
+
+    Args:
+        filename: Name der Datei (z.B. "01.1_Test.txt")
+
+    Returns:
+        Lektionsnummer als String (z.B. "1.1" oder "2")
+    """
+    match = re.match(r'^(\d+(?:\.\d+)?)_', filename)
+    if match:
+        # Konvertiere zu float und zurück zu string um führende Nullen zu entfernen
+        num = float(match.group(1))
+        # Wenn es eine Ganzzahl ist, gib sie ohne Dezimalpunkt zurück
+        if num == int(num):
+            return str(int(num))
+        return str(num)
+    return "0"
+
+
+def parse_txt_file(filepath: Path) -> Dict[str, Any]:
+    """
+    Parst eine einzelne TXT-Datei und extrahiert alle relevanten Informationen.
+
+    Args:
+        filepath: Pfad zur TXT-Datei
+
+    Returns:
+        Dictionary mit lesson, title, text und task
+
+    Raises:
+        FileNotFoundError: Wenn die Datei nicht existiert
+        UnicodeDecodeError: Wenn die Datei nicht UTF-8 encoded ist
+    """
+    with open(filepath, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    title = ''
+    task = ''
+    text_lines = []
+    i = 0
+
+    # Titelzeile extrahieren
+    if i < len(lines) and lines[i].startswith('Titel: '):
+        title = lines[i].replace('Titel: ', '').strip()
+        i += 1
+
+    # Untertitelzeile überspringen
+    if i < len(lines) and lines[i].startswith('Untertitel: '):
+        i += 1
+
+    # Anweisungszeile extrahieren
+    if i < len(lines) and lines[i].startswith('Anweisung: '):
+        task = lines[i].replace('Anweisung: ', '').strip()
+        i += 1
+
+    # Rest der Datei verarbeiten (ab hier ist der eigentliche Text)
+    while i < len(lines):
+        line = lines[i]
+        # Kommentarzeilen überspringen
+        if line.startswith('#'):
+            i += 1
+            continue
+        text_lines.append(line.rstrip('\n'))
+        i += 1
+
+    # Text zusammenfügen
+    text = '\n'.join(text_lines).strip()
+    lesson_number = extract_lesson_number(filepath.name)
+
+    return {
+        "lesson": lesson_number,
+        "title": title,
+        "text": text,
+        "task": task
+    }
+
+
+def validate_file(filepath: str) -> Path:
+    """
+    Validiert eine Datei und gibt ein Path-Objekt zurück.
+
+    Args:
+        filepath: Pfad zur Datei als String
+
+    Returns:
+        Path-Objekt
+
+    Raises:
+        FileNotFoundError: Wenn die Datei nicht existiert
+        ValueError: Wenn der Pfad kein File ist oder falsches Format hat
+    """
+    path = Path(filepath)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Datei nicht gefunden: {filepath}")
+
+    if not path.is_file():
+        raise ValueError(f"Pfad ist keine Datei: {filepath}")
+
+    if not path.suffix == '.txt':
+        raise ValueError(f"Datei muss .txt Extension haben: {filepath}")
+
+    # Prüfe Dateinamen-Format (XX.Y_Name.txt oder XX_Name.txt)
+    pattern = re.compile(r'^[0-9]+(?:\.[0-9]+)?_.+\.txt$')
+    if not pattern.match(path.name):
+        raise ValueError(
+            f"Ungültiges Dateinamen-Format: {path.name}\n"
+            f"Erwartet: XX.Y_Beschreibung.txt (z.B. 01.1_Lektion.txt)"
+        )
+
+    return path
+
+
+def convert_files_to_json(input_files: List[str], output_file: str) -> None:
+    """
+    Konvertiert eine Liste von TXT-Dateien in eine JSON-Datei.
+
+    Args:
+        input_files: Liste von Dateipfaden
+        output_file: Pfad zur Ausgabedatei
+
+    Raises:
+        FileNotFoundError: Wenn eine Eingabedatei nicht existiert
+        ValueError: Wenn eine Datei ungültig ist
+    """
+    # Validiere alle Dateien zuerst
+    validated_files = []
+    for filepath in input_files:
+        try:
+            path = validate_file(filepath)
+            validated_files.append(path)
+        except (FileNotFoundError, ValueError) as e:
+            print(f"✗ FEHLER: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Wenn alle Dateien valide sind, starte Konvertierung
+    print(f"Konvertiere {len(validated_files)} Datei(en) zu {output_file}...")
+    print()
+
+    for path in validated_files:
+        print(f"✓ {path.name}")
+
+    print()
+
+    # Parse alle Dateien in der angegebenen Reihenfolge
+    lessons = []
+    for txt_file in validated_files:
+        try:
+            lesson_data = parse_txt_file(txt_file)
+            lessons.append(lesson_data)
+            print(f"  Lektion {lesson_data['lesson']}: {lesson_data['title']}")
+        except Exception as e:
+            print(f"✗ FEHLER beim Parsen von {txt_file.name}: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # JSON schreiben
+    output_path = Path(output_file)
+    try:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(lessons, f, ensure_ascii=False, indent=2)
+
+        print()
+        print(f"✓ {len(lessons)} Lektionen erfolgreich konvertiert")
+        print(f"✓ Ausgabedatei: {output_path.absolute()}")
+    except Exception as e:
+        print(f"✗ FEHLER beim Schreiben der Ausgabedatei: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Erstellt den ArgumentParser mit allen Optionen."""
+
+    parser = argparse.ArgumentParser(
+        prog='convert_txt_files_to_lessons_json.py',
+        description='''
+Konvertiert TXT-Dateien in eine lessons.json Datei für den Typewriter Trainer.
+
+Die Reihenfolge der angegebenen Dateien bestimmt die Reihenfolge in der
+Ausgabedatei. Dies erlaubt flexible Sortierung unabhängig von den
+Lektionsnummern in den Dateinamen.
+        ''',
+        epilog='''
+EINGABE-FORMAT (TXT-Dateien):
+    Dateiname:  XX.Y_Beschreibung.txt (z.B. 01.1_Grundstellung.txt)
+
+    Inhalt:
+        Titel: <Titel der Lektion>
+        Untertitel: <Optionaler Untertitel> (wird ignoriert)
+        Anweisung: <Task/Anweisung für den User>
+
+        <Der eigentliche Übungstext...>
+        <Weitere Zeilen...>
+        # Zeilen, die mit '#' beginnen (Kommentare), werden ignoriert
+
+AUSGABE-FORMAT (lessons.json):
+    [
+      {
+        "lesson": "1.1",
+        "title": "01.1 Erarbeitung der Grundstellung",
+        "text": "Der Übungstext...",
+        "task": "Anweisung für den User"
+      },
+      ...
+    ]
+
+BEISPIELE:
+    # Einfache Konvertierung
+    python3 convert_txt_files_to_lessons_json.py 01.1_Lektion.txt 01.2_Lektion.txt
+
+    # Mit benutzerdefinierter Ausgabedatei
+    python3 convert_txt_files_to_lessons_json.py -o meine_lektionen.json *.txt
+
+    # Bestimmte Reihenfolge
+    python3 convert_txt_files_to_lessons_json.py 01.1_*.txt 01.2_*.txt 02.1_*.txt
+        ''',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False  # Wir fügen custom help hinzu
+    )
+
+    # Custom Help-Optionen
+    parser.add_argument(
+        '-h', '--help', '-?',
+        action='help',
+        help='Zeigt diese Hilfe an und beendet das Programm'
+    )
+
+    # Output-Option
+    parser.add_argument(
+        '-o', '--output',
+        metavar='FILE',
+        default='lessons.json',
+        help='Ausgabedatei (default: lessons.json)'
+    )
+
+    # Input-Dateien (positional, mindestens eine erforderlich)
+    parser.add_argument(
+        'files',
+        metavar='FILE',
+        nargs='+',
+        help='TXT-Dateien zum Konvertieren (Format: XX.Y_Name.txt)'
+    )
+
+    return parser
+
+
+def main():
+    """Hauptfunktion des Programms."""
+    parser = create_parser()
+
+    # Wenn keine Argumente übergeben wurden, zeige Hilfe
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+
+    args = parser.parse_args()
+
+    try:
+        convert_files_to_json(args.files, args.output)
+    except KeyboardInterrupt:
+        print("\n\n✗ Abgebrochen durch Benutzer", file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        print(f"\n✗ Unerwarteter Fehler: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

data/lessons.json

@@ -1,217 +1,260 @@
 [
   {
-    "lesson": 1.1,
+    "lesson": "1.1",
     "title": "01.1 Erarbeitung der Grundstellung",
-    "text": "ffff jjjj ffff jjjj ffff jjjj ffff jjjj ffff jjjj ffff jjjj\nffjj ffjj ffjj ffjj ffjj ffjj fjfj fjfj fjfj fjfj fjfj fjfj\n\ndddd kkkk dddd kkkk dddd kkkk dddd kkkk dddd kkkk dddd kkkk\nddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk\n\nssss llll ssss llll ssss llll ssss llll ssss llll ssss llll\nssll ssll ssll ssll ssll ssll slsl slsl slsl slsl slsl slsl\n\naaaa öööö aaaa öööö aaaa öööö aaaa öööö aaaa öööö aaaa öööö\naaöö aaöö aaöö aaöö aaöö aaöö aöaö aöaö aöaö aöaö aöaö aöaö\n\nasdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö\nfdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj\n\nafa aja afa aja ada aka ada aka asa ala asa ala aöa aöa asd\nöjö öfö öjö öfö ökö ödö ökö ödö ölö ösö ölö ösö öal ösk ölk\n\nöl ja öl ja öl ja öl öd da öd da öd da sö la sö la sö la sö\nlö aj lö aj lö aj lö dö ad dö ad dö ad ös al ös al ös al ös"
+    "text": "ffff jjjj ffff jjjj ffff jjjj ffff jjjj ffff jjjj ffff jjjj\nffjj ffjj ffjj ffjj ffjj ffjj fjfj fjfj fjfj fjfj fjfj fjfj\n\ndddd kkkk dddd kkkk dddd kkkk dddd kkkk dddd kkkk dddd kkkk\nddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk ddkk\n\nssss llll ssss llll ssss llll ssss llll ssss llll ssss llll\nssll ssll ssll ssll ssll ssll slsl slsl slsl slsl slsl slsl\n\naaaa öööö aaaa öööö aaaa öööö aaaa öööö aaaa öööö aaaa öööö\naaöö aaöö aaöö aaöö aaöö aaöö aöaö aöaö aöaö aöaö aöaö aöaö\n\nasdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö\nfdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj\n\nafa aja afa aja ada aka ada aka asa ala asa ala aöa aöa asd\nöjö öfö öjö öfö ökö ödö ökö ödö ölö ösö ölö ösö öal ösk ölk\n\nöl ja öl ja öl ja öl öd da öd da öd da sö la sö la sö la sö\nlö aj lö aj lö aj lö dö ad dö ad dö ad ös al ös al ös al ös",
+    "task": "Diese Lektion mindestens 5 mal fehlerfrei abschließen!"
   },
   {
-    "lesson": 1.2,
+    "lesson": "1.2",
     "title": "01.2 Festigung durch Wortübungen",
-    "text": "all als all als all als all als all als all als all als all\ndas las das las das las das las das las das las das las das\n\ndas das das las las las als als als das las als das las als\nlas las las als als als das das das als las das als das las\n\nda all das las da all das las da all das da all das als las\nda all das las da all das las da all das da all das als las\n\nja lös das ja lös das ja lös das ja lös das ja lös da ja da\nja lös das ja lös das ja lös das ja lös das ja lös da ja da\n\nda ja öd fad da ja öd fad da ja öd fad da ja öd fad das las\nda ja öd fad da ja öd fad da ja öd fad da ja öd fad das las\n\nda ja öd da ja öd das lös fad das lös fad da ja öd da ja da\ndas las lös das las lös als das fad als das fad da öl da ja"
+    "text": "all als all als all als all als all als all als all als all\ndas las das las das las das las das las das las das las das\n\ndas das das las las las als als als das las als das las als\nlas las las als als als das das das als las das als das las\n\nda all das las da all das las da all das da all das als las\nda all das las da all das las da all das da all das als las\n\nja lös das ja lös das ja lös das ja lös das ja lös da ja da\nja lös das ja lös das ja lös das ja lös das ja lös da ja da\n\nda ja öd fad da ja öd fad da ja öd fad da ja öd fad das las\nda ja öd fad da ja öd fad da ja öd fad da ja öd fad das las\n\nda ja öd da ja öd das lös fad das lös fad da ja öd da ja da\ndas las lös das las lös als das fad als das fad da öl da ja",
+    "task": "Übe die Wörter, bis du sie ohne Hinschauen tippen kannst."
   },
   {
-    "lesson": 1.3,
+    "lesson": "1.3",
     "title": "01.3 Schreibsicherheit durch Griffübungen",
-    "text": "asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö\njklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf\n\nölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa\nfdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj\n\nasdfjklö asdfjklö asdfjklö asdfjklö asdfjklö asdfjklö asdfj\njklöasdf jklöasdf jklöasdf jklöasdf jklöasdf jklöasdf jklöa\n\njfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdl\nöalskdjf öalskdjf öalskdjf öalskdjf öalskdjf öalskdjf öalsk\n\nafa aja ada aka asa ala aöa afa aja ada aka asa ala aöa afa\nöjö öfö ölö ösö ökö ödö öjö öfö ölö ösö ökö ödö öja öfa öka\n\naöaöjö ajaöfö adaölö akaösö asaökö alaödö aöaöjö afaöfö aöj\nöföafa öjöaöa ödöala ököasa ösöaka ölöada öföaja aöfjaö kfj\n\nsla sal sad sla sal sad sla sla sal sad sla sal sad sla sll\nals las das als las das als las das als las das als las das\n\nsad söl aj sad lla ad aj lö sad söl aj sad lla ad aj lö aja\ndas lös ja das all da ja öl das lös ja das all da ja öl das"
+    "text": "asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö\njklö asdf jklö asdf jklö asdf jklö asdf jklö asdf jklö asdf\n\nölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa\nfdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj fdsa ölkj\n\nasdfjklö asdfjklö asdfjklö asdfjklö asdfjklö asdfjklö asdfj\njklöasdf jklöasdf jklöasdf jklöasdf jklöasdf jklöasdf jklöa\n\njfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdlsöa jfkdl\nöalskdjf öalskdjf öalskdjf öalskdjf öalskdjf öalskdjf öalsk\n\nafa aja ada aka asa ala aöa afa aja ada aka asa ala aöa afa\nöjö öfö ölö ösö ökö ödö öjö öfö ölö ösö ökö ödö öja öfa öka\n\naöaöjö ajaöfö adaölö akaösö asaökö alaödö aöaöjö afaöfö aöj\nöföafa öjöaöa ödöala ököasa ösöaka ölöada öföaja aöfjaö kfj\n\nsla sal sad sla sal sad sla sla sal sad sla sal sad sla sll\nals las das als las das als las das als las das als las das\n\nsad söl aj sad lla ad aj lö sad söl aj sad lla ad aj lö aja\ndas lös ja das all da ja öl das lös ja das all da ja öl das",
+    "task": "Konzentriere dich auf gleichmäßiges Tempo."
   },
   {
-    "lesson": 1.4,
+    "lesson": "1.4",
     "title": "01.4 Lernkontrolle durch Wortübungen",
-    "text": "ja das las ja das lös ja das las ja das lös ja das las da j\nja das las ja das lös ja das las ja das lös ja das las ja a\n\ndas lös ja all das lös ja all das lös ja all das lös da das\ndas lös ja all das lös ja all das lös ja all das lös da all\n\nja das fad ja das fad ja das fad ja das fad ja das fad da s\nja das fad ja das fad ja das fad ja das fad ja das fad ja f\n\ndas las als all lös fad öd öl da ja das las als all ja da s\ndas las als all lös fad öd öl da ja das las als all ja da l"
+    "text": "ja das las ja das lös ja das las ja das lös ja das las da j\nja das las ja das lös ja das las ja das lös ja das las ja a\n\ndas lös ja all das lös ja all das lös ja all das lös da das\ndas lös ja all das lös ja all das lös ja all das lös da all\n\nja das fad ja das fad ja das fad ja das fad ja das fad da s\nja das fad ja das fad ja das fad ja das fad ja das fad ja f\n\ndas las als all lös fad öd öl da ja das las als all ja da s\ndas las als all lös fad öd öl da ja das las als all ja da l",
+    "task": "dummy"
   },
   {
-    "lesson": 2.1,
+    "lesson": "2.1",
     "title": "02.1 Erarbeitung der Griffe e und i",
-    "text": "dede kiki dede kiki dede kiki dede kiki dede kiki dede kiki\ndeki kide deki kide deki kide deki kide deki kide deki kide\n\ndedf kikj deds kikl deda kikö dedf kikj deds kikl deda kikö\ndidf kekj dids kekl dida kekö didf kekj dids kekl dida kekö\n\ndeed kiik deed kiik deed kiik deed kiik deed kiik deed kiik\ndedi kike dedi kike dedi kike dedi kike dedi kike dedi kike\n\ndedkik dedkik dedkik dedkik dedkik dedkik dedkik dedkik ded\njedfik jedfik jedfik jedfik jedfik jedfik jedfik jedfik dfi\n\nella esöl esel edal lede ellaf ella esöl esel edal lede ell\nalle löse lese lade edel falle alle löse lese lade edel all\n\nesöl sella edal sella esel sella edö sella elde lla sad lla\nlöse alles lade alles lese alles öde alles edle all das all"
+    "text": "dede kiki dede kiki dede kiki dede kiki dede kiki dede kiki\ndeki kide deki kide deki kide deki kide deki kide deki kide\n\ndedf kikj deds kikl deda kikö dedf kikj deds kikl deda kikö\ndidf kekj dids kekl dida kekö didf kekj dids kekl dida kekö\n\ndeed kiik deed kiik deed kiik deed kiik deed kiik deed kiik\ndedi kike dedi kike dedi kike dedi kike dedi kike dedi kike\n\ndedkik dedkik dedkik dedkik dedkik dedkik dedkik dedkik ded\njedfik jedfik jedfik jedfik jedfik jedfik jedfik jedfik dfi\n\nella esöl esel edal lede ellaf ella esöl esel edal lede ell\nalle löse lese lade edel falle alle löse lese lade edel all\n\nesöl sella edal sella esel sella edö sella elde lla sad lla\nlöse alles lade alles lese alles öde alles edle all das all",
+    "task": "dummy"
   },
   {
-    "lesson": 2.2,
+    "lesson": "2.2",
     "title": "02.2 Festigung durch Wortübungen",
-    "text": "lies dies leise dies sei leise lies dies leise dieses leide\nlies dies leise dies sei leise lies dies leise dieses leide\n\neile leise dieses alles sie lese dieses alles leise sei die\neile leise dieses alles sie lese dieses alles leise sei die\n\nfade öde löse alle falle lasse fade öde löse alle falle sie\nfade öde löse alle falle lasse fade öde löse alle falle sie\n\ndies sei lila fasse das alles löse dies alles dieses sei da\nalles eile jedes lies leise alles eile jedes lies leise all\n\nsei edel das sei edel diese sei edel dieses sei edel sei da\nseid leise dies sei ideal sie lief leise sie fiel leise die"
+    "text": "lies dies leise dies sei leise lies dies leise dieses leide\nlies dies leise dies sei leise lies dies leise dieses leide\n\neile leise dieses alles sie lese dieses alles leise sei die\neile leise dieses alles sie lese dieses alles leise sei die\n\nfade öde löse alle falle lasse fade öde löse alle falle sie\nfade öde löse alle falle lasse fade öde löse alle falle sie\n\ndies sei lila fasse das alles löse dies alles dieses sei da\nalles eile jedes lies leise alles eile jedes lies leise all\n\nsei edel das sei edel diese sei edel dieses sei edel sei da\nseid leise dies sei ideal sie lief leise sie fiel leise die",
+    "task": "dummy"
   },
   {
-    "lesson": 2.3,
+    "lesson": "2.3",
     "title": "Schreibsicherheit durch Griffübungen",
-    "text": "fdsajklö fdsajklö fdsajklö fdsajklö fdsajklö fdsajklö fdsaj\nölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkja\n\nasdedfölkikj asdedfölkikj asdedfölkikj asdedfölkikj asdedfö\njkikölfdedsa jkikölfdedsa jkikölfdedsa jkikölfdedsa jkikölf\n\nadedf ökikj adedf ökikj adedf ökikj adedf ökikj adedf ökikj\njaded fökik jaded fökik jaded fökik jaded fökik jaded fökik\n\njiklö fedsa jiklö fedsa jiklö fedsa jiklö fedsa jiklö fedsa\nölijk asefd ölijk asefd ölijk asefd ölijk asefd ölijk asefd"
+    "text": "fdsajklö fdsajklö fdsajklö fdsajklö fdsajklö fdsajklö fdsaj\nölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkjasdf ölkja\n\nasdedfölkikj asdedfölkikj asdedfölkikj asdedfölkikj asdedfö\njkikölfdedsa jkikölfdedsa jkikölfdedsa jkikölfdedsa jkikölf\n\nadedf ökikj adedf ökikj adedf ökikj adedf ökikj adedf ökikj\njaded fökik jaded fökik jaded fökik jaded fökik jaded fökik\n\njiklö fedsa jiklö fedsa jiklö fedsa jiklö fedsa jiklö fedsa\nölijk asefd ölijk asefd ölijk asefd ölijk asefd ölijk asefd",
+    "task": "dummy"
   },
   {
-    "lesson": 2.4,
+    "lesson": "2.4",
     "title": "02.4 Lernkontrolle durch Wortübungen",
-    "text": "seid seid esiel sella ellaf esiel seseid edö alil lede dies\nlies dies leise alles falle leise dieses öde lila edel seid\n\nelie esiel seseid sella eis esel seseid sella esiel eis ies\neile leise dieses alles sie lese dieses alles leise sie sei\n\nedeis ellaf ella esöl edö edaf essal ellaf ella esöl edö ed\nsiede falle alle löse öde fade lasse falle alle löse öde fa\n\nseid dies eile seid dies eile seid dies eile seid dieses ei\nseid dies eile seid dies eile seid dies eile seid dieses ei\n\nes sei dies alles leise es sei dies alles leise es sei dies\nes sei dies alles leise es sei dies alles leise es sei dies\n\nfiel feil fidele feil fiel lief fiel feil fidele feile fiel\nfiel feil fidele feil fiel lief fiel feil fidele feile fiel\n\nsei sie sei die eid die eid alle alles alle alles diese die\nsei sie sei die eid die eid alle alles alle alles diese die\n\nfiel fiel fiel feil feil feil fiel fiel fiel feil feil feil\nlief lief lief eile eile eile lief lief lief eile eile eile"
+    "text": "seid seid esiel sella ellaf esiel seseid edö alil lede dies\nlies dies leise alles falle leise dieses öde lila edel seid\n\nelie esiel seseid sella eis esel seseid sella esiel eis ies\neile leise dieses alles sie lese dieses alles leise sie sei\n\nedeis ellaf ella esöl edö edaf essal ellaf ella esöl edö ed\nsiede falle alle löse öde fade lasse falle alle löse öde fa\n\nseid dies eile seid dies eile seid dies eile seid dieses ei\nseid dies eile seid dies eile seid dies eile seid dieses ei\n\nes sei dies alles leise es sei dies alles leise es sei dies\nes sei dies alles leise es sei dies alles leise es sei dies\n\nfiel feil fidele feil fiel lief fiel feil fidele feile fiel\nfiel feil fidele feil fiel lief fiel feil fidele feile fiel\n\nsei sie sei die eid die eid alle alles alle alles diese die\nsei sie sei die eid die eid alle alles alle alles diese die\n\nfiel fiel fiel feil feil feil fiel fiel fiel feil feil feil\nlief lief lief eile eile eile lief lief lief eile eile eile",
+    "task": "dummy"
   },
   {
-    "lesson": 3.1,
+    "lesson": "3.1",
     "title": "03.1 Erarbeitung der beiden Umschalter",
-    "text": "öÖö öÖö aAa aAa lLl lLl sSs sSs kKk kKk dDd dDd jJj jJj fFf F\nöÖö öÖö aAa aAa lLl lLl sSs sSs kKk kKk dDd dDd jJj jJj fFf F\n\nJa Ja Fö Fö Ka Ka Dö Dö La La Sö Sö Öa Öa Aö Aö Ja Fö Ka Dö L\nJa Ja Fö Fö Ka Ka Dö Dö La La Sö Sö Öa Öa Aö Aö Ja Fö Ka Dö L\n\nöJ aJ aF öF öK aK aD öD öL aL aS öS öA aÖ sA lÖ kA dÖ jA fÖ a\nöJ aJ aF öF öK aK aD öD öL aL aS öS öA aÖ sA lÖ kA dÖ jA fÖ a\n\nJaf Föj Jad Fök Jas Föl Jaa Föö Jaö Föa Jal Fös Jak Föd Ja Fö\nJaf Föj Jad Fök Jas Föl Jaa Föö Jaö Föa Jal Fös Jak Föd Ja Fö\n\nöF aJ döF kaJ söF laJ aöF öaJ ööF aaJ löF saJ köF daJ jöF faJ\nöF aJ döF kaJ söF laJ aöF öaJ ööF aaJ löF saJ köF daJ jöF faJ"
+    "text": "öÖö öÖö aAa aAa lLl lLl sSs sSs kKk kKk dDd dDd jJj jJj fFf F\nöÖö öÖö aAa aAa lLl lLl sSs sSs kKk kKk dDd dDd jJj jJj fFf F\n\nJa Ja Fö Fö Ka Ka Dö Dö La La Sö Sö Öa Öa Aö Aö Ja Fö Ka Dö L\nJa Ja Fö Fö Ka Ka Dö Dö La La Sö Sö Öa Öa Aö Aö Ja Fö Ka Dö L\n\nöJ aJ aF öF öK aK aD öD öL aL aS öS öA aÖ sA lÖ kA dÖ jA fÖ a\nöJ aJ aF öF öK aK aD öD öL aL aS öS öA aÖ sA lÖ kA dÖ jA fÖ a\n\nJaf Föj Jad Fök Jas Föl Jaa Föö Jaö Föa Jal Fös Jak Föd Ja Fö\nJaf Föj Jad Fök Jas Föl Jaa Föö Jaö Föa Jal Fös Jak Föd Ja Fö\n\nöF aJ döF kaJ söF laJ aöF öaJ ööF aaJ löF saJ köF daJ jöF faJ\nöF aJ döF kaJ söF laJ aöF öaJ ööF aaJ löF saJ köF daJ jöF faJ",
+    "task": "dummy"
   },
   {
-    "lesson": 3.2,
+    "lesson": "3.2",
     "title": "03.2 Festigung durch Wortübungen",
-    "text": "Aal Aal Aal Aas Aas Aas Aal Aas Aal Aas Aal Aas Aal Aas Aal A\nAal Aal Aal Aas Aas Aas Aal Aas Aal Aas Aal Aas Aal Aas Aal A\n\nÖle Öle Öle Öde Öde Öde Öle Öde Öle Öde Öle Öde Öle Öde Öle Ö\nÖle Öle Öle Öde Öde Öde Öle Öde Öle Öde Öle Öde Öle Öde Öle Ö\n\nEile Seide Seile Eile Seide Seile Eile Seide Seile Eile Seide\nEile Seide Seile Eile Seide Seile Eile Seide Seile Eile Seide\n\ndie Seide die Eile die Seide die Eile die Seide die Eile Aale\ndie Seide die Eile die Seide die Eile die Seide die Eile Aale\n\ndie Öle die Aale die Öle die Aale die Öle die Aale die Öle Öl\ndie Öle die Aale die Öle die Aale die Öle die Aale die Öle Öl"
+    "text": "Aal Aal Aal Aas Aas Aas Aal Aas Aal Aas Aal Aas Aal Aas Aal A\nAal Aal Aal Aas Aas Aas Aal Aas Aal Aas Aal Aas Aal Aas Aal A\n\nÖle Öle Öle Öde Öde Öde Öle Öde Öle Öde Öle Öde Öle Öde Öle Ö\nÖle Öle Öle Öde Öde Öde Öle Öde Öle Öde Öle Öde Öle Öde Öle Ö\n\nEile Seide Seile Eile Seide Seile Eile Seide Seile Eile Seide\nEile Seide Seile Eile Seide Seile Eile Seide Seile Eile Seide\n\ndie Seide die Eile die Seide die Eile die Seide die Eile Aale\ndie Seide die Eile die Seide die Eile die Seide die Eile Aale\n\ndie Öle die Aale die Öle die Aale die Öle die Aale die Öle Öl\ndie Öle die Aale die Öle die Aale die Öle die Aale die Öle Öl",
+    "task": "dummy"
   },
   {
-    "lesson": 3.3,
+    "lesson": "3.3",
     "title": "03.3 Schreibsicherheit durch Wortgruppen",
-    "text": "diese Seide alle Keile des Eides diese Löffel diese Seele\ndiese Seide alle Keile des Eides diese Löffel diese Seele\n\ndiese fidele Liesel dieses ideale Lied Liesa lies das leise\ndiese fidele Liesel dieses ideale Lied Liesa lies das leise\n\ndie Seide dieses Kleides diese Seide des Kleides ideales Ei\ndie Seide dieses Kleides diese Seide des Kleides ideales Ei\n\ndiese ideale Kasse dieses ideale Kleid diese Diele das Eis\ndiese ideale Kasse dieses ideale Kleid diese Diele das Eis\n\ndiese leise Kasse diese Eisdiele diese Eislöffel die Seele\ndiese leise Kasse diese Eisdiele diese Eislöffel die Seele"
+    "text": "diese Seide alle Keile des Eides diese Löffel diese Seele\ndiese Seide alle Keile des Eides diese Löffel diese Seele\n\ndiese fidele Liesel dieses ideale Lied Liesa lies das leise\ndiese fidele Liesel dieses ideale Lied Liesa lies das leise\n\ndie Seide dieses Kleides diese Seide des Kleides ideales Ei\ndie Seide dieses Kleides diese Seide des Kleides ideales Ei\n\ndiese ideale Kasse dieses ideale Kleid diese Diele das Eis\ndiese ideale Kasse dieses ideale Kleid diese Diele das Eis\n\ndiese leise Kasse diese Eisdiele diese Eislöffel die Seele\ndiese leise Kasse diese Eisdiele diese Eislöffel die Seele",
+    "task": "dummy"
   },
   {
-    "lesson": 3.4,
+    "lesson": "3.4",
     "title": "03.4 Lernkontrolle durch Satzübungen",
-    "text": "Fasse die Seide dieses Kleides Fasse diese Seide des Kleides\nFasse die Seide dieses Kleides Fasse diese Seide des Kleides\n\nLiesel löse leise diese Kaffeelöffel Ja alles ideale Löffel\nLiesel löse leise diese Kaffeelöffel Ja alles ideale Löffel\n\nLiesel lies leise dieses Lied Dieses Lied lies leise Liesel\nLiesel lies leise dieses Lied Dieses Lied lies leise Liesel\n\nLiesel fasse diese Eislöffel Ja Liesel fasse alle Eislöffel\nLiesel fasse diese Eislöffel Ja Liesel fasse alle Eislöffel"
+    "text": "Fasse die Seide dieses Kleides Fasse diese Seide des Kleides\nFasse die Seide dieses Kleides Fasse diese Seide des Kleides\n\nLiesel löse leise diese Kaffeelöffel Ja alles ideale Löffel\nLiesel löse leise diese Kaffeelöffel Ja alles ideale Löffel\n\nLiesel lies leise dieses Lied Dieses Lied lies leise Liesel\nLiesel lies leise dieses Lied Dieses Lied lies leise Liesel\n\nLiesel fasse diese Eislöffel Ja Liesel fasse alle Eislöffel\nLiesel fasse diese Eislöffel Ja Liesel fasse alle Eislöffel",
+    "task": "dummy"
   },
   {
-    "lesson": 4.1,
+    "lesson": "4.1",
     "title": "04.1 Erarbeitung der Griffe g und h",
-    "text": "asdfgfölkjhj asdfgfölkjhj asdfgfölkjhj asdfgfölkjh asdfgfölkj\nölkjhjasdfgf ölkjhjasdfgf ölkjhjasdfgf ölkjhjasdfg ölkjhasdfg\n\nfgf jhj gfd hjk gfs hjl gfa hjö fgf jhj gfd hjk gfs hjl gfa h\nöhj agf öhk agd öhl ags öhj agf öhk agd öhl ags öhj agf öhk g\n\nhHj gGf hHj gGf Hjh Gfg Hjh gFg Hkl Gds Hlö Gsa Hil Ges HH GG\nHeg Geh Hag Gih Hie Gei Hei Gie Hid Gid Hel Gel Hal Göl Halle"
+    "text": "asdfgfölkjhj asdfgfölkjhj asdfgfölkjhj asdfgfölkjh asdfgfölkj\nölkjhjasdfgf ölkjhjasdfgf ölkjhjasdfgf ölkjhjasdfg ölkjhasdfg\n\nfgf jhj gfd hjk gfs hjl gfa hjö fgf jhj gfd hjk gfs hjl gfa h\nöhj agf öhk agd öhl ags öhj agf öhk agd öhl ags öhj agf öhk g\n\nhHj gGf hHj gGf Hjh Gfg Hjh gFg Hkl Gds Hlö Gsa Hil Ges HH GG\nHeg Geh Hag Gih Hie Gei Hei Gie Hid Gid Hel Gel Hal Göl Halle",
+    "task": "dummy"
   },
   {
-    "lesson": 4.2,
+    "lesson": "4.2",
     "title": "04.2 Festigung durch Wortübungen",
-    "text": "Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd J\nLage Lage Lage Lage Lage Lage Lage Lage Lage Lage Lage Lage L\n\nJagd Lage Jagd Lage Jagd Lage Jagd Lage Jagd Lage Jagd Lage J\nSage Lage Jagd Sage Lage Jagd Sage Lage Jagd Sage Lage Jagd S\n\nhalf Haag sage Sieg sehe Glas gehe Gala sieh Sieg lies Affe H\nsage Agfa half Jagd hege Haff lies Hall gehe Hase sehe Hefe S"
+    "text": "Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd Jagd J\nLage Lage Lage Lage Lage Lage Lage Lage Lage Lage Lage Lage L\n\nJagd Lage Jagd Lage Jagd Lage Jagd Lage Jagd Lage Jagd Lage J\nSage Lage Jagd Sage Lage Jagd Sage Lage Jagd Sage Lage Jagd S\n\nhalf Haag sage Sieg sehe Glas gehe Gala sieh Sieg lies Affe H\nsage Agfa half Jagd hege Haff lies Hall gehe Hase sehe Hefe S",
+    "task": "dummy"
   },
   {
-    "lesson": 4.3,
+    "lesson": "4.3",
     "title": "04.3 Festigung durch Wendungen",
-    "text": "das Jagdglas die Lage des Jagdglases die Lage dieses Glases\ndas Jagdglas die Lage des Jagdglases die Lage dieses Glases\n\ndie eisige See die eilige Hilfe die öde Höhle die Eisdiele\ndie eisige See  die eilige Hilfe die öde Höhle die Eisdiele\n\ndie Lage des Haffes hege diese Aale diese heilige Halle Öl\ndie Lage des Haffes hege diese Aale diese heilige Halle Öl"
+    "text": "das Jagdglas die Lage des Jagdglases die Lage dieses Glases\ndas Jagdglas die Lage des Jagdglases die Lage dieses Glases\n\ndie eisige See die eilige Hilfe die öde Höhle die Eisdiele\ndie eisige See  die eilige Hilfe die öde Höhle die Eisdiele\n\ndie Lage des Haffes hege diese Aale diese heilige Halle Öl\ndie Lage des Haffes hege diese Aale diese heilige Halle Öl",
+    "task": "dummy"
   },
   {
-    "lesson": 4.4,
+    "lesson": "4.4",
     "title": "04.4 Lernkontrolle durch Satzübungen",
-    "text": "Aha da lag ja das Jagdglas Gisela sah die eisige öde Höhle\nAha da lag ja das Jagdglas Gisela sah die eisige öde Höhle\n\nAls Adelheid diese eisige See sah da half sie eilig Gisela\nAls Adelheid diese eisige See sah da half sie eilig Gisela"
+    "text": "Aha da lag ja das Jagdglas Gisela sah die eisige öde Höhle\nAha da lag ja das Jagdglas Gisela sah die eisige öde Höhle\n\nAls Adelheid diese eisige See sah da half sie eilig Gisela\nAls Adelheid diese eisige See sah da half sie eilig Gisela",
+    "task": "dummy"
   },
   {
-    "lesson": 4.5,
+    "lesson": "4.5",
     "title": "04.5 Sicherheit durch Griffwiederholung = Fingergymnastik",
-    "text": "jhiikihh jhiikihh jhiikihh jhiikihh jhiikihh jhiikihh jhiikik\nfgeedegg fgeedegg fgeedegg fgeedegg fgeedegg fgeedegg fgeedeg\n\nöikk aedd öikk aedd öikk aedd öikk aedd öikk aedd öikk aedd ö\nlikk sedd likk sedd likk sedd likk sedd likk sedd likk sedd l\n\nkikk dedd kikk dedd kikk dedd kikk dedd kikk dedd kikk dedd k\njikk fedd jikk fedd jikk fedd jikk fedd jikk fedd jikk fedd j\n\naikö öeda aikö öeda aikö öeda aikö öeda aikö öeda aikö öeda a\nsikö leda sikö leda sikö leda sikö leda sikö leda sikö leda s\n\ndikö keda dikö keda dikö keda dikö keda dikö keda dikö keda d\nfikö jeda fikö jeda fikö jeda fikö jeda fikö jeda fikö jeda f\n\nöikklikkkikkjikkaikösiködiköfikö aeddsedddeddfeddöedaledakeda\nehesegalesahekieh ehesegalesahekie ehesegalesahekie ehesegale\n\nsadeleidellehhaseiSffaHsadegaL elhöHedöseidflahseeföHeidegalK\nellaHegiliehsessaHsedelaAeseid giliealesiGeisflahadhaseeSella"
+    "text": "jhiikihh jhiikihh jhiikihh jhiikihh jhiikihh jhiikihh jhiikik\nfgeedegg fgeedegg fgeedegg fgeedegg fgeedegg fgeedegg fgeedeg\n\nöikk aedd öikk aedd öikk aedd öikk aedd öikk aedd öikk aedd ö\nlikk sedd likk sedd likk sedd likk sedd likk sedd likk sedd l\n\nkikk dedd kikk dedd kikk dedd kikk dedd kikk dedd kikk dedd k\njikk fedd jikk fedd jikk fedd jikk fedd jikk fedd jikk fedd j\n\naikö öeda aikö öeda aikö öeda aikö öeda aikö öeda aikö öeda a\nsikö leda sikö leda sikö leda sikö leda sikö leda sikö leda s\n\ndikö keda dikö keda dikö keda dikö keda dikö keda dikö keda d\nfikö jeda fikö jeda fikö jeda fikö jeda fikö jeda fikö jeda f\n\nöikklikkkikkjikkaikösiködiköfikö aeddsedddeddfeddöedaledakeda\nehesegalesahekieh ehesegalesahekie ehesegalesahekie ehesegale\n\nsadeleidellehhaseiSffaHsadegaL elhöHedöseidflahseeföHeidegalK\nellaHegiliehsessaHsedelaAeseid giliealesiGeisflahadhaseeSella",
+    "task": "dummy"
   },
   {
-    "lesson": 4.6,
+    "lesson": "4.6",
     "title": "04.06 Lernkontrolle durch Wortübungen",
-    "text": "alle See sah das half sie Gisela eilige diese Aale des Hasses\nKlage die Höfe es half diese öde Höhle Lage dies Haff Sie sah\n\nsehe Halle sage Heike helle Höfe öde Höhle die Heide die Haie\nsehe Halle sage Heike helle Höfe öde Höhle die Heide die Haie\n\ngedeihe Klage heikel Heilige fehle Felge eilig Lage lege Igel\ngedeihe Klage heikel Heilige fehle Felge eilig Lage lege Igel"
+    "text": "alle See sah das half sie Gisela eilige diese Aale des Hasses\nKlage die Höfe es half diese öde Höhle Lage dies Haff Sie sah\n\nsehe Halle sage Heike helle Höfe öde Höhle die Heide die Haie\nsehe Halle sage Heike helle Höfe öde Höhle die Heide die Haie\n\ngedeihe Klage heikel Heilige fehle Felge eilig Lage lege Igel\ngedeihe Klage heikel Heilige fehle Felge eilig Lage lege Igel",
+    "task": "dummy"
   },
   {
-    "lesson": 5.1,
+    "lesson": "5.1",
     "title": "Einschreibübung",
-    "text": "asedsa ölkilö asedsa ölkilö asedsa ölkilö asedsa ölkilö kikik\nasedsa ölkilö asedsa ölkilö asedsa ölkilö asedsa ölkilö kikik\n\nAsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdS\nJkIkLö FdEdSa JkIkLö FdEdSa JkIkLö FdEdSa JkIkLö FdEdSa JkIkL\n\nsage siege liege geige lasse diese jedes alles da sie lieh es\nsage siege liege geige lasse diese jedes alles da sie lieh es"
+    "text": "asedsa ölkilö asedsa ölkilö asedsa ölkilö asedsa ölkilö kikik\nasedsa ölkilö asedsa ölkilö asedsa ölkilö asedsa ölkilö kikik\n\nAsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdSa ÖlKiLö AsEdS\nJkIkLö FdEdSa JkIkLö FdEdSa JkIkLö FdEdSa JkIkLö FdEdSa JkIkL\n\nsage siege liege geige lasse diese jedes alles da sie lieh es\nsage siege liege geige lasse diese jedes alles da sie lieh es",
+    "task": "dummy"
   },
   {
-    "lesson": 5.2,
+    "lesson": "5.2",
     "title": "05.2 Erarbeitung der Griffe c, Komma und Semikolon",
-    "text": "dedcd kik,k dedcd kik,k dedcd kik,k dedcd kik,k dedcd kik,k c\nfdcdf jk,kj fdcdf jk,kj fdcdf jk,kj fdcdf jk,kj fdcdf jk,kj ,\n\njk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcas\njk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcas\n\nach, ich, dich, sich, schlage, Celle, Chef, Dach, Fach, Sache\nach, ich, dich, sich, schlage, Celle, Chef, Dach, Fach, Sache\n\nlache, lege, leise, leihe, Leiche, Lacke, Jacke, Hacke, Hecke\nlache, lege, leise, leihe, Leiche, Lacke, Jacke, Hacke, Hecke"
+    "text": "dedcd kik,k dedcd kik,k dedcd kik,k dedcd kik,k dedcd kik,k c\nfdcdf jk,kj fdcdf jk,kj fdcdf jk,kj fdcdf jk,kj fdcdf jk,kj ,\n\njk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcas\njk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcasdf jk;ölkj fdcas\n\nach, ich, dich, sich, schlage, Celle, Chef, Dach, Fach, Sache\nach, ich, dich, sich, schlage, Celle, Chef, Dach, Fach, Sache\n\nlache, lege, leise, leihe, Leiche, Lacke, Jacke, Hacke, Hecke\nlache, lege, leise, leihe, Leiche, Lacke, Jacke, Hacke, Hecke",
+    "task": "dummy"
   },
   {
-    "lesson": 5.3,
+    "lesson": "5.3",
     "title": "05.3 Festigung durch Wendungen",
-    "text": "lache leise, diese Sache, dieses Fach, dieses Dach, die Cella\nlache leise, diese Sache, dieses Fach, dieses Dach, die Cella\n\ndie Fische, ach alle, lese diese Sache leise, dieses Cedille;\ndie Fische, ach alle, lese diese Sache leise, dieses Cedille;\n\nlöse das Dach, leihe die Sache, lache Chef, ach diese Deiche;\nlöse das Dach, leihe die Sache, lache Chef, ach diese Deiche;\n\ndie Eiche, die Leiche, die Fische, die Fischlaiche, Schleife;\ndie Eiche, die Leiche, die Fische, die Fischlaiche, Schleife;"
+    "text": "lache leise, diese Sache, dieses Fach, dieses Dach, die Cella\nlache leise, diese Sache, dieses Fach, dieses Dach, die Cella\n\ndie Fische, ach alle, lese diese Sache leise, dieses Cedille;\ndie Fische, ach alle, lese diese Sache leise, dieses Cedille;\n\nlöse das Dach, leihe die Sache, lache Chef, ach diese Deiche;\nlöse das Dach, leihe die Sache, lache Chef, ach diese Deiche;\n\ndie Eiche, die Leiche, die Fische, die Fischlaiche, Schleife;\ndie Eiche, die Leiche, die Fische, die Fischlaiche, Schleife;",
+    "task": "dummy"
   },
   {
-    "lesson": 5.4,
+    "lesson": "5.4",
     "title": "05.4 Konzentrationstraining durch Griffübungen",
-    "text": "asdcdef jk,kilö asdcef jk,ilö asecf ji,lö fedcsa ölik,j ec i,\nasdcdef jk,kilö asdcef jk,ilö asecf ji,lö fedcsa ölik,j ec i,\n\nasdfedc jklöik, asdfced jklö,ki fedc öik, fesa ölij fcsa öl,j\nasdfedc jklöik, asdfced jklö,ki fedc öik, fesa ölij fcsa öl,j"
+    "text": "asdcdef jk,kilö asdcef jk,ilö asecf ji,lö fedcsa ölik,j ec i,\nasdcdef jk,kilö asdcef jk,ilö asecf ji,lö fedcsa ölik,j ec i,\n\nasdfedc jklöik, asdfced jklö,ki fedc öik, fesa ölij fcsa öl,j\nasdfedc jklöik, asdfced jklö,ki fedc öik, fesa ölij fcsa öl,j",
+    "task": "dummy"
   },
   {
-    "lesson": 5.5,
+    "lesson": "5.5",
     "title": "05.5 Festigung durch Wortübungen",
-    "text": "Öle Aale Liesel Sessel Klasse Diesel Jaffa Fliege Hilfe Galle\nÖle Aale Liesel Sessel Klasse Diesel Jaffa Fliege Hilfe Galle\n\ndie Öle, die Aale, die Liesel, die Sessel, die Klasse, Diesel\ndie Fliege, die Hilfe, die Galle, die Geige, die Liege, Jaffa\n\ndie Eiche, die Deiche, die Asche, die Fische, die Deichsel da\ndiese Eiche, diese Deiche, diese Asche, diese Fische, Cedille\n\ndie Eidechse, die Gleiche, die Leiche, diese Hechelei, Kachel\nja die Eidechse, ja die Gleiche, ja die Leiche, ja die Kachel"
+    "text": "Öle Aale Liesel Sessel Klasse Diesel Jaffa Fliege Hilfe Galle\nÖle Aale Liesel Sessel Klasse Diesel Jaffa Fliege Hilfe Galle\n\ndie Öle, die Aale, die Liesel, die Sessel, die Klasse, Diesel\ndie Fliege, die Hilfe, die Galle, die Geige, die Liege, Jaffa\n\ndie Eiche, die Deiche, die Asche, die Fische, die Deichsel da\ndiese Eiche, diese Deiche, diese Asche, diese Fische, Cedille\n\ndie Eidechse, die Gleiche, die Leiche, diese Hechelei, Kachel\nja die Eidechse, ja die Gleiche, ja die Leiche, ja die Kachel",
+    "task": "dummy"
   },
   {
-    "lesson": 5.6,
+    "lesson": "5.6",
     "title": "05.6 Lernkontrolle durch Satzübungen",
-    "text": "Liesel sage es Helga, ich sage das Lied leise; ach Liese half\neilig; Adelheid, dich sah ich eilig; ach Liesel ich leihe dir\nSchleife; die Klasse lese leise das Lied, siehe die Eidechse;\n\nDas Jagdglas lag ja da; als Heidi diese Eidechse sah, da lief\nsie; ja, als Adelheid die eisige See sah, da half sie Liesel;\n\nIch sah die helle Diele, ich sah die Heide, ich sah die Höfe;\nAch, jede sah das Dach; ja, dieses Dach; siehe die Heidehöfe;"
+    "text": "Liesel sage es Helga, ich sage das Lied leise; ach Liese half\neilig; Adelheid, dich sah ich eilig; ach Liesel ich leihe dir\nSchleife; die Klasse lese leise das Lied, siehe die Eidechse;\n\nDas Jagdglas lag ja da; als Heidi diese Eidechse sah, da lief\nsie; ja, als Adelheid die eisige See sah, da half sie Liesel;\n\nIch sah die helle Diele, ich sah die Heide, ich sah die Höfe;\nAch, jede sah das Dach; ja, dieses Dach; siehe die Heidehöfe;",
+    "task": "dummy"
   },
   {
-    "lesson": 6.1,
+    "lesson": "6.1",
     "title": "05.7 Einschreibübung",
-    "text": "asdfjklö asdefölkij asdfjklö asdefölkij asdfjklö asdefölkikj\nölkjasdf ölk,kasdcd ölkjasdf ölk,kasdcd ölkjasdf ölk,kasdcdf\n\nedcsafik,löj edcsafik,löj edcsafik,öj edcsafik,öj edcsafik,öj\njöl,kifascde jöl,kifascde jöl,kifascde jöl,kifascde jöl,kifas\nErarbeitung der Griffe r und u\n\nasdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj frfju\nfrfjuj frfjuj frdesa jukilö frdesa frfjuj frfjuj frdesa jukil\n\nfrfded jujkik frfdcd jujk,k frfded jujkik frfdcd jujk,k rfded\nujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,k\n\nfra juö frs jul frd juk örl aus örk aud örj auf fru jur fr ju\nruj urf fua jrö dua krö sua lrö kuj drf luj srf öuj arf rf uj"
+    "text": "asdfjklö asdefölkij asdfjklö asdefölkij asdfjklö asdefölkikj\nölkjasdf ölk,kasdcd ölkjasdf ölk,kasdcd ölkjasdf ölk,kasdcdf\n\nedcsafik,löj edcsafik,löj edcsafik,öj edcsafik,öj edcsafik,öj\njöl,kifascde jöl,kifascde jöl,kifascde jöl,kifascde jöl,kifas\nErarbeitung der Griffe r und u\n\nasdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj frfju\nfrfjuj frfjuj frdesa jukilö frdesa frfjuj frfjuj frdesa jukil\n\nfrfded jujkik frfdcd jujk,k frfded jujkik frfdcd jujk,k rfded\nujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,k\n\nfra juö frs jul frd juk örl aus örk aud örj auf fru jur fr ju\nruj urf fua jrö dua krö sua lrö kuj drf luj srf öuj arf rf uj",
+    "task": "dummy"
   },
   {
-    "lesson": 6.2,
+    "lesson": "6.2",
     "title": "06.2 Erarbeitung der Griffe r und u",
-    "text": "asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj frfju\nfrfjuj frfjuj frdesa jukilö frdesa frfjuj frfjuj frdesa jukil\n\nfrfded jujkik frfdcd jujk,k frfded jujkik frfdcd jujk,k rfded\nujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,k\n\nfra juö frs jul frd juk örl aus örk aud örj auf fru jur fr ju\nruj urf fua jrö dua krö sua lrö kuj drf luj srf öuj arf rf uj"
+    "text": "asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj asdfrf ölkjuj frfju\nfrfjuj frfjuj frdesa jukilö frdesa frfjuj frfjuj frdesa jukil\n\nfrfded jujkik frfdcd jujk,k frfded jujkik frfdcd jujk,k rfded\nujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,ki rfdcde ujk,k\n\nfra juö frs jul frd juk örl aus örk aud örj auf fru jur fr ju\nruj urf fua jrö dua krö sua lrö kuj drf luj srf öuj arf rf uj",
+    "task": "dummy"
   },
   {
-    "lesson": 6.3,
+    "lesson": "6.3",
     "title": "06.3 Festigung durch Wortübungen",
-    "text": "frage, frage, frage, laufe, laufe, laufe, frage, laufe, rauf,\nfrage, raufe, frage, kaufe, frage, raufe, frage, kaufe, rief,\n\neure, drei, klar, eure, drei, klar, eure, drei, klar, eure, d\nrede, sehr, hier, rede, sehr, hier, rede, sehr, hier, rede, s\n\nsehr eilige, alles ruhig, jeder laufe, gerade hier, gehe aus,\nsehr ruhige, alles eilig, jeder kaufe, gerade alle, geradeaus\n\ndie Frage, die Freude, die Ruhe, der Karl, die Karla, Kuckuck\ndie Frage, die Freude, die Ruhe, der Karl, die Karla, Kuckuck\n\ndie Kugelfische, der Hilferuf, der Kuckucksruf, die Ruhelage,\ndie Kugelfische, der Hilferuf, der Kuckucksruf, die Ruhelage,"
+    "text": "frage, frage, frage, laufe, laufe, laufe, frage, laufe, rauf,\nfrage, raufe, frage, kaufe, frage, raufe, frage, kaufe, rief,\n\neure, drei, klar, eure, drei, klar, eure, drei, klar, eure, d\nrede, sehr, hier, rede, sehr, hier, rede, sehr, hier, rede, s\n\nsehr eilige, alles ruhig, jeder laufe, gerade hier, gehe aus,\nsehr ruhige, alles eilig, jeder kaufe, gerade alle, geradeaus\n\ndie Frage, die Freude, die Ruhe, der Karl, die Karla, Kuckuck\ndie Frage, die Freude, die Ruhe, der Karl, die Karla, Kuckuck\n\ndie Kugelfische, der Hilferuf, der Kuckucksruf, die Ruhelage,\ndie Kugelfische, der Hilferuf, der Kuckucksruf, die Ruhelage,",
+    "task": "dummy"
   },
   {
-    "lesson": 6.4,
+    "lesson": "6.4",
     "title": "06.4 Lernkontrolle durch Geläufigkeitssätze",
-    "text": "Sage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\n\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;"
+    "text": "Sage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\nSage Adelheid, hier höre jeder diese Kuckucksrufe sehr leise;\n\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;\nKarla sage sehr leise, dieser Löffel gehöre sicherlich Adele;",
+    "task": "dummy"
   },
   {
-    "lesson": 6.5,
+    "lesson": "6.5",
     "title": "06.5 Schreibsicherheit durch Griffübungen = Fingergymnastik",
-    "text": "frfr juju frfr juju frfr juju frfr juju frfr juju frfr juju r\nfruj jurf fruj jurf fruj jurf fruj jurf fruj jurf fruj jurf u\n\nfra juö fra juö fra juö fra juö fra juö fra juö fra juö fra r\nraf uöj raf uöj raf uöj raf uöj raf uöj raf uöj raf uöj raf u\n\nrsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf r\nrdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf u\n\nörf auj örf auj örf auj örf auj örf auj örf auj örf auj örf r\nöre aui öre aui öre aui öre aui öre aui öre aui öre aui öre u\n\nref uij ref uij ref uij ref uij ref uij ref uij ref uij ref e\naer öiu aer öiu aer öiu aer öiu aer öiu aer öiu aer öiu aer i\n\nasderfd ölkiujk asderfd ölkiujk asderfd ölkiujk asderfd ölkiu\ndfredas kjuiklö dfredas kjuiklö dfredas kjuiklö dfredas uiklö"
+    "text": "frfr juju frfr juju frfr juju frfr juju frfr juju frfr juju r\nfruj jurf fruj jurf fruj jurf fruj jurf fruj jurf fruj jurf u\n\nfra juö fra juö fra juö fra juö fra juö fra juö fra juö fra r\nraf uöj raf uöj raf uöj raf uöj raf uöj raf uöj raf uöj raf u\n\nrsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf ulj rsf r\nrdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf ukj rdf u\n\nörf auj örf auj örf auj örf auj örf auj örf auj örf auj örf r\nöre aui öre aui öre aui öre aui öre aui öre aui öre aui öre u\n\nref uij ref uij ref uij ref uij ref uij ref uij ref uij ref e\naer öiu aer öiu aer öiu aer öiu aer öiu aer öiu aer öiu aer i\n\nasderfd ölkiujk asderfd ölkiujk asderfd ölkiujk asderfd ölkiu\ndfredas kjuiklö dfredas kjuiklö dfredas kjuiklö dfredas uiklö",
+    "task": "dummy"
   },
   {
-    "lesson": 6.6,
+    "lesson": "6.6",
     "title": "06.6 Festigung durch Wortübungen",
-    "text": "Hirse Haus Rede Reeder Reederei Dur Kur Uhr Ruhr Kuli Ulli Öl\nHirse Haus Rede Reeder Reederei Dur Kur Uhr Ruhr Kuli Ulli Öl\n\nJura Frau Erde Ilse Juli Frage Iller Erdöl Jahr Friede Julius\nJura Frau Erde Ilse Juli Frage Iller Erdöl Jahr Friede Julius"
+    "text": "Hirse Haus Rede Reeder Reederei Dur Kur Uhr Ruhr Kuli Ulli Öl\nHirse Haus Rede Reeder Reederei Dur Kur Uhr Ruhr Kuli Ulli Öl\n\nJura Frau Erde Ilse Juli Frage Iller Erdöl Jahr Friede Julius\nJura Frau Erde Ilse Juli Frage Iller Erdöl Jahr Friede Julius",
+    "task": "dummy"
   },
   {
-    "lesson": 6.7,
+    "lesson": "6.7",
     "title": "06.7 Lernkontrolle durch Wendungen",
-    "text": "auf dieser Reise, das Ufer der Saale, raufe die Haare, das Ei\nauf dieser Reise, das Ufer der Saale, raufe die Haare, das Ei\n\nrufe Julius her, rufe Frau Krause, Adelheid lege alles darauf\nsei ruhig Ilse, sieh da Ulli, auch Karla sah die Fischerei da"
+    "text": "auf dieser Reise, das Ufer der Saale, raufe die Haare, das Ei\nauf dieser Reise, das Ufer der Saale, raufe die Haare, das Ei\n\nrufe Julius her, rufe Frau Krause, Adelheid lege alles darauf\nsei ruhig Ilse, sieh da Ulli, auch Karla sah die Fischerei da",
+    "task": "dummy"
   },
   {
-    "lesson": 7.1,
+    "lesson": "7.1",
     "title": "07.1 Erarbeitung der Griffe v und m",
-    "text": "asdfvf ölkjmj asdfvf ölkjmj asdfvf ölkjmj asdfvf ölkjmj asdfv\nfvfdsa jmjklö fvfdsa jmjklö fvfdsa jmjklö fvfdsa jmjklö fvfds\n\nfvfrfvf jmjujmj fvfrfvf jmjujmj fvfrfvf jmjujmj fvfrfvf jujmj\nfrfvfrd jujmjuk frfvfrs jujmjul frfvfra jujmjuö frvfrvf jumjö\n\nfvfredsa jmjuiklö fvfredsa jmjuiklö fvfredsa jmjuiklö fvfreds\nfvfredca jmjuik,ö fvfredca jmjuik,ö fvfredca jmjuik,ö fvfredc\n\nver mir vie mie vei mei ver mir vie mie vei mei ver mir vie m\nmer vir mie vie mei vei mer vir mie vie mei vei mer vir mie v"
+    "text": "asdfvf ölkjmj asdfvf ölkjmj asdfvf ölkjmj asdfvf ölkjmj asdfv\nfvfdsa jmjklö fvfdsa jmjklö fvfdsa jmjklö fvfdsa jmjklö fvfds\n\nfvfrfvf jmjujmj fvfrfvf jmjujmj fvfrfvf jmjujmj fvfrfvf jujmj\nfrfvfrd jujmjuk frfvfrs jujmjul frfvfra jujmjuö frvfrvf jumjö\n\nfvfredsa jmjuiklö fvfredsa jmjuiklö fvfredsa jmjuiklö fvfreds\nfvfredca jmjuik,ö fvfredca jmjuik,ö fvfredca jmjuik,ö fvfredc\n\nver mir vie mie vei mei ver mir vie mie vei mei ver mir vie m\nmer vir mie vie mei vei mer vir mie vie mei vei mer vir mie v",
+    "task": "dummy"
   },
   {
-    "lesson": 7.2,
+    "lesson": "7.2",
     "title": "07.2 Festigung durch Wortübungen",
-    "text": "viel mehr verlese mehrfach vielfach mache vermache mische das\nviele vieles vieler vielem mehr mehre mehrere mehreres vieler\n\nvermehre verlasse verkaufe vermache verlese verliere verkaufe\nvergehe vermerke vermische vermelde vergesse verlaufe verlese\n\nvermiese, vermahle, vermale, versehe, vergehe, verlege, viele\nvermerke, vergesse, verlaufe, versuche, vermerke, vermöge es,\n\nVieh, Meer, Vers, Mimik, Villa, Muskel, Vier, Mieder, Villach\nVermerk, Mega, Vikar, Mischer, Verruf, Mull, Virus, Maulesel."
+    "text": "viel mehr verlese mehrfach vielfach mache vermache mische das\nviele vieles vieler vielem mehr mehre mehrere mehreres vieler\n\nvermehre verlasse verkaufe vermache verlese verliere verkaufe\nvergehe vermerke vermische vermelde vergesse verlaufe verlese\n\nvermiese, vermahle, vermale, versehe, vergehe, verlege, viele\nvermerke, vergesse, verlaufe, versuche, vermerke, vermöge es,\n\nVieh, Meer, Vers, Mimik, Villa, Muskel, Vier, Mieder, Villach\nVermerk, Mega, Vikar, Mischer, Verruf, Mull, Virus, Maulesel.",
+    "task": "dummy"
   },
   {
-    "lesson": 7.3,
+    "lesson": "7.3",
     "title": "07.3 Festigung durch Wendungen",
-    "text": "sehr viel Vieh, auf dem Meer, merke viele Verse, diese Villa,\nder kluge Vermerk, vermerke ihre Versuche, das Villacher Vieh\n\nalle die Vermerke, der aufmerksame Mischer, der fremde Vikar,\nmehrere Filme, immer mehr Verkehr, immer viele Versuchsfilme,\n\nimmer die Maare, immer die Meere, auf dem Mars, mehrere Male,\nverkaufe im Mai, verkaufe die Vase, vermische das viele Mehl,"
+    "text": "sehr viel Vieh, auf dem Meer, merke viele Verse, diese Villa,\nder kluge Vermerk, vermerke ihre Versuche, das Villacher Vieh\n\nalle die Vermerke, der aufmerksame Mischer, der fremde Vikar,\nmehrere Filme, immer mehr Verkehr, immer viele Versuchsfilme,\n\nimmer die Maare, immer die Meere, auf dem Mars, mehrere Male,\nverkaufe im Mai, verkaufe die Vase, vermische das viele Mehl,",
+    "task": "dummy"
   },
   {
-    "lesson": 7.4,
+    "lesson": "7.4",
     "title": "07.4 Schreibsicherheit durch Griffübungen = Fingergymnastik",
-    "text": "rfvdsa ujmklö rfvdsa ujmklö rfvdsa ujmklö rfvdsa ujmklö rfvds\nedcrfv ik,ujm edcrfv ik,ujm edcrfv ik,ujm edcrfv ik,ujm edcrf\n\nfjruvmdkeic, fjruvmdkeic, fjruvmdkeic, fjruvmdkeic, fjruvmdke\n,kiujmcderfv ,kiujmcderfv ,kiujmcderfv ,kiujmcderfv ,kiujmcde\n\nfjvmdkc,eidk fjvmdkc,eidk fjvmdkc,eidk fjvmdkc,eidk fjvmdkcei\nkdie,ckdmvjf kdie,ckdmvjf kdie,ckdmvjf kdie,ckdmvjf ieckdmvjf"
+    "text": "rfvdsa ujmklö rfvdsa ujmklö rfvdsa ujmklö rfvdsa ujmklö rfvds\nedcrfv ik,ujm edcrfv ik,ujm edcrfv ik,ujm edcrfv ik,ujm edcrf\n\nfjruvmdkeic, fjruvmdkeic, fjruvmdkeic, fjruvmdkeic, fjruvmdke\n,kiujmcderfv ,kiujmcderfv ,kiujmcderfv ,kiujmcderfv ,kiujmcde\n\nfjvmdkc,eidk fjvmdkc,eidk fjvmdkc,eidk fjvmdkc,eidk fjvmdkcei\nkdie,ckdmvjf kdie,ckdmvjf kdie,ckdmvjf kdie,ckdmvjf ieckdmvjf",
+    "task": "dummy"
   },
   {
-    "lesson": 7.5,
+    "lesson": "7.5",
     "title": "07.5 Festigung durch Wendungen",
-    "text": "viele Lacke, jede Jacke, diese Hecke, dieser Fleck, ja Flachs\ndiese Lacke, diese Hacke, jede Decke, der Flachs, die Fackel,\n\ndieser Vermerk, decke das Dach, recke die Decke, dieser Mars,\nversuche die Lachse, die Meereslage, mehrere Maler, die Eiche"
+    "text": "viele Lacke, jede Jacke, diese Hecke, dieser Fleck, ja Flachs\ndiese Lacke, diese Hacke, jede Decke, der Flachs, die Fackel,\n\ndieser Vermerk, decke das Dach, recke die Decke, dieser Mars,\nversuche die Lachse, die Meereslage, mehrere Maler, die Eiche",
+    "task": "dummy"
   },
   {
-    "lesson": 7.6,
+    "lesson": "7.6",
     "title": "07.6 Lernkontrolle durch Satzübungen",
-    "text": "Adelheid vermerke dir die Reihe der Versuche der Marschierer;\nAdele versuche die Lachse; Friedel sieh diese Messer im Sack;\n\nAdam vermerke es, ich vergesse diese Sache sicherlich gleich;\nFriedel ich verleihe im Juli die Decke, die ich dir vermache;\n\nDie Kauffrau verkaufe im Juli frische Meeresfische aus Kiel;\nIm Kaufhaus Meier kaufe ich immer mehrere frische Seefische;\n\nSage Helga, die Filme aus dem Kaufhaus kaufe ich sicher auch;\nLege die Filme auf die Jacke, dieses merke ich mir sicherlich"
+    "text": "Adelheid vermerke dir die Reihe der Versuche der Marschierer;\nAdele versuche die Lachse; Friedel sieh diese Messer im Sack;\n\nAdam vermerke es, ich vergesse diese Sache sicherlich gleich;\nFriedel ich verleihe im Juli die Decke, die ich dir vermache;\n\nDie Kauffrau verkaufe im Juli frische Meeresfische aus Kiel;\nIm Kaufhaus Meier kaufe ich immer mehrere frische Seefische;\n\nSage Helga, die Filme aus dem Kaufhaus kaufe ich sicher auch;\nLege die Filme auf die Jacke, dieses merke ich mir sicherlich",
+    "task": "dummy"
   },
   {
-    "lesson": 8.1,
+    "lesson": "8.1",
     "title": "08.1 Erarbeitung der Griffe t und z",
-    "text": "jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa z\njhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf t\n\nfrtgf juzhj frtgf juzhj frtgf juzhj frtgf juzhj frtgf juzhj z\njhzuj fgtrf jhzuj fgtrf jhzuj fgtrf jhzuj fgtrf jhzuj fgtrf t\n\njuzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfr\ntrfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzu\n\nfjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrut\ntzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurj\n\nzer ter zer ter zer ter zer ter zer ter zer ter zer ter zer t\nzur tur zur tur zur tur zur tur zur tur zur tur zur tur zur z"
+    "text": "jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa jzjö ftfa z\njhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf jhzj fgtf t\n\nfrtgf juzhj frtgf juzhj frtgf juzhj frtgf juzhj frtgf juzhj z\njhzuj fgtrf jhzuj fgtrf jhzuj fgtrf jhzuj fgtrf jhzuj fgtrf t\n\njuzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfrt juzfr\ntrfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzuj trfzu\n\nfjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrutz fjrut\ntzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurjf tzurj\n\nzer ter zer ter zer ter zer ter zer ter zer ter zer ter zer t\nzur tur zur tur zur tur zur tur zur tur zur tur zur tur zur z",
+    "task": "dummy"
   },
   {
-    "lesson": 8.2,
+    "lesson": "8.2",
     "title": "08.02 Festigung durch Wortübungen",
-    "text": "trage trete treffe trat tretet geht guter ziehe zage letztere\ntrage trete treffe trat tretet geht guter ziehe zage letztere\n\nzerfalle zertrete zermale zergehe zergliedere zerstreue zerre\nzerfalle zertrete zermale zergehe zergliedere zerstreue zerre\n\nZerrerei, zeige, Zeiger, zerfalle, Zerfall, ziehe es, Zieher,\nZerrerei, zeige, Zeiger, zerfalle, Zerfall, ziehe es, Zieher,\n\nZiege, Ziegel, Ziegelei, Ziegeldach, Ziegelstreicher, Ziegel,\nZiel, Zielkamera, Zielkauf, Zielgerade, diese Zielsicherheit,\n\nzugemauert, zugeheftet, zugemutet, zumeist, zugleich, zuletzt\nZuzug, Zugtier, Zugverkehr, Zulieferer, Zurichterei, Zurichter"
+    "text": "trage trete treffe trat tretet geht guter ziehe zage letztere\ntrage trete treffe trat tretet geht guter ziehe zage letztere\n\nzerfalle zertrete zermale zergehe zergliedere zerstreue zerre\nzerfalle zertrete zermale zergehe zergliedere zerstreue zerre\n\nZerrerei, zeige, Zeiger, zerfalle, Zerfall, ziehe es, Zieher,\nZerrerei, zeige, Zeiger, zerfalle, Zerfall, ziehe es, Zieher,\n\nZiege, Ziegel, Ziegelei, Ziegeldach, Ziegelstreicher, Ziegel,\nZiel, Zielkamera, Zielkauf, Zielgerade, diese Zielsicherheit,\n\nzugemauert, zugeheftet, zugemutet, zumeist, zugleich, zuletzt\nZuzug, Zugtier, Zugverkehr, Zulieferer, Zurichterei, Zurichter",
+    "task": "dummy"
   },
   {
-    "lesson": 8.3,
+    "lesson": "8.3",
     "title": "08.3 Festigung durch Wendungen",
-    "text": "zertrete die Ziegel, zerhacke die Ziegel, zerstreue das Zeug,\nzeige die Zulage, zeige die Zielkamera, zeige diese Ziegelei,\n\nviel Verkehr, viel Zugverkehr, viele Zulieferer, der Zielkauf\njetzt zur Schau gestellt, richtet die Zeit, seit kurzer Zeit,"
+    "text": "zertrete die Ziegel, zerhacke die Ziegel, zerstreue das Zeug,\nzeige die Zulage, zeige die Zielkamera, zeige diese Ziegelei,\n\nviel Verkehr, viel Zugverkehr, viele Zulieferer, der Zielkauf\njetzt zur Schau gestellt, richtet die Zeit, seit kurzer Zeit,",
+    "task": "dummy"
   },
   {
-    "lesson": 8.4,
+    "lesson": "8.4",
     "title": "08.4 Schreibsicherheit durch Griffübungen",
-    "text": "jzjklö ftfdsa jzjklö ftfdsa jzjklö ftfdsa jzjklö ftfdsa jzftö\nölkjzj asdftf ölkjzj asdftf ölkjzj asdftf ölkjzj asdftf ötfzj\n\nfgtfdsa jhzjklö fgtfdsa jhzjklö fgtfdsa jhzjklö fgtfdsa fjztu\nasdftgf ölkjzhj asdftgf ölkjzhj asdftgf ölkjzhj asdftgf öaztl\n\nfjghtzdkeirutzghfj fjghtzdkeirutzghfj fjghtzdkeirutzghfj fjgh\nöasldkfjrueidkslaö öasldkfjrueidkslaö öasldkfjrueidkslaö öasl"
+    "text": "jzjklö ftfdsa jzjklö ftfdsa jzjklö ftfdsa jzjklö ftfdsa jzftö\nölkjzj asdftf ölkjzj asdftf ölkjzj asdftf ölkjzj asdftf ötfzj\n\nfgtfdsa jhzjklö fgtfdsa jhzjklö fgtfdsa jhzjklö fgtfdsa fjztu\nasdftgf ölkjzhj asdftgf ölkjzhj asdftgf ölkjzhj asdftgf öaztl\n\nfjghtzdkeirutzghfj fjghtzdkeirutzghfj fjghtzdkeirutzghfj fjgh\nöasldkfjrueidkslaö öasldkfjrueidkslaö öasldkfjrueidkslaö öasl",
+    "task": "dummy"
   },
   {
-    "lesson": 8.5,
+    "lesson": "8.5",
     "title": "08.5 Lernkontrolle durch Satzübungen",
-    "text": "Kurt Zeiger macht heute die Fahrt mit Zacharias zur Adria mit\nZacharias Ziegeler eilte mit dem Zug immer heiter um die Erde\n\nDie Zufahrt zur Garage ist gut gestreut, dieses ist immer gut\nJetzt herrschte fast eisige Stille, darum rettete er das Tier\n\nKurt Zart hört leise dem Leser zu, ja er ist sehr aufmerksam;\nGerd Zielazeck ist der gute Stegreifdichter, der immer lacht;\n\nJeder hat aufmerksam die Ersatzteile aus Edelstahl gesichtet;\nHerr Fritz Zart macht jetzt diese mutige Aussage zur Tatzeit;\n\nDer Arzt machte zur Zeit viele Versuche, das ist sehr richtig\nFrau Kraus geht mit ihrer Katze zum Tierarzt, das ist richtig\n\nJulius Ziegler geht als starker Sieger direkt auf das Ziel zu\nStatt der Tiere aus dem Zirkus zeigt Karla die Katze Mizemaus\n\nDieser Zufahrtssteg ist seit heute mit Stahlgitter zugemacht;\nDie Zufahrt zur Garage der Reiter ist sehr dauerhaft verlegt;"
+    "text": "Kurt Zeiger macht heute die Fahrt mit Zacharias zur Adria mit\nZacharias Ziegeler eilte mit dem Zug immer heiter um die Erde\n\nDie Zufahrt zur Garage ist gut gestreut, dieses ist immer gut\nJetzt herrschte fast eisige Stille, darum rettete er das Tier\n\nKurt Zart hört leise dem Leser zu, ja er ist sehr aufmerksam;\nGerd Zielazeck ist der gute Stegreifdichter, der immer lacht;\n\nJeder hat aufmerksam die Ersatzteile aus Edelstahl gesichtet;\nHerr Fritz Zart macht jetzt diese mutige Aussage zur Tatzeit;\n\nDer Arzt machte zur Zeit viele Versuche, das ist sehr richtig\nFrau Kraus geht mit ihrer Katze zum Tierarzt, das ist richtig\n\nJulius Ziegler geht als starker Sieger direkt auf das Ziel zu\nStatt der Tiere aus dem Zirkus zeigt Karla die Katze Mizemaus\n\nDieser Zufahrtssteg ist seit heute mit Stahlgitter zugemacht;\nDie Zufahrt zur Garage der Reiter ist sehr dauerhaft verlegt;",
+    "task": "dummy"
   },
   {
-    "lesson": 100,
+    "lesson": "100",
     "title": "Test",
-    "text": "asdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö"
+    "text": "asdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö",
+    "task": "dummy"
   }
-]
+]

routes/main.py

@@ -0,0 +1,49 @@
+"""
+Main Routes Blueprint
+Handles main pages and static file serving
+"""
+
+import logging
+from flask import Blueprint, render_template, send_from_directory
+
+logger = logging.getLogger(__name__)
+
+main_bp = Blueprint('main', __name__)
+
+
+@main_bp.route('/')
+def welcome():
+    """Begrüßungsseite / Landing Page"""
+    return render_template('welcome.html')
+
+
+@main_bp.route('/hilfe')
+def hilfe():
+    """Online-Hilfe anzeigen"""
+    try:
+        import markdown
+
+        with open('HILFE.md', 'r', encoding='utf-8') as f:
+            hilfe_content = f.read()
+
+        # Konvertiere Markdown zu HTML
+        hilfe_html = markdown.markdown(
+            hilfe_content,
+            extensions=['tables', 'fenced_code', 'nl2br']
+        )
+
+        return render_template('hilfe.html', hilfe_html=hilfe_html)
+    except ImportError:
+        logger.warning("Markdown-Modul nicht installiert, verwende Plain-Text-Anzeige")
+        with open('HILFE.md', 'r', encoding='utf-8') as f:
+            hilfe_content = f.read()
+        return render_template('hilfe.html', hilfe_html=f"<pre>{hilfe_content}</pre>")
+    except Exception as e:
+        logger.error(f"Fehler beim Laden der Hilfe: {e}")
+        return render_template('hilfe.html', hilfe_html="<p>Hilfe konnte nicht geladen werden.</p>")
+
+
+@main_bp.route('/images/<path:filename>')
+def serve_images(filename):
+    """Serviert Bilder aus dem images-Verzeichnis"""
+    return send_from_directory('images', filename)

routes/session.py

@@ -0,0 +1,87 @@
+"""
+Session Routes Blueprint
+Handles session management routes
+"""
+
+import logging
+from flask import Blueprint, render_template, request, jsonify
+from services.statistics_service import StatisticsService
+from services.settings_service import SettingsService
+from services.progress_service import ProgressService
+
+logger = logging.getLogger(__name__)
+
+session_bp = Blueprint('session', __name__)
+
+# Initialize services
+statistics_service = StatisticsService()
+settings_service = SettingsService()
+progress_service = ProgressService()
+
+
+@session_bp.route('/end_session', methods=['POST'])
+def end_session():
+    """Beendet eine Tipp-Session und speichert Statistiken"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        # Get session time
+        total_elapsed_time = float(data.get('total_elapsed_time', 0))
+        minutes_practiced = total_elapsed_time / 60.0
+
+        # Update daily practice
+        if minutes_practiced > 0:
+            statistics_service.update_daily_practice(minutes_practiced)
+
+        # Get current lesson
+        current_lesson = progress_service.get_current_lesson_index()
+
+        # Save all settings
+        settings_service.update_settings(
+            current_lesson_index=current_lesson,
+            metronome_enabled=data.get('metronome_enabled', False),
+            metronome_bpm=data.get('metronome_bpm', 60),
+            metronome_sound=data.get('metronome_sound', 'beep'),
+            metronome_mode=data.get('metronome_mode', 'automatic'),
+            metronome_speed=data.get('metronome_speed', 60),
+            target_error_rate=data.get('target_error_rate', 5),
+            max_bpm_speed=data.get('max_bpm_speed', 100),
+            speed_display=data.get('speed_display', 'zpm')
+        )
+
+        logger.info(f"Session beendet: {minutes_practiced:.2f} Minuten geübt")
+        return jsonify({
+            'status': 'success',
+            'message': 'Session beendet',
+            'redirect': '/session_end'
+        })
+
+    except Exception as e:
+        logger.error(f"Fehler in end_session: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@session_bp.route('/session_end')
+def session_end():
+    """Zeigt die Endseite mit Übungsstatistiken der letzten 30 Tage"""
+    try:
+        # Get full 30 days practice data
+        full_data = statistics_service.get_full_30_days_practice()
+
+        # Calculate total statistics
+        total_minutes = sum(d['minutes'] for d in full_data)
+        days_practiced = sum(1 for d in full_data if d['minutes'] > 0)
+
+        return render_template('session_end.html',
+                             practice_data=full_data,
+                             total_minutes=total_minutes,
+                             days_practiced=days_practiced)
+
+    except Exception as e:
+        logger.error(f"Fehler in session_end: {e}", exc_info=True)
+        return render_template('session_end.html',
+                             practice_data=[],
+                             total_minutes=0,
+                             days_practiced=0)

routes/settings.py

@@ -0,0 +1,128 @@
+"""
+Settings Routes Blueprint
+Handles all settings-related routes
+"""
+
+import logging
+from flask import Blueprint, render_template, request, jsonify, session
+from services.settings_service import SettingsService
+from services.progress_service import ProgressService
+
+logger = logging.getLogger(__name__)
+
+settings_bp = Blueprint('settings', __name__)
+
+# Initialize services
+settings_service = SettingsService()
+progress_service = ProgressService()
+
+
+@settings_bp.route('/settings')
+def settings():
+    """Einstellungsseite"""
+    settings_dict = settings_service.get_settings_dict()
+    current_settings = {
+        'metronome_mode': settings_dict['metronome_mode'],
+        'metronome_speed': settings_dict['metronome_speed'],
+        'target_error_rate': settings_dict['target_error_rate'],
+        'max_bpm_speed': settings_dict['max_bpm_speed'],
+        'speed_display': settings_dict['speed_display']
+    }
+    return render_template('settings.html', settings=current_settings)
+
+
+@settings_bp.route('/save_settings', methods=['POST'])
+def save_settings_route():
+    """Speichert die Einstellungen persistent in der Datenbank"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        # Extract and validate settings
+        metronome_mode = data.get('metronome_mode', 'automatic')
+        if not settings_service.validate_metronome_mode(metronome_mode):
+            return jsonify({'error': 'Ungültiger Metronom-Modus'}), 400
+
+        # Validate numeric values
+        try:
+            metronome_speed = int(data.get('metronome_speed', 60))
+            target_error_rate = int(data.get('target_error_rate', 5))
+            max_bpm_speed = int(data.get('max_bpm_speed', 100))
+        except (ValueError, TypeError):
+            return jsonify({'error': 'Ungültige numerische Werte'}), 400
+
+        # Validate ranges
+        if not settings_service.validate_metronome_speed(metronome_speed):
+            return jsonify({'error': 'Metronom-Geschwindigkeit muss zwischen 20 und 300 liegen'}), 400
+
+        if not settings_service.validate_target_error_rate(target_error_rate):
+            return jsonify({'error': 'Fehlerrate muss zwischen 0 und 100 liegen'}), 400
+
+        if not settings_service.validate_max_bpm_speed(max_bpm_speed):
+            return jsonify({'error': 'Maximale BPM-Geschwindigkeit muss zwischen 40 und 200 liegen'}), 400
+
+        # Validate speed display
+        speed_display = data.get('speed_display', 'zpm')
+        if not settings_service.validate_speed_display(speed_display):
+            return jsonify({'error': 'Ungültige Geschwindigkeitsanzeige'}), 400
+
+        # Get current lesson
+        current_lesson = progress_service.get_current_lesson_index()
+
+        # Update settings
+        settings_service.update_settings(
+            current_lesson_index=current_lesson,
+            metronome_enabled=True,
+            metronome_bpm=metronome_speed,
+            metronome_sound='beep',
+            metronome_mode=metronome_mode,
+            metronome_speed=metronome_speed,
+            target_error_rate=target_error_rate,
+            max_bpm_speed=max_bpm_speed,
+            speed_display=speed_display
+        )
+
+        logger.info(f"Einstellungen gespeichert: mode={metronome_mode}, speed={metronome_speed}, max_bpm={max_bpm_speed}")
+        return jsonify({'status': 'success'})
+
+    except Exception as e:
+        logger.error(f"Fehler in save_settings: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@settings_bp.route('/set_metronome', methods=['POST'])
+def set_metronome():
+    """Setzt die Metronom-Einstellungen in der Session"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        # Validation
+        enabled = bool(data.get('enabled', False))
+
+        try:
+            bpm = int(data.get('bpm', 60))
+        except (ValueError, TypeError):
+            return jsonify({'error': 'Ungültiger BPM-Wert'}), 400
+
+        # Extended validation
+        if bpm < 20:
+            return jsonify({'error': 'BPM muss mindestens 20 sein'}), 400
+        if bpm > 300:
+            return jsonify({'error': 'BPM darf maximal 300 sein'}), 400
+
+        sound = data.get('sound', 'beep')
+        if not settings_service.validate_metronome_sound(sound):
+            sound = 'beep'  # Fallback
+
+        session['metronome_enabled'] = enabled
+        session['metronome_bpm'] = bpm
+        session['metronome_sound'] = sound
+
+        return jsonify({'status': 'success'})
+
+    except Exception as e:
+        logger.error(f"Fehler in set_metronome: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500

routes/statistics.py

@@ -0,0 +1,182 @@
+"""
+Statistics Routes Blueprint
+Handles all statistics-related routes
+"""
+
+import logging
+import csv
+import json
+from io import StringIO
+from datetime import datetime
+from flask import Blueprint, render_template, request, jsonify, session, Response, make_response
+from models import db
+from services.helpers import lessons
+from services.statistics_service import StatisticsService
+from services.progress_service import ProgressService
+from services.lesson_service import LessonService
+
+logger = logging.getLogger(__name__)
+
+statistics_bp = Blueprint('statistics', __name__)
+
+# Initialize services
+statistics_service = StatisticsService()
+progress_service = ProgressService()
+lesson_service = LessonService(lessons)
+
+
+@statistics_bp.route('/statistics')
+def statistics():
+    """Zeigt die Statistik-Seite mit Diagrammen"""
+    try:
+        # Get current lesson index
+        current_lesson_index = progress_service.get_current_lesson_index()
+
+        # Check which lessons have statistics
+        lesson_has_data = [
+            statistics_service.has_lesson_statistics(i)
+            for i in range(lesson_service.get_lesson_count())
+        ]
+
+        # Get speed display setting
+        speed_display = session.get('speed_display', 'zpm')
+
+        return render_template('statistics.html',
+                             lessons=lessons,
+                             current_lesson_index=current_lesson_index,
+                             lesson_has_data=lesson_has_data,
+                             speed_display=speed_display)
+    except Exception as e:
+        logger.error(f"Fehler in statistics(): {e}", exc_info=True)
+        return render_template('statistics.html',
+                             lessons=[],
+                             current_lesson_index=0,
+                             lesson_has_data=[],
+                             speed_display='zpm')
+
+
+@statistics_bp.route('/get_lesson_statistics/<int:lesson_index>')
+def get_lesson_statistics(lesson_index: int) -> Response:
+    """Gibt die Statistiken für eine bestimmte Lektion zurück"""
+    try:
+        data = statistics_service.get_lesson_statistics_data(lesson_index)
+        return jsonify(data)
+
+    except Exception as e:
+        logger.error(f"Fehler in get_lesson_statistics: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@statistics_bp.route('/reset_lesson_statistics', methods=['POST'])
+def reset_lesson_statistics():
+    """Löscht alle Statistiken für eine bestimmte Lektion"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        lesson_index = data.get('lesson_index')
+        if lesson_index is None:
+            return jsonify({'error': 'Lektionsindex fehlt'}), 400
+
+        try:
+            lesson_index = int(lesson_index)
+        except (ValueError, TypeError):
+            return jsonify({'error': 'Ungültiger Lektionsindex'}), 400
+
+        if not lesson_service.validate_lesson_index(lesson_index):
+            return jsonify({'error': 'Lektionsindex außerhalb des gültigen Bereichs'}), 400
+
+        # Delete statistics
+        deleted_count = statistics_service.delete_lesson_statistics(lesson_index)
+
+        return jsonify({
+            'status': 'success',
+            'message': f'{deleted_count} Statistik-Einträge gelöscht',
+            'lesson_index': lesson_index,
+            'deleted_count': deleted_count
+        })
+
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Fehler in reset_lesson_statistics: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@statistics_bp.route('/export/statistics/csv')
+def export_statistics_csv() -> Response:
+    """Exportiert alle Statistiken als CSV-Datei"""
+    try:
+        # Get all statistics
+        stats = statistics_service.get_all_statistics()
+
+        # Create CSV
+        output = StringIO()
+        writer = csv.writer(output)
+
+        # Header
+        writer.writerow(['Datum', 'Lektion-Nr', 'Lektionstitel', 'Zeichen/Min', 'Fehlerrate %', 'Wörter/Min'])
+
+        # Data
+        for stat in stats:
+            lesson_title = lesson_service.get_lesson_title(stat.lesson_index)
+
+            writer.writerow([
+                stat.created_at.strftime('%Y-%m-%d %H:%M:%S'),
+                stat.lesson_index + 1,
+                lesson_title,
+                f"{stat.chars_per_minute:.1f}",
+                f"{stat.error_rate:.1f}",
+                f"{stat.wpm:.2f}"
+            ])
+
+        # Create response
+        response = make_response(output.getvalue())
+        response.headers['Content-Type'] = 'text/csv; charset=utf-8'
+        response.headers['Content-Disposition'] = 'attachment; filename=typewriter_statistiken.csv'
+
+        logger.info(f"CSV-Export erfolgreich: {len(stats)} Einträge")
+        return response
+
+    except Exception as e:
+        logger.error(f"Fehler beim CSV-Export: {e}", exc_info=True)
+        return jsonify({'error': 'Fehler beim Export'}), 500
+
+
+@statistics_bp.route('/export/statistics/json')
+def export_statistics_json() -> Response:
+    """Exportiert alle Statistiken als JSON-Datei"""
+    try:
+        # Get all statistics
+        stats = statistics_service.get_all_statistics()
+
+        # Create JSON data
+        export_data = {
+            'export_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'total_entries': len(stats),
+            'statistics': []
+        }
+
+        for stat in stats:
+            lesson_title = lesson_service.get_lesson_title(stat.lesson_index)
+
+            export_data['statistics'].append({
+                'date': stat.created_at.strftime('%Y-%m-%d %H:%M:%S'),
+                'lesson_number': stat.lesson_index + 1,
+                'lesson_title': lesson_title,
+                'chars_per_minute': round(stat.chars_per_minute, 1),
+                'error_rate': round(stat.error_rate, 1),
+                'words_per_minute': round(stat.wpm, 2)
+            })
+
+        # Create response
+        response = make_response(json.dumps(export_data, ensure_ascii=False, indent=2))
+        response.headers['Content-Type'] = 'application/json; charset=utf-8'
+        response.headers['Content-Disposition'] = 'attachment; filename=typewriter_statistiken.json'
+
+        logger.info(f"JSON-Export erfolgreich: {len(stats)} Einträge")
+        return response
+
+    except Exception as e:
+        logger.error(f"Fehler beim JSON-Export: {e}", exc_info=True)
+        return jsonify({'error': 'Fehler beim Export'}), 500

routes/training.py

@@ -0,0 +1,215 @@
+"""
+Training Routes Blueprint
+Handles all training-related routes
+"""
+
+import logging
+from flask import Blueprint, render_template, request, jsonify
+from models import db
+from services import helpers
+from services.lesson_service import LessonService
+from services.training_service import TrainingService
+
+logger = logging.getLogger(__name__)
+
+training_bp = Blueprint('training', __name__)
+
+# Initialize services (will be populated when lessons are loaded)
+lesson_service = None
+training_service = None
+
+
+def get_services():
+    """Lazy initialization of services after lessons are loaded"""
+    global lesson_service, training_service
+    if lesson_service is None:
+        lesson_service = LessonService(helpers.lessons)
+        training_service = TrainingService(lesson_service)
+    return lesson_service, training_service
+
+
+@training_bp.route('/train')
+def train():
+    """Hauptseite des Tipptrainers"""
+    try:
+        _, training_service = get_services()
+        context = training_service.get_training_context()
+        return render_template('index.html', **context)
+
+    except Exception as e:
+        logger.error(f"Fehler in train(): {e}", exc_info=True)
+        # Fehlerfall mit Standardwerten
+        return render_template('index.html',
+                             current_text="Fehler beim Laden der Lektionen",
+                             current_position=0,
+                             last_text="",
+                             lessons=[],
+                             metronome_enabled=False,
+                             metronome_bpm=60,
+                             metronome_sound='beep')
+
+
+@training_bp.route('/update_progress', methods=['POST'])
+def update_progress():
+    """Aktualisiert den Tippfortschritt mit echter Zeitmessung"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        # Input-Validierung
+        user_input = data.get('user_input', '')
+        current_text = data.get('current_text', '')
+
+        # Validiere numerische Werte
+        try:
+            elapsed_time = float(data.get('elapsed_time', 0))
+            cursor_position = int(data.get('cursor_position', len(user_input)))
+            total_elapsed_time = float(data.get('total_elapsed_time', 0))
+            net_training_time = float(data.get('net_training_time', 0))
+            key_stroke_count = int(data.get('key_stroke_count', 0))
+        except (ValueError, TypeError):
+            return jsonify({'error': 'Ungültige numerische Werte'}), 400
+
+        # Validiere Bereiche
+        if elapsed_time < 0 or total_elapsed_time < 0 or net_training_time < 0 or key_stroke_count < 0:
+            return jsonify({'error': 'Negative Werte sind nicht erlaubt'}), 400
+
+        if cursor_position < 0:
+            return jsonify({'error': 'Cursor-Position muss >= 0 sein'}), 400
+
+        is_paused = bool(data.get('is_paused', False))
+
+        try:
+            # Update progress and get statistics
+            _, training_service = get_services()
+            stats = training_service.update_training_progress(
+                user_input=user_input,
+                current_text=current_text,
+                elapsed_time=elapsed_time,
+                cursor_position=cursor_position,
+                total_elapsed_time=total_elapsed_time,
+                net_training_time=net_training_time,
+                key_stroke_count=key_stroke_count,
+                is_paused=is_paused
+            )
+
+            return jsonify(stats)
+
+        except Exception as db_error:
+            db.session.rollback()
+            logger.error(f"Datenbank-Fehler beim Speichern des Fortschritts: {db_error}", exc_info=True)
+            return jsonify({'error': 'Fehler beim Speichern des Fortschritts'}), 500
+
+    except Exception as e:
+        logger.error(f"Fehler in update_progress: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@training_bp.route('/next_text', methods=['POST'])
+def next_text():
+    """Wechselt zum nächsten Text"""
+    try:
+        _, training_service = get_services()
+        result = training_service.switch_to_next_lesson()
+        return jsonify(result)
+
+    except Exception as e:
+        logger.error(f"Fehler in next_text: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@training_bp.route('/set_lesson', methods=['POST'])
+def set_lesson():
+    """Setzt die aktuelle Lektion auf die ausgewählte"""
+    try:
+        data = request.get_json()
+        lesson_index = data.get('lesson_index')
+
+        if lesson_index is None or not isinstance(lesson_index, int):
+            return jsonify({'error': 'Ungültiger Lektionsindex'}), 400
+
+        _, training_service = get_services()
+        success, result = training_service.switch_to_lesson(lesson_index)
+
+        if not success:
+            return jsonify(result), 400
+
+        return jsonify(result)
+
+    except Exception as e:
+        logger.error(f"Fehler in set_lesson: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@training_bp.route('/save_lesson_statistics', methods=['POST'])
+def save_lesson_statistics():
+    """Speichert die Statistiken für eine abgeschlossene Lektion"""
+    from services.statistics_service import StatisticsService
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'Keine Daten empfangen'}), 400
+
+        # Input-Validierung
+        lesson_index = data.get('lesson_index')
+        if lesson_index is None:
+            return jsonify({'error': 'Lektionsindex fehlt'}), 400
+
+        # Validiere Typen und Bereiche
+        try:
+            lesson_index = int(lesson_index)
+            chars_per_minute = float(data.get('chars_per_minute', 0))
+            error_rate = float(data.get('error_rate', 0))
+            wpm = float(data.get('wpm', 0))
+            training_duration = float(data.get('training_duration', 0))
+        except (ValueError, TypeError):
+            return jsonify({'error': 'Ungültige Datentypen'}), 400
+
+        # Bereichsvalidierung
+        if lesson_index < 0 or lesson_index >= len(helpers.lessons):
+            return jsonify({'error': 'Ungültiger Lektionsindex'}), 400
+
+        if chars_per_minute < 0 or error_rate < 0 or wpm < 0 or training_duration < 0:
+            return jsonify({'error': 'Negative Werte sind nicht erlaubt'}), 400
+
+        if error_rate > 100:
+            return jsonify({'error': 'Fehlerrate kann nicht über 100% sein'}), 400
+
+        try:
+            StatisticsService.save_lesson_statistics(
+                lesson_index=lesson_index,
+                chars_per_minute=chars_per_minute,
+                error_rate=error_rate,
+                wpm=wpm,
+                training_duration=training_duration
+            )
+
+            return jsonify({'status': 'success', 'message': 'Lektionsstatistiken gespeichert'})
+
+        except Exception as db_error:
+            db.session.rollback()
+            logger.error(f"Datenbank-Fehler beim Speichern der Statistik: {db_error}", exc_info=True)
+            return jsonify({'error': 'Fehler beim Speichern der Statistik'}), 500
+
+    except Exception as e:
+        logger.error(f"Fehler in save_lesson_statistics: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500
+
+
+@training_bp.route('/reset_lesson', methods=['POST'])
+def reset_lesson():
+    """Setzt den Fortschritt der aktuellen Lektion zurück"""
+    try:
+        _, training_service = get_services()
+        success, result = training_service.reset_current_lesson()
+
+        if not success:
+            return jsonify(result), 400
+
+        return jsonify(result)
+
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Fehler in reset_lesson: {e}", exc_info=True)
+        return jsonify({'error': 'Interner Serverfehler'}), 500

routes/utils.py

@@ -0,0 +1,161 @@
+"""
+Utils Routes Blueprint
+Handles utility and debug routes
+"""
+
+import os
+import json
+import logging
+import threading
+import time
+from flask import Blueprint, request, jsonify, current_app
+from services.helpers import (
+    lessons,
+    DATA_PATH,
+    repair_json,
+    load_lessons,
+    create_sample_lessons
+)
+from models import Progress
+
+logger = logging.getLogger(__name__)
+
+utils_bp = Blueprint('utils', __name__)
+
+
+@utils_bp.route('/debug')
+def debug():
+    """Debug-Route zum Überprüfen der Lektionen und Konfiguration"""
+    # Debug-Endpoint nur im Debug-Modus verfügbar
+    if not current_app.debug:
+        from flask import abort
+        abort(404)
+
+    progress = Progress.query.first()
+
+    # Versuche, den Inhalt der JSON-Datei zu lesen
+    json_content = "Datei nicht gefunden"
+    json_error = None
+    try:
+        if os.path.exists(DATA_PATH):
+            with open(DATA_PATH, "r", encoding="utf-8") as f:
+                json_content = f.read()
+    except Exception as e:
+        json_content = f"Fehler beim Lesen der Datei: {e}"
+        json_error = str(e)
+
+    debug_info = {
+        'lessons_loaded': len(lessons),
+        'lessons_sample': lessons[:3] if lessons else [],  # Nur erste 3 anzeigen
+        'data_path': DATA_PATH,
+        'file_exists': os.path.exists(DATA_PATH),
+        'file_size': os.path.getsize(DATA_PATH) if os.path.exists(DATA_PATH) else 0,
+        'file_content_preview': json_content[:500] + '...' if len(json_content) > 500 else json_content,
+        'json_error': json_error,
+        'current_progress': {
+            'current_text_index': progress.current_text_index if progress else None,
+            'current_position': progress.current_position if progress else None,
+            'last_text_length': len(progress.last_text) if progress and progress.last_text else 0,
+            'last_text_preview': progress.last_text[:100] + '...' if progress and progress.last_text and len(progress.last_text) > 100 else progress.last_text if progress else None
+        } if progress else None,
+        'app_root_path': current_app.root_path,
+        'fallback_used': False  # Simplified check
+    }
+
+    return jsonify(debug_info)
+
+
+@utils_bp.route('/repair_json', methods=['POST'])
+def repair_json_endpoint():
+    """Endpoint zum manuellen Reparieren der JSON-Datei"""
+    try:
+        if os.path.exists(DATA_PATH):
+            with open(DATA_PATH, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            repaired_content = repair_json(content)
+
+            # Validiere das reparierte JSON
+            try:
+                json.loads(repaired_content)
+
+                # Backup der originalen Datei erstellen
+                backup_path = DATA_PATH + ".backup"
+                with open(backup_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+
+                # Reparierte Version speichern
+                with open(DATA_PATH, "w", encoding="utf-8") as f:
+                    f.write(repaired_content)
+
+                # Lektionen neu laden
+                load_lessons()
+
+                return jsonify({
+                    'status': 'success',
+                    'message': f'JSON erfolgreich repariert. Backup erstellt: {backup_path}',
+                    'lessons_loaded': len(lessons)
+                })
+
+            except json.JSONDecodeError as e:
+                return jsonify({
+                    'status': 'error',
+                    'message': f'Repariertes JSON ist immer noch ungültig: {e}'
+                }), 400
+        else:
+            return jsonify({
+                'status': 'error',
+                'message': 'JSON-Datei nicht gefunden'
+            }), 404
+
+    except Exception as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Fehler beim Reparieren: {e}'
+        }), 500
+
+
+@utils_bp.route('/recreate_lessons', methods=['POST'])
+def recreate_lessons():
+    """Endpoint zum Neuerstellen der Lektionen-Datei"""
+    try:
+        new_lessons = create_sample_lessons()
+        return jsonify({
+            'status': 'success',
+            'message': 'Beispiel-Lektionen erfolgreich erstellt',
+            'lessons_loaded': len(new_lessons)
+        })
+    except Exception as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Fehler beim Erstellen der Lektionen: {e}'
+        }), 500
+
+
+@utils_bp.route('/shutdown', methods=['POST'])
+def shutdown():
+    """Beendet den Flask-Server (nur für lokale Desktop-Nutzung)"""
+    from flask_wtf.csrf import csrf
+    try:
+        logger.info("Server-Shutdown angefordert")
+
+        # Nur im Debug-Mode erlauben
+        if not current_app.debug:
+            return jsonify({'error': 'Shutdown nur im Debug-Mode erlaubt'}), 403
+
+        # Verzögert beenden, damit die Response noch gesendet werden kann
+        def shutdown_server():
+            time.sleep(0.5)
+            os._exit(0)
+        threading.Thread(target=shutdown_server).start()
+        return jsonify({'status': 'success', 'message': 'Server wird beendet...'})
+    except Exception as e:
+        logger.error(f"Fehler beim Shutdown: {e}", exc_info=True)
+        return jsonify({'error': str(e)}), 500
+
+
+# Disable CSRF for shutdown route
+@utils_bp.before_app_request
+def exempt_shutdown_from_csrf():
+    """Exempts shutdown route from CSRF protection"""
+    pass

run_coverage.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Generate Test Coverage Report
+
+echo "📊 Generating Test Coverage Report..."
+echo ""
+
+# Check if coverage is installed
+if ! command -v coverage &> /dev/null; then
+    echo "❌ Coverage not installed. Installing..."
+    pip install coverage
+fi
+
+# Run tests with coverage
+echo "🧪 Running tests with coverage..."
+coverage run -m unittest discover -s tests -p "test_*.py"
+
+echo ""
+echo "📈 Coverage Report:"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+coverage report -m
+
+# Generate HTML report
+echo ""
+echo "🌐 Generating HTML report..."
+coverage html
+
+echo ""
+echo "✅ Done!"
+echo ""
+echo "📁 HTML report generated in: htmlcov/"
+echo "   Open htmlcov/index.html in your browser to view detailed coverage."
+echo ""

services/helpers.py

@@ -0,0 +1,380 @@
+"""
+Helper Functions
+Contains utility functions for the typewriter application
+"""
+
+import os
+import json
+import re
+import logging
+import secrets
+from typing import Dict, List, Any, Optional
+from datetime import date, timedelta
+from sqlalchemy import inspect
+
+# Logging
+logger = logging.getLogger(__name__)
+
+# Globale Variablen
+lessons: List[Dict[str, Any]] = []
+DATA_PATH: str = ""
+
+# Fallback-Lektionen für den Fall, dass die JSON-Datei nicht geladen werden kann
+FALLBACK_LESSONS = [
+    {"text": "Dies ist der erste Übungstext für den Tipptrainer. Beginne mit diesem einfachen Text."},
+    {"text": "Übung macht den Meister. Tippe weiter, um deine Geschwindigkeit und Genauigkeit zu verbessern."},
+    {"text": "Die schnelle braune Fuchs springt über den faulen Hund. Dies ist ein klassischer Übungstext."},
+    {"text": "Programmieren lernen mit Python macht Spaß und eröffnet viele Möglichkeiten in der Softwareentwicklung."}
+]
+
+
+def initialize_paths(app_root_path: str) -> None:
+    """Initialisiert die globalen Pfade"""
+    global DATA_PATH
+    DATA_PATH = os.path.join(app_root_path, "data", "lessons.json")
+
+
+def get_version() -> str:
+    """Liest die Versionsnummer aus der VERSION-Datei"""
+    version_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'VERSION')
+    try:
+        with open(version_file, 'r') as f:
+            return f.read().strip()
+    except Exception:
+        return '0.5.0'
+
+
+def get_or_create_secret_key() -> str:
+    """
+    Holt den Secret Key aus der .env Datei oder generiert einen neuen.
+    Die .env Datei ist nur vom User schreib- und lesbar (0o600).
+    """
+    env_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
+
+    # Versuche Secret Key aus .env zu laden
+    if os.path.exists(env_path):
+        try:
+            with open(env_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith('SECRET_KEY='):
+                        secret_key = line.split('=', 1)[1].strip()
+                        if secret_key:
+                            logger.info("Secret Key aus .env geladen")
+                            return secret_key
+        except Exception as e:
+            logger.warning(f"Fehler beim Lesen der .env Datei: {e}")
+
+    # Secret Key generieren und speichern
+    logger.info("Generiere neuen Secret Key...")
+    secret_key = secrets.token_hex(32)  # 64 Zeichen Hex-String
+
+    try:
+        with open(env_path, 'w') as f:
+            f.write(f"SECRET_KEY={secret_key}\n")
+
+        # Setze Dateiberechtigungen auf 0o600 (nur User kann lesen/schreiben)
+        os.chmod(env_path, 0o600)
+        logger.info(f"Neuer Secret Key generiert und in .env gespeichert (Berechtigungen: 0o600)")
+    except Exception as e:
+        logger.error(f"Fehler beim Speichern der .env Datei: {e}")
+        logger.warning("Verwende temporären Secret Key für diese Session")
+
+    return secret_key
+
+
+def repair_json(json_string: str) -> str:
+    """Versucht, häufige JSON-Fehler automatisch zu reparieren"""
+    try:
+        # Repariere fehlende Kommas zwischen Objekten
+        # Sucht nach } followed by { ohne Komma dazwischen
+        repaired = re.sub(r'\}\s*\n\s*\{', '},\n{', json_string)
+
+        # Repariere fehlende Kommas am Ende von Objekten im Array
+        repaired = re.sub(r'\}\s*\n\s*\]', '}\n]', repaired)
+
+        # Repariere fehlende Anführungszeichen bei Keys
+        repaired = re.sub(r'(\w+)\s*:', r'"\1":', repaired)
+
+        # Repariere fehlende schließende Klammern
+        brackets_open = repaired.count('[') + repaired.count('{')
+        brackets_close = repaired.count(']') + repaired.count('}')
+
+        if brackets_open > brackets_close:
+            repaired += ']' * (brackets_open - brackets_close)
+
+        return repaired
+    except Exception as e:
+        logger.error(f"Fehler beim Reparieren des JSON: {e}")
+        return json_string
+
+
+def load_lessons() -> None:
+    """Lädt Lektionen aus der JSON-Datei oder verwendet Fallback"""
+    global lessons
+    try:
+        if os.path.exists(DATA_PATH):
+            with open(DATA_PATH, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+
+            # Versuche zuerst das originale JSON zu laden
+            try:
+                lessons = json.loads(content)
+                logger.info(f"Erfolgreich {len(lessons)} Lektionen aus {DATA_PATH} geladen")
+                return
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON-Fehler in {DATA_PATH}: {e}")
+                logger.error(f"Position: Zeile {e.lineno}, Spalte {e.colno}")
+
+                # Versuche das JSON zu reparieren
+                logger.info("Versuche JSON automatisch zu reparieren...")
+                repaired_content = repair_json(content)
+
+                try:
+                    lessons = json.loads(repaired_content)
+                    logger.info(f"Erfolgreich {len(lessons)} Lektionen nach Reparatur geladen")
+
+                    # Speichere die reparierte Version als Backup
+                    backup_path = DATA_PATH + ".repaired"
+                    with open(backup_path, "w", encoding="utf-8") as f:
+                        json.dump(lessons, f, indent=2, ensure_ascii=False)
+                    logger.info(f"Reparierte Version gespeichert als: {backup_path}")
+                    return
+
+                except json.JSONDecodeError as e2:
+                    logger.error(f"Automatische Reparatur fehlgeschlagen: {e2}")
+                    logger.warning("Verwende Fallback-Lektionen und erstelle neue Lektionen-Datei")
+                    lessons = FALLBACK_LESSONS
+                    # Speichere Fallback-Lektionen für zukünftige Verwendung
+                    with open(DATA_PATH, "w", encoding="utf-8") as f:
+                        json.dump(lessons, f, indent=2, ensure_ascii=False)
+                    logger.info(f"Fallback-Lektionen gespeichert in: {DATA_PATH}")
+        else:
+            logger.warning(f"Datei {DATA_PATH} nicht gefunden. Verwende Fallback-Lektionen und erstelle Datei.")
+            lessons = FALLBACK_LESSONS
+            # Speichere Fallback-Lektionen für zukünftige Verwendung
+            with open(DATA_PATH, "w", encoding="utf-8") as f:
+                json.dump(lessons, f, indent=2, ensure_ascii=False)
+            logger.info(f"Fallback-Lektionen gespeichert in: {DATA_PATH}")
+
+    except Exception as e:
+        logger.error(f"Unerwarteter Fehler beim Laden der Lektionen: {e}")
+        logger.warning("Verwende Fallback-Lektionen")
+        lessons = FALLBACK_LESSONS
+
+
+def create_sample_lessons() -> List[Dict[str, Any]]:
+    """Erstellt eine korrekte Beispiel-JSON-Datei falls nötig"""
+    sample_lessons = [
+        {
+            "id": 1,
+            "text": "Willkommen beim Tipptrainer! Übe das Tippen mit diesem einfachen Text.",
+            "level": "beginner",
+            "description": "Einführungstext für Anfänger"
+        },
+        {
+            "id": 2,
+            "text": "Die schnelle braune Fuchs springt über den faulen Hund. Dies ist ein klassischer Pangramm-Satz.",
+            "level": "beginner",
+            "description": "Pangramm-Übung mit allen Buchstaben"
+        },
+        {
+            "id": 3,
+            "text": "Programmieren mit Python macht großen Spaß und ermöglicht die Entwicklung vielfältiger Anwendungen.",
+            "level": "intermediate",
+            "description": "Programmierbezogener Text"
+        },
+        {
+            "id": 4,
+            "text": "Flüssiges und fehlerfreies Tippen ist in der heutigen digitalen Welt eine wertvolle Fähigkeit für viele Berufe.",
+            "level": "intermediate",
+            "description": "Berufsbezogene Übung"
+        },
+        {
+            "id": 5,
+            "text": "Übung macht den Meister: Regelmäßiges Training verbessert nicht nur die Geschwindigkeit, sondern auch die Genauigkeit beim Tippen erheblich.",
+            "level": "advanced",
+            "description": "Längerer Text für Fortgeschrittene"
+        }
+    ]
+
+    try:
+        with open(DATA_PATH, "w", encoding="utf-8") as f:
+            json.dump(sample_lessons, f, indent=2, ensure_ascii=False)
+        logger.info(f"Beispiel-Lektionen erstellt in: {DATA_PATH}")
+        return sample_lessons
+    except Exception as e:
+        logger.error(f"Fehler beim Erstellen der Beispiel-Lektionen: {e}")
+        return FALLBACK_LESSONS
+
+
+def get_or_create_user_settings(db, UserSettings):
+    """Holt oder erstellt die Benutzereinstellungen"""
+    settings = UserSettings.query.first()
+    if not settings:
+        settings = UserSettings()
+        db.session.add(settings)
+        db.session.commit()
+        logger.info("Neue Benutzereinstellungen erstellt")
+    return settings
+
+
+def get_or_create_lesson_progress(db, LessonProgress, lesson_index: int):
+    """Holt oder erstellt den Fortschritt für eine bestimmte Lektion"""
+    lesson_progress = LessonProgress.query.filter_by(lesson_index=lesson_index).first()
+    if not lesson_progress:
+        lesson_progress = LessonProgress(
+            lesson_index=lesson_index,
+            current_position=0,
+            last_text="",
+            total_elapsed_time=0,
+            key_stroke_count=0,
+            is_paused=True
+        )
+        db.session.add(lesson_progress)
+        db.session.commit()
+        logger.info(f"Neuen Lektions-Fortschritt für Lektion {lesson_index} erstellt")
+    return lesson_progress
+
+
+def save_user_settings(
+    db,
+    UserSettings,
+    current_lesson_index: int,
+    metronome_enabled: bool,
+    metronome_bpm: int,
+    metronome_sound: str,
+    metronome_mode: str,
+    metronome_speed: int,
+    target_error_rate: int,
+    max_bpm_speed: int,
+    speed_display: str
+) -> None:
+    """Speichert Benutzereinstellungen in der Datenbank"""
+    settings = get_or_create_user_settings(db, UserSettings)
+    settings.current_lesson_index = current_lesson_index
+    settings.metronome_enabled = metronome_enabled
+    settings.metronome_bpm = metronome_bpm
+    settings.metronome_sound = metronome_sound
+    settings.metronome_mode = metronome_mode
+    settings.metronome_speed = metronome_speed
+    settings.target_error_rate = target_error_rate
+    settings.max_bpm_speed = max_bpm_speed
+    settings.speed_display = speed_display
+    db.session.commit()
+    logger.info("Benutzereinstellungen gespeichert")
+
+
+def update_daily_practice(db, DailyPractice, minutes: float) -> None:
+    """Aktualisiert die tägliche Übungszeit"""
+    today = date.today()
+    practice = DailyPractice.query.filter_by(date=today).first()
+
+    if practice:
+        practice.minutes_practiced += minutes
+    else:
+        practice = DailyPractice(date=today, minutes_practiced=minutes)
+        db.session.add(practice)
+
+    db.session.commit()
+    logger.info(f"Tägliche Übungszeit aktualisiert: {minutes:.2f} Minuten")
+
+
+def get_last_30_days_practice(DailyPractice) -> List[Dict[str, Any]]:
+    """Holt die Übungszeiten der letzten 30 Tage"""
+    thirty_days_ago = date.today() - timedelta(days=29)
+    practices = DailyPractice.query.filter(DailyPractice.date >= thirty_days_ago).order_by(DailyPractice.date.asc()).all()
+    return [{'date': p.date.strftime('%Y-%m-%d'), 'minutes': p.minutes_practiced} for p in practices]
+
+
+def check_database_status(db_engine):
+    """
+    Prüft ob die Datenbank initialisiert ist und ob Migrationen ausstehen.
+
+    WICHTIG: Für Schema-Änderungen IMMER Alembic verwenden!
+    - Neue Migration erstellen: alembic revision --autogenerate -m "Beschreibung"
+    - Migration anwenden: alembic upgrade head
+    - Migration rückgängig: alembic downgrade -1
+
+    Siehe MIGRATIONS.md für Details.
+    """
+    try:
+        # Prüfe ob alembic_version Tabelle existiert
+        inspector = inspect(db_engine)
+        tables = inspector.get_table_names()
+
+        if 'alembic_version' not in tables:
+            logger.warning("=" * 80)
+            logger.warning("DATENBANK NICHT INITIALISIERT!")
+            logger.warning("Bitte führe folgende Schritte aus:")
+            logger.warning("  1. alembic upgrade head")
+            logger.warning("Siehe MIGRATIONS.md für Details.")
+            logger.warning("=" * 80)
+            return False
+
+        # Prüfe ob benötigte Tabellen existieren
+        required_tables = {'progress', 'lesson_statistic', 'statistic'}
+        missing_tables = required_tables - set(tables)
+
+        if missing_tables:
+            logger.warning("=" * 80)
+            logger.warning(f"FEHLENDE TABELLEN: {', '.join(missing_tables)}")
+            logger.warning("Bitte führe aus: alembic upgrade head")
+            logger.warning("=" * 80)
+            return False
+
+        logger.info("✓ Datenbank initialisiert und bereit")
+        logger.info("  Hinweis: Für Schema-Änderungen verwende Alembic (siehe MIGRATIONS.md)")
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler bei Datenbank-Prüfung: {e}")
+        logger.warning("Falls Datenbank nicht existiert, führe aus: alembic upgrade head")
+        return False
+
+
+def calculate_statistics(user_input: str, current_text: str, elapsed_time: float) -> Dict[str, Any]:
+    """Berechnet Tippstatistiken mit echter Zeitmessung"""
+    correct_chars = 0
+    incorrect_chars = 0
+    total_chars = len(user_input)
+
+    # Zähle korrekte und falsche Zeichen
+    for i, char in enumerate(user_input):
+        if i < len(current_text) and char == current_text[i]:
+            correct_chars += 1
+        else:
+            incorrect_chars += 1
+
+    # Berechne Metriken basierend auf echter Zeit
+    # Mindestzeit von 1 Sekunde, um unrealistische Werte zu vermeiden
+    if total_chars > 0 and elapsed_time >= 1.0:
+        # Zeichen pro Minute (ganzzahlig)
+        chars_per_minute = (total_chars / elapsed_time) * 60
+        # Wörter pro Minute gemäß Formel: (Gesamtzahl der korrekt getippten Zeichen/5)/((Zeit in Sekunden)/60)
+        words_per_minute = (correct_chars / 5) / (elapsed_time / 60)
+        # Durchschnittliche Zeit pro Zeichen
+        duration_per_char = elapsed_time / total_chars
+
+        # Begrenze auf realistische Maximalwerte (z.B. max 1000 ZPM)
+        chars_per_minute = min(chars_per_minute, 1000)
+        words_per_minute = min(words_per_minute, 200)
+    else:
+        chars_per_minute = 0
+        words_per_minute = 0
+        duration_per_char = 0
+
+    # Fehlerrate und Genauigkeit
+    error_rate = (incorrect_chars / total_chars * 100) if total_chars > 0 else 0
+    accuracy = (correct_chars / total_chars * 100) if total_chars > 0 else 0
+
+    return {
+        'correct_chars': correct_chars,
+        'incorrect_chars': incorrect_chars,
+        'total_chars': total_chars,
+        'error_rate': round(error_rate, 1),
+        'typing_speed': round(chars_per_minute),  # Ganzzahlig
+        'duration_per_char': round(duration_per_char, 3),
+        'words_per_minute': round(words_per_minute, 2),  # Auf zwei Nachkommastellen
+        'accuracy': round(accuracy, 2)
+    }

services/lesson_service.py

@@ -0,0 +1,151 @@
+"""
+Lesson Service
+Handles all lesson-related business logic
+"""
+
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LessonService:
+    """Service for managing lessons"""
+
+    def __init__(self, lessons: List[Dict[str, Any]]):
+        """
+        Initialize LessonService with lessons data
+
+        Args:
+            lessons: List of lesson dictionaries
+        """
+        self.lessons = lessons
+
+    def get_all_lessons(self) -> List[Dict[str, Any]]:
+        """
+        Get all lessons
+
+        Returns:
+            List of all lessons
+        """
+        return self.lessons
+
+    def get_lesson_count(self) -> int:
+        """
+        Get total number of lessons
+
+        Returns:
+            Number of lessons
+        """
+        return len(self.lessons)
+
+    def get_lesson_by_index(self, index: int) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific lesson by index
+
+        Args:
+            index: Lesson index
+
+        Returns:
+            Lesson dictionary or None if invalid index
+        """
+        if 0 <= index < len(self.lessons):
+            return self.lessons[index]
+        return None
+
+    def get_lesson_text(self, index: int) -> str:
+        """
+        Get lesson text by index
+
+        Args:
+            index: Lesson index
+
+        Returns:
+            Lesson text or error message
+        """
+        lesson = self.get_lesson_by_index(index)
+        if lesson:
+            return lesson.get('text', 'Kein Text verfügbar')
+        return 'Lektion nicht gefunden'
+
+    def get_lesson_title(self, index: int) -> str:
+        """
+        Get lesson title by index
+
+        Args:
+            index: Lesson index
+
+        Returns:
+            Lesson title or default
+        """
+        lesson = self.get_lesson_by_index(index)
+        if lesson:
+            return lesson.get('title', f'Lektion {index + 1}')
+        return 'Unbekannte Lektion'
+
+    def validate_lesson_index(self, index: int) -> bool:
+        """
+        Validate if lesson index is valid
+
+        Args:
+            index: Lesson index to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        return 0 <= index < len(self.lessons)
+
+    def get_next_lesson_index(self, current_index: int) -> int:
+        """
+        Get next lesson index (wraps around to 0 at end)
+
+        Args:
+            current_index: Current lesson index
+
+        Returns:
+            Next lesson index
+        """
+        if current_index < len(self.lessons) - 1:
+            return current_index + 1
+        return 0
+
+    def get_previous_lesson_index(self, current_index: int) -> int:
+        """
+        Get previous lesson index (wraps around to last at beginning)
+
+        Args:
+            current_index: Current lesson index
+
+        Returns:
+            Previous lesson index
+        """
+        if current_index > 0:
+            return current_index - 1
+        return len(self.lessons) - 1
+
+    def get_lesson_info(self, index: int) -> Dict[str, Any]:
+        """
+        Get complete lesson information
+
+        Args:
+            index: Lesson index
+
+        Returns:
+            Dictionary with lesson info
+        """
+        lesson = self.get_lesson_by_index(index)
+        if not lesson:
+            return {
+                'index': index,
+                'text': 'Lektion nicht gefunden',
+                'title': 'Unbekannte Lektion',
+                'total': len(self.lessons)
+            }
+
+        return {
+            'index': index,
+            'text': lesson.get('text', ''),
+            'title': self.get_lesson_title(index),
+            'task': lesson.get('task', ''),
+            'total': len(self.lessons)
+        }

services/progress_service.py

@@ -0,0 +1,183 @@
+"""
+Progress Service
+Handles all progress and lesson progress related business logic
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from models import db, Progress, LessonProgress
+
+logger = logging.getLogger(__name__)
+
+
+class ProgressService:
+    """Service for managing user progress"""
+
+    @staticmethod
+    def get_or_create_global_progress() -> Progress:
+        """
+        Get or create global progress entry
+
+        Returns:
+            Progress instance
+        """
+        progress = Progress.query.first()
+        if not progress:
+            progress = Progress(
+                current_text_index=0,
+                current_position=0,
+                last_text=""
+            )
+            db.session.add(progress)
+            db.session.commit()
+            logger.info("Neuen globalen Fortschritt initialisiert")
+        return progress
+
+    @staticmethod
+    def get_current_lesson_index() -> int:
+        """
+        Get current lesson index from global progress
+
+        Returns:
+            Current lesson index
+        """
+        progress = ProgressService.get_or_create_global_progress()
+        return progress.current_text_index
+
+    @staticmethod
+    def set_current_lesson_index(lesson_index: int) -> None:
+        """
+        Set current lesson index in global progress
+
+        Args:
+            lesson_index: New lesson index
+        """
+        progress = ProgressService.get_or_create_global_progress()
+        progress.current_text_index = lesson_index
+        db.session.commit()
+        logger.info(f"Globalen Lektionsindex auf {lesson_index} gesetzt")
+
+    @staticmethod
+    def get_or_create_lesson_progress(lesson_index: int) -> LessonProgress:
+        """
+        Get or create lesson progress for specific lesson
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            LessonProgress instance
+        """
+        lesson_progress = LessonProgress.query.filter_by(lesson_index=lesson_index).first()
+        if not lesson_progress:
+            lesson_progress = LessonProgress(
+                lesson_index=lesson_index,
+                current_position=0,
+                last_text="",
+                total_elapsed_time=0,
+                key_stroke_count=0,
+                is_paused=True
+            )
+            db.session.add(lesson_progress)
+            db.session.commit()
+            logger.info(f"Neuen Lektions-Fortschritt für Lektion {lesson_index} erstellt")
+        return lesson_progress
+
+    @staticmethod
+    def get_lesson_progress_data(lesson_index: int) -> Dict[str, Any]:
+        """
+        Get lesson progress data as dictionary
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            Dictionary with progress data
+        """
+        lesson_progress = ProgressService.get_or_create_lesson_progress(lesson_index)
+        return {
+            'current_position': lesson_progress.current_position,
+            'last_text': lesson_progress.last_text,
+            'total_elapsed_time': lesson_progress.total_elapsed_time,
+            'key_stroke_count': lesson_progress.key_stroke_count,
+            'is_paused': lesson_progress.is_paused if lesson_progress.is_paused is not None else True
+        }
+
+    @staticmethod
+    def update_lesson_progress(
+        lesson_index: int,
+        cursor_position: int,
+        user_input: str,
+        total_elapsed_time: int,
+        key_stroke_count: int,
+        is_paused: bool
+    ) -> LessonProgress:
+        """
+        Update lesson progress with new data
+
+        Args:
+            lesson_index: Lesson index
+            cursor_position: Current cursor position
+            user_input: User's typed text
+            total_elapsed_time: Total elapsed time in milliseconds
+            key_stroke_count: Number of keystrokes
+            is_paused: Whether session is paused
+
+        Returns:
+            Updated LessonProgress instance
+        """
+        lesson_progress = ProgressService.get_or_create_lesson_progress(lesson_index)
+        lesson_progress.current_position = cursor_position
+        lesson_progress.last_text = user_input
+        lesson_progress.total_elapsed_time = int(total_elapsed_time)
+        lesson_progress.key_stroke_count = key_stroke_count
+        lesson_progress.is_paused = is_paused
+        db.session.commit()
+        return lesson_progress
+
+    @staticmethod
+    def reset_lesson_progress(lesson_index: int) -> None:
+        """
+        Reset progress for a specific lesson
+
+        Args:
+            lesson_index: Lesson index to reset
+        """
+        lesson_progress = ProgressService.get_or_create_lesson_progress(lesson_index)
+        lesson_progress.current_position = 0
+        lesson_progress.last_text = ""
+        lesson_progress.total_elapsed_time = 0
+        lesson_progress.key_stroke_count = 0
+        lesson_progress.is_paused = True
+        db.session.commit()
+        logger.info(f"Lektion {lesson_index} wurde zurückgesetzt")
+
+    @staticmethod
+    def check_lesson_completed(
+        cursor_position: int,
+        user_input_length: int,
+        lesson_text_length: int
+    ) -> bool:
+        """
+        Check if lesson is completed
+
+        Args:
+            cursor_position: Current cursor position
+            user_input_length: Length of user input
+            lesson_text_length: Length of lesson text
+
+        Returns:
+            True if lesson is completed
+        """
+        return cursor_position >= lesson_text_length and user_input_length == lesson_text_length
+
+    @staticmethod
+    def complete_lesson(lesson_index: int) -> None:
+        """
+        Mark lesson as completed and reset progress
+
+        Args:
+            lesson_index: Lesson index
+        """
+        ProgressService.reset_lesson_progress(lesson_index)
+        logger.info(f"Lektion {lesson_index} abgeschlossen und zurückgesetzt")

services/settings_service.py

@@ -0,0 +1,206 @@
+"""
+Settings Service
+Handles all user settings related business logic
+"""
+
+import logging
+from typing import Dict, Any
+from models import db, UserSettings
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsService:
+    """Service for managing user settings"""
+
+    @staticmethod
+    def get_or_create_user_settings() -> UserSettings:
+        """
+        Get or create user settings entry
+
+        Returns:
+            UserSettings instance
+        """
+        settings = UserSettings.query.first()
+        if not settings:
+            settings = UserSettings()
+            db.session.add(settings)
+            db.session.commit()
+            logger.info("Neue Benutzereinstellungen erstellt")
+        return settings
+
+    @staticmethod
+    def get_settings_dict() -> Dict[str, Any]:
+        """
+        Get user settings as dictionary
+
+        Returns:
+            Dictionary with all settings
+        """
+        settings = SettingsService.get_or_create_user_settings()
+        return {
+            'current_lesson_index': settings.current_lesson_index,
+            'metronome_enabled': settings.metronome_enabled,
+            'metronome_bpm': settings.metronome_bpm,
+            'metronome_sound': settings.metronome_sound,
+            'metronome_mode': settings.metronome_mode,
+            'metronome_speed': settings.metronome_speed,
+            'target_error_rate': settings.target_error_rate,
+            'max_bpm_speed': getattr(settings, 'max_bpm_speed', 100),
+            'speed_display': settings.speed_display
+        }
+
+    @staticmethod
+    def update_settings(
+        current_lesson_index: int = None,
+        metronome_enabled: bool = None,
+        metronome_bpm: int = None,
+        metronome_sound: str = None,
+        metronome_mode: str = None,
+        metronome_speed: int = None,
+        target_error_rate: int = None,
+        max_bpm_speed: int = None,
+        speed_display: str = None
+    ) -> UserSettings:
+        """
+        Update user settings
+
+        Args:
+            current_lesson_index: Current lesson index
+            metronome_enabled: Whether metronome is enabled
+            metronome_bpm: Metronome BPM
+            metronome_sound: Metronome sound type
+            metronome_mode: Metronome mode (automatic/explicit)
+            metronome_speed: Metronome speed
+            target_error_rate: Target error rate percentage
+            max_bpm_speed: Maximum BPM speed
+            speed_display: Speed display mode (zpm/wpm)
+
+        Returns:
+            Updated UserSettings instance
+        """
+        settings = SettingsService.get_or_create_user_settings()
+
+        if current_lesson_index is not None:
+            settings.current_lesson_index = current_lesson_index
+        if metronome_enabled is not None:
+            settings.metronome_enabled = metronome_enabled
+        if metronome_bpm is not None:
+            settings.metronome_bpm = metronome_bpm
+        if metronome_sound is not None:
+            settings.metronome_sound = metronome_sound
+        if metronome_mode is not None:
+            settings.metronome_mode = metronome_mode
+        if metronome_speed is not None:
+            settings.metronome_speed = metronome_speed
+        if target_error_rate is not None:
+            settings.target_error_rate = target_error_rate
+        if max_bpm_speed is not None:
+            settings.max_bpm_speed = max_bpm_speed
+        if speed_display is not None:
+            settings.speed_display = speed_display
+
+        db.session.commit()
+        logger.info("Benutzereinstellungen aktualisiert")
+        return settings
+
+    @staticmethod
+    def save_all_settings(settings_data: Dict[str, Any]) -> UserSettings:
+        """
+        Save all settings from dictionary
+
+        Args:
+            settings_data: Dictionary with settings data
+
+        Returns:
+            Updated UserSettings instance
+        """
+        return SettingsService.update_settings(
+            current_lesson_index=settings_data.get('current_lesson_index'),
+            metronome_enabled=settings_data.get('metronome_enabled'),
+            metronome_bpm=settings_data.get('metronome_bpm'),
+            metronome_sound=settings_data.get('metronome_sound'),
+            metronome_mode=settings_data.get('metronome_mode'),
+            metronome_speed=settings_data.get('metronome_speed'),
+            target_error_rate=settings_data.get('target_error_rate'),
+            max_bpm_speed=settings_data.get('max_bpm_speed'),
+            speed_display=settings_data.get('speed_display')
+        )
+
+    @staticmethod
+    def validate_metronome_mode(mode: str) -> bool:
+        """
+        Validate metronome mode
+
+        Args:
+            mode: Mode to validate
+
+        Returns:
+            True if valid
+        """
+        return mode in ['automatic', 'explicit']
+
+    @staticmethod
+    def validate_metronome_speed(speed: int) -> bool:
+        """
+        Validate metronome speed
+
+        Args:
+            speed: Speed to validate
+
+        Returns:
+            True if valid
+        """
+        return 20 <= speed <= 300
+
+    @staticmethod
+    def validate_target_error_rate(rate: int) -> bool:
+        """
+        Validate target error rate
+
+        Args:
+            rate: Error rate to validate
+
+        Returns:
+            True if valid
+        """
+        return 0 <= rate <= 100
+
+    @staticmethod
+    def validate_max_bpm_speed(speed: int) -> bool:
+        """
+        Validate max BPM speed
+
+        Args:
+            speed: Speed to validate
+
+        Returns:
+            True if valid
+        """
+        return 40 <= speed <= 200
+
+    @staticmethod
+    def validate_speed_display(display: str) -> bool:
+        """
+        Validate speed display mode
+
+        Args:
+            display: Display mode to validate
+
+        Returns:
+            True if valid
+        """
+        return display in ['zpm', 'wpm']
+
+    @staticmethod
+    def validate_metronome_sound(sound: str) -> bool:
+        """
+        Validate metronome sound
+
+        Args:
+            sound: Sound to validate
+
+        Returns:
+            True if valid
+        """
+        return sound in ['beep', 'click', 'woodblock']

services/statistics_service.py

@@ -0,0 +1,250 @@
+"""
+Statistics Service
+Handles all statistics-related business logic
+"""
+
+import logging
+from typing import Dict, Any, List
+from datetime import date, timedelta
+from models import db, LessonStatistic, DailyPractice
+
+logger = logging.getLogger(__name__)
+
+
+class StatisticsService:
+    """Service for managing statistics"""
+
+    @staticmethod
+    def calculate_typing_statistics(
+        user_input: str,
+        current_text: str,
+        elapsed_time: float
+    ) -> Dict[str, Any]:
+        """
+        Calculate typing statistics based on user input
+
+        Args:
+            user_input: User's typed text
+            current_text: Target text
+            elapsed_time: Time elapsed in seconds
+
+        Returns:
+            Dictionary with calculated statistics
+        """
+        correct_chars = 0
+        incorrect_chars = 0
+        total_chars = len(user_input)
+
+        # Count correct and incorrect characters
+        for i, char in enumerate(user_input):
+            if i < len(current_text) and char == current_text[i]:
+                correct_chars += 1
+            else:
+                incorrect_chars += 1
+
+        # Calculate metrics based on real time
+        # Minimum 1 second to avoid unrealistic values
+        if total_chars > 0 and elapsed_time >= 1.0:
+            # Characters per minute (integer)
+            chars_per_minute = (total_chars / elapsed_time) * 60
+            # Words per minute: (correct characters / 5) / (time in minutes)
+            words_per_minute = (correct_chars / 5) / (elapsed_time / 60)
+            # Average time per character
+            duration_per_char = elapsed_time / total_chars
+
+            # Limit to realistic maximum values
+            chars_per_minute = min(chars_per_minute, 1000)
+            words_per_minute = min(words_per_minute, 200)
+        else:
+            chars_per_minute = 0
+            words_per_minute = 0
+            duration_per_char = 0
+
+        # Error rate and accuracy
+        error_rate = (incorrect_chars / total_chars * 100) if total_chars > 0 else 0
+        accuracy = (correct_chars / total_chars * 100) if total_chars > 0 else 0
+
+        return {
+            'correct_chars': correct_chars,
+            'incorrect_chars': incorrect_chars,
+            'total_chars': total_chars,
+            'error_rate': round(error_rate, 1),
+            'typing_speed': round(chars_per_minute),
+            'duration_per_char': round(duration_per_char, 3),
+            'words_per_minute': round(words_per_minute, 2),
+            'accuracy': round(accuracy, 2)
+        }
+
+    @staticmethod
+    def save_lesson_statistics(
+        lesson_index: int,
+        chars_per_minute: float,
+        error_rate: float,
+        wpm: float,
+        training_duration: float
+    ) -> LessonStatistic:
+        """
+        Save statistics for a completed lesson
+
+        Args:
+            lesson_index: Lesson index
+            chars_per_minute: Characters per minute
+            error_rate: Error rate percentage
+            wpm: Words per minute
+            training_duration: Training duration in seconds
+
+        Returns:
+            Created LessonStatistic instance
+        """
+        lesson_stat = LessonStatistic(
+            lesson_index=lesson_index,
+            chars_per_minute=chars_per_minute,
+            error_rate=error_rate,
+            wpm=wpm,
+            training_duration=training_duration
+        )
+        db.session.add(lesson_stat)
+        db.session.commit()
+        logger.info(f"Statistik für Lektion {lesson_index} gespeichert")
+        return lesson_stat
+
+    @staticmethod
+    def get_lesson_statistics(lesson_index: int) -> List[LessonStatistic]:
+        """
+        Get all statistics for a specific lesson
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            List of LessonStatistic instances
+        """
+        return LessonStatistic.query.filter_by(lesson_index=lesson_index)\
+            .order_by(LessonStatistic.created_at.asc())\
+            .all()
+
+    @staticmethod
+    def get_lesson_statistics_data(lesson_index: int) -> Dict[str, List]:
+        """
+        Get lesson statistics as formatted data for charts
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            Dictionary with statistics data arrays
+        """
+        stats = StatisticsService.get_lesson_statistics(lesson_index)
+        return {
+            'dates': [stat.created_at.strftime('%Y-%m-%d') for stat in stats],
+            'chars_per_minute': [stat.chars_per_minute for stat in stats],
+            'error_rate': [stat.error_rate for stat in stats],
+            'wpm': [stat.wpm for stat in stats],
+            'training_duration': [stat.training_duration for stat in stats]
+        }
+
+    @staticmethod
+    def has_lesson_statistics(lesson_index: int) -> bool:
+        """
+        Check if lesson has any statistics
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            True if lesson has statistics
+        """
+        return LessonStatistic.query.filter_by(lesson_index=lesson_index).first() is not None
+
+    @staticmethod
+    def delete_lesson_statistics(lesson_index: int) -> int:
+        """
+        Delete all statistics for a lesson
+
+        Args:
+            lesson_index: Lesson index
+
+        Returns:
+            Number of deleted entries
+        """
+        deleted_count = LessonStatistic.query.filter_by(lesson_index=lesson_index).delete()
+        db.session.commit()
+        logger.info(f"{deleted_count} Statistik-Einträge für Lektion {lesson_index} gelöscht")
+        return deleted_count
+
+    @staticmethod
+    def get_all_statistics() -> List[LessonStatistic]:
+        """
+        Get all statistics ordered by lesson and creation date
+
+        Returns:
+            List of all LessonStatistic instances
+        """
+        return LessonStatistic.query.order_by(
+            LessonStatistic.lesson_index.asc(),
+            LessonStatistic.created_at.asc()
+        ).all()
+
+    @staticmethod
+    def update_daily_practice(minutes: float) -> None:
+        """
+        Update daily practice time
+
+        Args:
+            minutes: Minutes practiced
+        """
+        today = date.today()
+        practice = DailyPractice.query.filter_by(date=today).first()
+
+        if practice:
+            practice.minutes_practiced += minutes
+        else:
+            practice = DailyPractice(date=today, minutes_practiced=minutes)
+            db.session.add(practice)
+
+        db.session.commit()
+        logger.info(f"Tägliche Übungszeit aktualisiert: {minutes:.2f} Minuten")
+
+    @staticmethod
+    def get_last_30_days_practice() -> List[Dict[str, Any]]:
+        """
+        Get practice times for last 30 days
+
+        Returns:
+            List of practice data dictionaries
+        """
+        thirty_days_ago = date.today() - timedelta(days=29)
+        practices = DailyPractice.query.filter(
+            DailyPractice.date >= thirty_days_ago
+        ).order_by(DailyPractice.date.asc()).all()
+        return [
+            {'date': p.date.strftime('%Y-%m-%d'), 'minutes': p.minutes_practiced}
+            for p in practices
+        ]
+
+    @staticmethod
+    def get_full_30_days_practice() -> List[Dict[str, Any]]:
+        """
+        Get complete 30 days of practice data (including days without practice)
+
+        Returns:
+            List with all 30 days including zeros
+        """
+        practice_data = StatisticsService.get_last_30_days_practice()
+        today = date.today()
+        full_data = []
+
+        for i in range(29, -1, -1):  # From 29 days ago to today
+            current_date = today - timedelta(days=i)
+            date_str = current_date.strftime('%Y-%m-%d')
+
+            # Find data for this day
+            matching = next((p for p in practice_data if p['date'] == date_str), None)
+
+            full_data.append({
+                'date': date_str,
+                'display_date': current_date.strftime('%d.%m'),
+                'minutes': matching['minutes'] if matching else 0
+            })
+
+        return full_data

services/training_service.py

@@ -0,0 +1,258 @@
+"""
+Training Service
+Orchestrates training-related business logic using other services
+"""
+
+import logging
+from typing import Dict, Any, Tuple
+from flask import session
+from services.lesson_service import LessonService
+from services.progress_service import ProgressService
+from services.statistics_service import StatisticsService
+from services.settings_service import SettingsService
+
+logger = logging.getLogger(__name__)
+
+
+class TrainingService:
+    """High-level service for training operations"""
+
+    def __init__(self, lesson_service: LessonService):
+        """
+        Initialize TrainingService
+
+        Args:
+            lesson_service: LessonService instance
+        """
+        self.lesson_service = lesson_service
+        self.progress_service = ProgressService()
+        self.statistics_service = StatisticsService()
+        self.settings_service = SettingsService()
+
+    def get_training_context(self) -> Dict[str, Any]:
+        """
+        Get complete training context for rendering training page
+
+        Returns:
+            Dictionary with all training data
+        """
+        # Get global progress
+        progress = self.progress_service.get_or_create_global_progress()
+        current_lesson_index = progress.current_text_index
+
+        # Get user settings
+        user_settings_dict = self.settings_service.get_settings_dict()
+
+        # Restore saved lesson if initial
+        if current_lesson_index == 0 and user_settings_dict['current_lesson_index'] > 0:
+            current_lesson_index = user_settings_dict['current_lesson_index']
+            progress.current_text_index = current_lesson_index
+            from models import db
+            db.session.commit()
+
+        # Validate lesson index
+        if not self.lesson_service.validate_lesson_index(current_lesson_index):
+            current_lesson_index = 0
+            progress.current_text_index = 0
+            from models import db
+            db.session.commit()
+
+        # Get lesson info
+        lesson_info = self.lesson_service.get_lesson_info(current_lesson_index)
+
+        # Get lesson progress
+        progress_data = self.progress_service.get_lesson_progress_data(current_lesson_index)
+
+        # Synchronize session with DB
+        session['total_elapsed_time'] = progress_data['total_elapsed_time']
+        session['net_training_time'] = progress_data['total_elapsed_time']
+        session['key_stroke_count'] = progress_data['key_stroke_count']
+        session['is_paused'] = progress_data['is_paused']
+
+        return {
+            'current_text': lesson_info['text'],
+            'current_position': progress_data['current_position'],
+            'last_text': progress_data['last_text'],
+            'total_elapsed_time': progress_data['total_elapsed_time'],
+            'net_training_time': progress_data['total_elapsed_time'],
+            'key_stroke_count': progress_data['key_stroke_count'],
+            'is_paused': progress_data['is_paused'],
+            'lessons': self.lesson_service.get_all_lessons(),
+            'current_lesson_title': lesson_info['title'],
+            'current_lesson_task': lesson_info['task'],
+            'current_lesson_index': current_lesson_index,
+            'metronome_enabled': user_settings_dict['metronome_enabled'],
+            'metronome_bpm': user_settings_dict['metronome_bpm'],
+            'metronome_sound': user_settings_dict['metronome_sound'],
+            'metronome_mode': user_settings_dict['metronome_mode'],
+            'metronome_speed': user_settings_dict['metronome_speed'],
+            'target_error_rate': user_settings_dict['target_error_rate'],
+            'max_bpm_speed': user_settings_dict['max_bpm_speed'],
+            'speed_display': user_settings_dict['speed_display']
+        }
+
+    def update_training_progress(
+        self,
+        user_input: str,
+        current_text: str,
+        elapsed_time: float,
+        cursor_position: int,
+        total_elapsed_time: float,
+        net_training_time: float,
+        key_stroke_count: int,
+        is_paused: bool
+    ) -> Dict[str, Any]:
+        """
+        Update training progress and calculate statistics
+
+        Args:
+            user_input: User's typed text
+            current_text: Target text
+            elapsed_time: Time elapsed in seconds
+            cursor_position: Current cursor position
+            total_elapsed_time: Total elapsed time in milliseconds
+            net_training_time: Net training time in milliseconds
+            key_stroke_count: Number of keystrokes
+            is_paused: Whether session is paused
+
+        Returns:
+            Dictionary with statistics and completion status
+        """
+        # Get current lesson
+        lesson_index = self.progress_service.get_current_lesson_index()
+
+        # Update lesson progress
+        self.progress_service.update_lesson_progress(
+            lesson_index=lesson_index,
+            cursor_position=cursor_position,
+            user_input=user_input,
+            total_elapsed_time=int(total_elapsed_time),
+            key_stroke_count=key_stroke_count,
+            is_paused=is_paused
+        )
+
+        # Check if lesson is completed
+        lesson_completed = self.progress_service.check_lesson_completed(
+            cursor_position=cursor_position,
+            user_input_length=len(user_input),
+            lesson_text_length=len(current_text)
+        )
+
+        if lesson_completed:
+            logger.info(f"Lektion {lesson_index} abgeschlossen!")
+
+            # Calculate final statistics
+            stats = self.statistics_service.calculate_typing_statistics(
+                user_input, current_text, elapsed_time
+            )
+
+            # Save statistics
+            self.statistics_service.save_lesson_statistics(
+                lesson_index=lesson_index,
+                chars_per_minute=stats['typing_speed'],
+                error_rate=stats['error_rate'],
+                wpm=stats['words_per_minute'],
+                training_duration=total_elapsed_time / 1000.0
+            )
+
+            # Reset lesson progress
+            self.progress_service.complete_lesson(lesson_index)
+
+        # Update session
+        session['total_elapsed_time'] = total_elapsed_time
+        session['net_training_time'] = net_training_time
+        session['key_stroke_count'] = key_stroke_count
+        session['is_paused'] = is_paused
+
+        # Calculate statistics
+        stats = self.statistics_service.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+        stats['lesson_completed'] = lesson_completed
+
+        return stats
+
+    def switch_to_next_lesson(self) -> Dict[str, Any]:
+        """
+        Switch to next lesson
+
+        Returns:
+            Dictionary with new lesson data
+        """
+        current_index = self.progress_service.get_current_lesson_index()
+        new_index = self.lesson_service.get_next_lesson_index(current_index)
+
+        return self._switch_lesson(new_index, current_index)
+
+    def switch_to_lesson(self, lesson_index: int) -> Tuple[bool, Dict[str, Any]]:
+        """
+        Switch to specific lesson
+
+        Args:
+            lesson_index: Target lesson index
+
+        Returns:
+            Tuple of (success, data dictionary)
+        """
+        if not self.lesson_service.validate_lesson_index(lesson_index):
+            return False, {'error': 'Ungültiger Lektionsindex'}
+
+        current_index = self.progress_service.get_current_lesson_index()
+        return True, self._switch_lesson(lesson_index, current_index)
+
+    def _switch_lesson(self, new_index: int, old_index: int) -> Dict[str, Any]:
+        """
+        Internal method to switch lessons
+
+        Args:
+            new_index: New lesson index
+            old_index: Old lesson index
+
+        Returns:
+            Dictionary with new lesson data
+        """
+        # Update global progress
+        self.progress_service.set_current_lesson_index(new_index)
+
+        # Get new lesson progress
+        progress_data = self.progress_service.get_lesson_progress_data(new_index)
+
+        # Synchronize session
+        session['total_elapsed_time'] = progress_data['total_elapsed_time']
+        session['net_training_time'] = progress_data['total_elapsed_time']
+        session['key_stroke_count'] = progress_data['key_stroke_count']
+        session['is_paused'] = progress_data['is_paused']
+
+        # Get lesson info
+        lesson_info = self.lesson_service.get_lesson_info(new_index)
+
+        logger.info(f"Lektionswechsel: {old_index} -> {new_index}")
+
+        return {
+            'text': lesson_info['text'],
+            'index': new_index,
+            'total': lesson_info['total'],
+            'title': lesson_info['title'],
+            'task': lesson_info['task'],
+            'current_position': progress_data['current_position'],
+            'last_text': progress_data['last_text'],
+            'total_elapsed_time': progress_data['total_elapsed_time'],
+            'key_stroke_count': progress_data['key_stroke_count'],
+            'is_paused': progress_data['is_paused']
+        }
+
+    def reset_current_lesson(self) -> Tuple[bool, Dict[str, Any]]:
+        """
+        Reset current lesson progress
+
+        Returns:
+            Tuple of (success, data dictionary)
+        """
+        lesson_index = self.progress_service.get_current_lesson_index()
+        self.progress_service.reset_lesson_progress(lesson_index)
+
+        return True, {
+            'status': 'success',
+            'message': 'Lektion zurückgesetzt',
+            'lesson_index': lesson_index
+        }

static/js/main.js

@@ -565,6 +565,7 @@ class TypewriterApp {
             this.textDisplayManager.resetScroll();
 
             this.uiManager.updateLessonTitle(data.title);
+            this.uiManager.updateLessonTask(data.task);
             this.uiManager.updateLessonHighlight(data.index);
             this.uiManager.showPlay();
 
@@ -601,6 +602,7 @@ class TypewriterApp {
             this.textDisplayManager.resetScroll();
 
             this.uiManager.updateLessonTitle(data.title);
+            this.uiManager.updateLessonTask(data.task);
             this.uiManager.updateLessonHighlight(lessonIndex);
             this.uiManager.showPlay();
 

static/js/ui.js

@@ -143,6 +143,23 @@ export class UIManager {
         }
     }
 
+    /**
+     * Update lesson task in UI
+     * @param {string} task - Lesson task
+     */
+    updateLessonTask(task) {
+        const taskElement = document.getElementById('lesson-task');
+        if (taskElement) {
+            if (task && task !== 'dummy') {
+                taskElement.textContent = task;
+                taskElement.style.display = 'block';
+            } else {
+                taskElement.textContent = '';
+                taskElement.style.display = 'none';
+            }
+        }
+    }
+
     /**
      * Update lesson highlight in sidebar
      * @param {number} lessonIndex - Index of current lesson

templates/hilfe.html

@@ -131,7 +131,7 @@
     </div>
 
     <!-- Zurück-Button -->
-    <a href="{{ url_for('train') }}" class="btn btn-primary btn-lg back-button shadow">
+    <a href="{{ url_for('training.train') }}" class="btn btn-primary btn-lg back-button shadow">
         ← Zurück zum Trainer
     </a>
 

templates/index.html

@@ -55,7 +55,7 @@
                                     <i data-lucide="pause" id="play-pause-pause" style="width: 24px; height: 24px; position: absolute; top: 0; left: 0;"></i>
                                     <i data-lucide="play" id="play-pause-play" style="width: 24px; height: 24px; position: absolute; top: 0; left: 0; display: none;"></i>
                                 </div>
-                                <a href="{{ url_for('hilfe') }}"
+                                <a href="{{ url_for('main.hilfe') }}"
                                    style="width: 24px; height: 24px; cursor: pointer; color: white; text-decoration: none; display: inline-block;"
                                    aria-label="Hilfe öffnen"
                                    title="Hilfe öffnen">
@@ -93,6 +93,11 @@
                                  tabindex="0">
                                 <!-- Text wird durch JavaScript eingefügt -->
                             </div>
+                            <div id="lesson-task" class="mt-2" style="font-size: 0.85em; color: var(--bs-secondary);">
+                                {%- if current_lesson_task and current_lesson_task != 'dummy' -%}
+                                {{- current_lesson_task -}}
+                                {%- endif -%}
+                            </div>
                         </div>
                         <script>
                             window.fullText = {{ current_text|tojson }};

tests/README.md

@@ -0,0 +1,258 @@
+# Unit Tests für Typewriter Trainer Services
+
+Dieses Verzeichnis enthält Unit Tests für die Service-Layer der Typewriter Trainer Anwendung.
+
+## Test-Übersicht
+
+### Unit Tests (ohne Datenbankzugriff)
+
+| Service | Test-Datei | Anzahl Tests | Status |
+|---------|-----------|--------------|--------|
+| **LessonService** | `test_lesson_service.py` | 17 | ✅ Alle bestanden |
+| **StatisticsService** | `test_statistics_service.py` | 15 | ✅ Alle bestanden |
+| **SettingsService** | `test_settings_service.py` | 22 | ✅ Alle bestanden |
+
+**Gesamt Unit Tests:** 54 Tests, alle bestanden ✅
+
+### Integration Tests (mit Datenbank)
+
+| Service | Test-Datei | Anzahl Tests | Status |
+|---------|-----------|--------------|--------|
+| **ProgressService** | `test_integration_progress.py` | 12 | ✅ Alle bestanden |
+| **StatisticsService** | `test_integration_statistics.py` | 14 | ✅ Alle bestanden |
+
+**Gesamt Integration Tests:** 26 Tests, alle bestanden ✅
+
+### Gesamtübersicht
+
+**Gesamt:** 80 Tests (54 Unit + 26 Integration), **alle bestanden** ✅
+
+### Hinweise
+
+- **ProgressService Tests** (`test_progress_service.py.skip`): Diese Tests wurden übersprungen, da das Mocking von SQLAlchemy-Modellen zu komplex ist und einen vollständigen Flask-App-Context erfordern würde. Diese Funktionalität wird durch Integration-Tests abgedeckt.
+
+- **TrainingService Tests**: Nicht implementiert, da TrainingService ein Orchestrations-Service ist, der hauptsächlich andere Services kombiniert. Diese Funktionalität wird besser durch Integration-Tests abgedeckt.
+
+## Test-Strategie
+
+### Was wird getestet?
+
+#### LessonService (17 Tests)
+- Lektions-Validierung und Navigation
+- Index-Wrapping (Ende → Anfang)
+- Abrufen von Lektionsinformationen
+- Fehlerbehandlung bei ungültigen Indizes
+- Edge Cases (leere Lektionen, Grenzen)
+
+#### StatisticsService Unit Tests (15 Tests)
+- Tippstatistik-Berechnungen (ZPM, WPM)
+- Fehlerraten-Berechnung
+- Genauigkeitsberechnung
+- Geschwindigkeitsbegrenzungen (max 1000 ZPM, 200 WPM)
+- Zeit-basierte Validierung (min. 1 Sekunde)
+- Edge Cases (leere Eingabe, zu schnelle Eingabe)
+- Rundung und Formatierung
+
+#### ProgressService Integration Tests (12 Tests)
+- get_or_create_global_progress (creates new/returns existing)
+- get/set_current_lesson_index
+- get_or_create_lesson_progress (creates new/returns existing)
+- update_lesson_progress
+- reset_lesson_progress
+- get_lesson_progress_data (with data/creates if missing)
+- complete_lesson
+- multiple_lessons_independent
+
+#### StatisticsService Integration Tests (14 Tests)
+- save_lesson_statistics
+- has_lesson_statistics (true/false)
+- get_lesson_statistics_data (with data/empty)
+- delete_lesson_statistics (single/preserve others)
+- get_all_statistics
+- update_daily_practice (creates new/accumulates)
+- get_full_30_days_practice (with gaps filled/all zeros)
+- daily_practice_separate_days
+- end_to_end_statistic_save
+
+#### SettingsService (22 Tests)
+- Validierung aller Einstellungsparameter:
+  - Metronom-Modus (automatic/explicit)
+  - Metronom-Geschwindigkeit (20-300 BPM)
+  - Fehlerrate (0-100%)
+  - Max BPM (40-200)
+  - Display-Modus (zpm/wpm)
+  - Metronom-Sound (beep/click/woodblock)
+- Grenzwerte und Boundary-Tests
+- Ungültige Werte
+- Type-Safety
+
+### Test-Framework
+
+- **Framework:** Python `unittest` (eingebaut, keine zusätzlichen Dependencies)
+- **Mocking:** `unittest.mock` für komplexe Dependencies
+- **Fokus:** Unit Tests für Business-Logik ohne Datenbankzugriff
+
+### Warum unittest statt pytest?
+
+- Bereits im Projekt verwendet (siehe `test_app.py`)
+- Keine zusätzlichen Dependencies
+- Standard Python-Tool
+- Ausreichend für Service-Layer Unit Tests
+
+## Tests ausführen
+
+### Alle Tests ausführen
+
+```bash
+# Alle Unit Tests
+python -m unittest discover -s tests -p "test_*.py" -v
+
+# Alle Integration Tests
+python -m unittest discover -s tests -p "test_integration_*.py" -v
+
+# NUR Unit Tests (ohne Integration)
+python -m unittest tests.test_lesson_service tests.test_statistics_service tests.test_settings_service -v
+```
+
+### Unit Tests (einzeln)
+
+```bash
+# LessonService Tests
+python -m unittest tests.test_lesson_service -v
+
+# StatisticsService Tests
+python -m unittest tests.test_statistics_service -v
+
+# SettingsService Tests
+python -m unittest tests.test_settings_service -v
+```
+
+### Integration Tests (einzeln)
+
+```bash
+# ProgressService Integration Tests
+python -m unittest tests.test_integration_progress -v
+
+# StatisticsService Integration Tests
+python -m unittest tests.test_integration_statistics -v
+```
+
+### Einzelne Test-Klassen
+
+```bash
+python -m unittest tests.test_lesson_service.TestLessonService -v
+```
+
+### Einzelne Tests
+
+```bash
+python -m unittest tests.test_lesson_service.TestLessonService.test_validate_lesson_index_valid -v
+```
+
+## Test-Coverage
+
+Die Tests decken die wichtigsten Business-Logic-Methoden ab:
+
+- ✅ **Validierungslogik:** Alle Validierungsmethoden getestet
+- ✅ **Berechnungslogik:** Alle Statistik-Berechnungen getestet
+- ✅ **Navigation:** Lektionswechsel und Index-Verwaltung
+- ✅ **Edge Cases:** Grenzwerte, ungültige Eingaben, leere Daten
+- ⚠️ **Datenbankoperationen:** Nicht durch Unit Tests abgedeckt (erfordert Integration Tests)
+
+## Best Practices
+
+### Was macht einen guten Unit Test aus?
+
+1. **Isoliert:** Jeder Test testet genau eine Funktionalität
+2. **Schnell:** Alle 54 Tests laufen in < 1 Sekunde
+3. **Deterministisch:** Tests geben immer das gleiche Ergebnis
+4. **Lesbar:** Aussagekräftige Test-Namen und Docstrings
+5. **Unabhängig:** Tests können in beliebiger Reihenfolge ausgeführt werden
+
+### Test-Namenskonvention
+
+```python
+def test_<was_wird_getestet>_<erwartetes_verhalten>(self):
+    """Test: Beschreibung in Deutsch"""
+```
+
+Beispiele:
+- `test_validate_lesson_index_valid` - Testet Validierung mit gültigem Index
+- `test_calculate_typing_statistics_perfect_input` - Testet Berechnung mit perfekter Eingabe
+- `test_validate_metronome_speed_too_high` - Testet Validierung mit zu hoher Geschwindigkeit
+
+## Erweiterung der Tests
+
+### Neue Tests hinzufügen
+
+1. Erstelle eine neue Test-Datei: `tests/test_<service_name>.py`
+2. Importiere unittest und den zu testenden Service
+3. Erstelle eine Test-Klasse die von `unittest.TestCase` erbt
+4. Schreibe Test-Methoden mit dem Präfix `test_`
+5. Führe Tests aus mit `python -m unittest tests.test_<service_name> -v`
+
+### Beispiel
+
+```python
+import unittest
+from services.my_service import MyService
+
+class TestMyService(unittest.TestCase):
+    """Tests für MyService"""
+
+    def setUp(self):
+        """Wird vor jedem Test ausgeführt"""
+        self.service = MyService()
+
+    def test_my_method_valid_input(self):
+        """Test: my_method mit gültiger Eingabe"""
+        result = self.service.my_method("valid")
+        self.assertEqual(result, "expected")
+
+    def test_my_method_invalid_input(self):
+        """Test: my_method mit ungültiger Eingabe"""
+        result = self.service.my_method("invalid")
+        self.assertIsNone(result)
+
+if __name__ == '__main__':
+    unittest.main()
+```
+
+## Integration Tests
+
+Für vollständige Integration Tests (mit Datenbank, Flask-Context, etc.) siehe `test_app.py` im Hauptverzeichnis.
+
+## Continuous Integration
+
+Diese Tests können einfach in CI/CD-Pipelines integriert werden:
+
+```bash
+# In GitHub Actions / GitLab CI
+python -m unittest discover tests -v
+```
+
+Bei Fehlschlag gibt der Command einen Exit-Code ≠ 0 zurück.
+
+## Troubleshooting
+
+### Problem: `ImportError: No module named 'services'`
+
+**Lösung:** Tests müssen aus dem Projekt-Root ausgeführt werden:
+```bash
+cd /home/dschlueter/typewriter
+python -m unittest discover tests -v
+```
+
+### Problem: SQLAlchemy-Fehler
+
+**Lösung:** Services mit Datenbankzugriff erfordern Flask-App-Context. Siehe `test_app.py` für Beispiele mit `app.app_context()`.
+
+### Problem: Tests schlagen intermittierend fehl
+
+**Lösung:** Stelle sicher, dass Tests unabhängig sind und keine shared state verwenden. Nutze `setUp()` und `tearDown()` für Test-Isolation.
+
+## Weitere Informationen
+
+- [Python unittest Dokumentation](https://docs.python.org/3/library/unittest.html)
+- [Flask Testing Dokumentation](https://flask.palletsprojects.com/en/latest/testing/)
+- [SQLAlchemy Testing](https://docs.sqlalchemy.org/en/latest/orm/session_transaction.html)

tests/test_integration_progress.py

@@ -0,0 +1,259 @@
+"""
+Integration Tests für ProgressService mit Datenbank
+"""
+import unittest
+import os
+os.environ['FLASK_TESTING'] = 'true'  # Set before importing app
+
+from app import app, db
+from models import Progress, LessonProgress
+from services.progress_service import ProgressService
+
+
+class TestProgressServiceIntegration(unittest.TestCase):
+    """Integration Tests für ProgressService mit echter Datenbank"""
+
+    def setUp(self):
+        """Setup: Test-App und In-Memory-Datenbank"""
+        app.config['TESTING'] = True
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
+        app.config['WTF_CSRF_ENABLED'] = False
+        self.app = app
+        self.app_context = self.app.app_context()
+        self.app_context.push()
+        db.create_all()
+
+    def tearDown(self):
+        """Cleanup: Datenbank löschen"""
+        db.session.remove()
+        db.drop_all()
+        self.app_context.pop()
+
+    # ========================
+    # Global Progress Tests
+    # ========================
+
+    def test_get_or_create_global_progress_creates_new(self):
+        """Test: Erstellt neuen GlobalProgress wenn keiner existiert"""
+        # Sicherstellen, dass DB leer ist
+        self.assertIsNone(Progress.query.first())
+
+        progress = ProgressService.get_or_create_global_progress()
+
+        # Sollte neuen Eintrag erstellt haben
+        self.assertIsNotNone(progress)
+        self.assertEqual(progress.current_text_index, 0)
+        self.assertEqual(progress.current_position, 0)
+        self.assertEqual(Progress.query.count(), 1)
+
+    def test_get_or_create_global_progress_returns_existing(self):
+        """Test: Gibt existierenden GlobalProgress zurück"""
+        # Erstelle existierenden Eintrag
+        existing = Progress(current_text_index=5, current_position=100)
+        db.session.add(existing)
+        db.session.commit()
+
+        progress = ProgressService.get_or_create_global_progress()
+
+        # Sollte existierenden Eintrag zurückgeben
+        self.assertEqual(progress.id, existing.id)
+        self.assertEqual(progress.current_text_index, 5)
+        self.assertEqual(Progress.query.count(), 1)  # Kein neuer Eintrag
+
+    def test_get_current_lesson_index(self):
+        """Test: Liest aktuellen Lektionsindex"""
+        # Erstelle Progress mit Lektion 3
+        progress = Progress(current_text_index=3)
+        db.session.add(progress)
+        db.session.commit()
+
+        index = ProgressService.get_current_lesson_index()
+
+        self.assertEqual(index, 3)
+
+    def test_set_current_lesson_index(self):
+        """Test: Setzt aktuellen Lektionsindex"""
+        # Erstelle initialen Progress
+        ProgressService.get_or_create_global_progress()
+
+        ProgressService.set_current_lesson_index(7)
+
+        # Verifiziere Änderung
+        progress = Progress.query.first()
+        self.assertEqual(progress.current_text_index, 7)
+
+    # ========================
+    # Lesson Progress Tests
+    # ========================
+
+    def test_get_or_create_lesson_progress_creates_new(self):
+        """Test: Erstellt neuen LessonProgress"""
+        self.assertIsNone(LessonProgress.query.first())
+
+        lesson_progress = ProgressService.get_or_create_lesson_progress(5)
+
+        self.assertIsNotNone(lesson_progress)
+        self.assertEqual(lesson_progress.lesson_index, 5)
+        self.assertEqual(lesson_progress.current_position, 0)
+        self.assertEqual(lesson_progress.last_text, "")
+        self.assertTrue(lesson_progress.is_paused)
+        self.assertEqual(LessonProgress.query.count(), 1)
+
+    def test_get_or_create_lesson_progress_returns_existing(self):
+        """Test: Gibt existierenden LessonProgress zurück"""
+        # Erstelle existierenden Eintrag
+        existing = LessonProgress(
+            lesson_index=2,
+            current_position=50,
+            last_text="test input"
+        )
+        db.session.add(existing)
+        db.session.commit()
+
+        lesson_progress = ProgressService.get_or_create_lesson_progress(2)
+
+        self.assertEqual(lesson_progress.id, existing.id)
+        self.assertEqual(lesson_progress.current_position, 50)
+        self.assertEqual(lesson_progress.last_text, "test input")
+        self.assertEqual(LessonProgress.query.count(), 1)
+
+    def test_update_lesson_progress(self):
+        """Test: Aktualisiert LessonProgress"""
+        # Erstelle initialen Progress
+        ProgressService.get_or_create_lesson_progress(3)
+
+        ProgressService.update_lesson_progress(
+            lesson_index=3,
+            cursor_position=100,
+            user_input="hello world",
+            total_elapsed_time=5000,  # 5 Sekunden in ms
+            key_stroke_count=25,
+            is_paused=False
+        )
+
+        # Verifiziere Änderungen
+        lesson_progress = LessonProgress.query.filter_by(lesson_index=3).first()
+        self.assertEqual(lesson_progress.current_position, 100)
+        self.assertEqual(lesson_progress.last_text, "hello world")
+        self.assertEqual(lesson_progress.total_elapsed_time, 5000)
+        self.assertEqual(lesson_progress.key_stroke_count, 25)
+        self.assertFalse(lesson_progress.is_paused)
+
+    def test_reset_lesson_progress(self):
+        """Test: Setzt LessonProgress zurück"""
+        # Erstelle Progress mit Daten
+        lesson_progress = LessonProgress(
+            lesson_index=4,
+            current_position=200,
+            last_text="some text",
+            total_elapsed_time=10000,
+            key_stroke_count=50,
+            is_paused=False
+        )
+        db.session.add(lesson_progress)
+        db.session.commit()
+
+        ProgressService.reset_lesson_progress(4)
+
+        # Verifiziere Reset
+        lesson_progress = LessonProgress.query.filter_by(lesson_index=4).first()
+        self.assertEqual(lesson_progress.current_position, 0)
+        self.assertEqual(lesson_progress.last_text, "")
+        self.assertEqual(lesson_progress.total_elapsed_time, 0)
+        self.assertEqual(lesson_progress.key_stroke_count, 0)
+        self.assertTrue(lesson_progress.is_paused)
+
+    def test_get_lesson_progress_data(self):
+        """Test: Holt LessonProgress-Daten als Dict"""
+        # Erstelle Progress
+        lesson_progress = LessonProgress(
+            lesson_index=1,
+            current_position=75,
+            last_text="test",
+            total_elapsed_time=3000,
+            key_stroke_count=15,
+            is_paused=True
+        )
+        db.session.add(lesson_progress)
+        db.session.commit()
+
+        data = ProgressService.get_lesson_progress_data(1)
+
+        self.assertEqual(data['current_position'], 75)
+        self.assertEqual(data['last_text'], "test")
+        self.assertEqual(data['total_elapsed_time'], 3000)
+        self.assertEqual(data['key_stroke_count'], 15)
+        self.assertTrue(data['is_paused'])
+
+    def test_get_lesson_progress_data_creates_if_not_exists(self):
+        """Test: Erstellt neuen LessonProgress wenn nicht vorhanden"""
+        # DB ist leer
+        self.assertIsNone(LessonProgress.query.filter_by(lesson_index=99).first())
+
+        data = ProgressService.get_lesson_progress_data(99)
+
+        # Sollte neuen Eintrag erstellt haben mit Default-Werten
+        self.assertEqual(data['current_position'], 0)
+        self.assertEqual(data['last_text'], "")
+        self.assertEqual(data['total_elapsed_time'], 0)
+        self.assertEqual(data['key_stroke_count'], 0)
+        self.assertTrue(data['is_paused'])
+
+        # Verifiziere DB-Eintrag
+        lesson_progress = LessonProgress.query.filter_by(lesson_index=99).first()
+        self.assertIsNotNone(lesson_progress)
+
+    def test_complete_lesson(self):
+        """Test: Schließt Lektion ab (reset)"""
+        # Erstelle aktiven Progress
+        lesson_progress = LessonProgress(
+            lesson_index=6,
+            current_position=300,
+            last_text="completed text",
+            total_elapsed_time=20000,
+            key_stroke_count=100,
+            is_paused=False
+        )
+        db.session.add(lesson_progress)
+        db.session.commit()
+
+        ProgressService.complete_lesson(6)
+
+        # Sollte zurückgesetzt sein
+        lesson_progress = LessonProgress.query.filter_by(lesson_index=6).first()
+        self.assertEqual(lesson_progress.current_position, 0)
+        self.assertEqual(lesson_progress.last_text, "")
+        self.assertEqual(lesson_progress.total_elapsed_time, 0)
+        self.assertEqual(lesson_progress.key_stroke_count, 0)
+        self.assertTrue(lesson_progress.is_paused)
+
+    def test_multiple_lessons_independent(self):
+        """Test: Mehrere Lektionen sind unabhängig"""
+        # Erstelle Progress für mehrere Lektionen
+        ProgressService.update_lesson_progress(1, 10, "text1", 1000, 5, False)
+        ProgressService.update_lesson_progress(2, 20, "text2", 2000, 10, False)
+        ProgressService.update_lesson_progress(3, 30, "text3", 3000, 15, False)
+
+        # Verifiziere dass alle existieren und unabhängig sind
+        lesson1 = LessonProgress.query.filter_by(lesson_index=1).first()
+        lesson2 = LessonProgress.query.filter_by(lesson_index=2).first()
+        lesson3 = LessonProgress.query.filter_by(lesson_index=3).first()
+
+        self.assertEqual(lesson1.current_position, 10)
+        self.assertEqual(lesson2.current_position, 20)
+        self.assertEqual(lesson3.current_position, 30)
+
+        # Reset einer Lektion sollte andere nicht beeinflussen
+        ProgressService.reset_lesson_progress(2)
+
+        lesson1 = LessonProgress.query.filter_by(lesson_index=1).first()
+        lesson2 = LessonProgress.query.filter_by(lesson_index=2).first()
+        lesson3 = LessonProgress.query.filter_by(lesson_index=3).first()
+
+        self.assertEqual(lesson1.current_position, 10)  # Unverändert
+        self.assertEqual(lesson2.current_position, 0)   # Zurückgesetzt
+        self.assertEqual(lesson3.current_position, 30)  # Unverändert
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_integration_statistics.py

@@ -0,0 +1,302 @@
+"""
+Integration Tests für StatisticsService mit Datenbank
+"""
+import unittest
+import os
+os.environ['FLASK_TESTING'] = 'true'  # Set before importing app
+
+from datetime import datetime, timedelta, date
+from app import app, db
+from models import LessonStatistic, DailyPractice
+from services.statistics_service import StatisticsService
+
+
+class TestStatisticsServiceIntegration(unittest.TestCase):
+    """Integration Tests für StatisticsService mit echter Datenbank"""
+
+    def setUp(self):
+        """Setup: Test-App und In-Memory-Datenbank"""
+        app.config['TESTING'] = True
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
+        app.config['WTF_CSRF_ENABLED'] = False
+        self.app = app
+        self.app_context = self.app.app_context()
+        self.app_context.push()
+        db.create_all()
+
+    def tearDown(self):
+        """Cleanup: Datenbank löschen"""
+        db.session.remove()
+        db.drop_all()
+        self.app_context.pop()
+
+    # ========================
+    # Lesson Statistics Tests
+    # ========================
+
+    def test_save_lesson_statistics(self):
+        """Test: Speichert Lektionsstatistiken"""
+        stat = StatisticsService.save_lesson_statistics(
+            lesson_index=1,
+            chars_per_minute=120.5,
+            error_rate=5.2,
+            wpm=24.1,
+            training_duration=300.0
+        )
+
+        self.assertIsNotNone(stat)
+        self.assertEqual(stat.lesson_index, 1)
+        self.assertEqual(stat.chars_per_minute, 120.5)
+        self.assertEqual(stat.error_rate, 5.2)
+        self.assertEqual(stat.wpm, 24.1)
+        self.assertEqual(stat.training_duration, 300.0)
+
+        # Verifiziere DB-Eintrag
+        db_stat = LessonStatistic.query.first()
+        self.assertIsNotNone(db_stat)
+        self.assertEqual(db_stat.lesson_index, 1)
+
+    def test_has_lesson_statistics_true(self):
+        """Test: Prüft ob Statistiken für Lektion existieren (True)"""
+        # Erstelle Statistik
+        stat = LessonStatistic(
+            lesson_index=2,
+            chars_per_minute=100.0,
+            error_rate=3.0,
+            wpm=20.0,
+            training_duration=200.0
+        )
+        db.session.add(stat)
+        db.session.commit()
+
+        has_stats = StatisticsService.has_lesson_statistics(2)
+
+        self.assertTrue(has_stats)
+
+    def test_has_lesson_statistics_false(self):
+        """Test: Prüft ob Statistiken für Lektion existieren (False)"""
+        # DB ist leer
+        has_stats = StatisticsService.has_lesson_statistics(99)
+
+        self.assertFalse(has_stats)
+
+    def test_get_lesson_statistics_data(self):
+        """Test: Holt Statistiken für eine Lektion"""
+        # Erstelle mehrere Statistiken für eine Lektion
+        for i in range(3):
+            stat = LessonStatistic(
+                lesson_index=3,
+                chars_per_minute=100.0 + i * 10,
+                error_rate=5.0 - i,
+                wpm=20.0 + i * 2,
+                training_duration=180.0
+            )
+            db.session.add(stat)
+        db.session.commit()
+
+        data = StatisticsService.get_lesson_statistics_data(3)
+
+        self.assertEqual(len(data['dates']), 3)
+        self.assertEqual(len(data['chars_per_minute']), 3)
+        self.assertEqual(len(data['error_rate']), 3)
+        self.assertEqual(len(data['wpm']), 3)
+
+        # Älteste zuerst (aufsteigende Reihenfolge nach created_at)
+        self.assertEqual(data['chars_per_minute'][0], 100.0)
+        self.assertEqual(data['chars_per_minute'][-1], 120.0)
+        self.assertEqual(data['error_rate'][0], 5.0)
+        self.assertEqual(data['error_rate'][-1], 3.0)
+
+    def test_get_lesson_statistics_data_empty(self):
+        """Test: Holt Statistiken für Lektion ohne Daten"""
+        data = StatisticsService.get_lesson_statistics_data(99)
+
+        self.assertEqual(len(data['dates']), 0)
+        self.assertEqual(len(data['chars_per_minute']), 0)
+        self.assertEqual(len(data['error_rate']), 0)
+        self.assertEqual(len(data['wpm']), 0)
+
+    def test_delete_lesson_statistics(self):
+        """Test: Löscht alle Statistiken für eine Lektion"""
+        # Erstelle mehrere Statistiken
+        for i in range(5):
+            stat = LessonStatistic(
+                lesson_index=4,
+                chars_per_minute=100.0,
+                error_rate=5.0,
+                wpm=20.0,
+                training_duration=180.0
+            )
+            db.session.add(stat)
+        db.session.commit()
+
+        # Verifiziere dass sie existieren
+        self.assertEqual(LessonStatistic.query.filter_by(lesson_index=4).count(), 5)
+
+        deleted_count = StatisticsService.delete_lesson_statistics(4)
+
+        self.assertEqual(deleted_count, 5)
+        self.assertEqual(LessonStatistic.query.filter_by(lesson_index=4).count(), 0)
+
+    def test_delete_lesson_statistics_preserves_others(self):
+        """Test: Löschen einer Lektion lässt andere Lektionen intakt"""
+        # Erstelle Statistiken für mehrere Lektionen
+        for lesson in [1, 2, 3]:
+            for i in range(2):
+                stat = LessonStatistic(
+                    lesson_index=lesson,
+                    chars_per_minute=100.0,
+                    error_rate=5.0,
+                    wpm=20.0,
+                    training_duration=180.0
+                )
+                db.session.add(stat)
+        db.session.commit()
+
+        # Lösche nur Lektion 2
+        StatisticsService.delete_lesson_statistics(2)
+
+        # Lektion 1 und 3 sollten noch existieren
+        self.assertEqual(LessonStatistic.query.filter_by(lesson_index=1).count(), 2)
+        self.assertEqual(LessonStatistic.query.filter_by(lesson_index=2).count(), 0)
+        self.assertEqual(LessonStatistic.query.filter_by(lesson_index=3).count(), 2)
+
+    def test_get_all_statistics(self):
+        """Test: Holt alle Statistiken"""
+        # Erstelle Statistiken für verschiedene Lektionen
+        for lesson in range(3):
+            stat = LessonStatistic(
+                lesson_index=lesson,
+                chars_per_minute=100.0 + lesson * 10,
+                error_rate=5.0,
+                wpm=20.0,
+                training_duration=180.0
+            )
+            db.session.add(stat)
+        db.session.commit()
+
+        all_stats = StatisticsService.get_all_statistics()
+
+        self.assertEqual(len(all_stats), 3)
+        # Sollte nach created_at DESC sortiert sein
+        self.assertIsInstance(all_stats[0], LessonStatistic)
+
+    # ========================
+    # Daily Practice Tests
+    # ========================
+
+    def test_update_daily_practice_creates_new(self):
+        """Test: Erstellt neuen DailyPractice-Eintrag"""
+        today = date.today()
+
+        StatisticsService.update_daily_practice(15.5)  # 15.5 Minuten
+
+        # Verifiziere DB-Eintrag
+        practice = DailyPractice.query.filter_by(date=today).first()
+        self.assertIsNotNone(practice)
+        self.assertEqual(practice.minutes_practiced, 15.5)
+
+    def test_update_daily_practice_accumulates(self):
+        """Test: Addiert zu existierendem DailyPractice"""
+        today = date.today()
+
+        # Erste Session: 10 Minuten
+        StatisticsService.update_daily_practice(10.0)
+        # Zweite Session: 5 Minuten
+        StatisticsService.update_daily_practice(5.0)
+
+        # Sollte addiert haben
+        practice = DailyPractice.query.filter_by(date=today).first()
+        self.assertEqual(practice.minutes_practiced, 15.0)
+
+    def test_get_full_30_days_practice(self):
+        """Test: Holt 30 Tage Übungsdaten (mit Lücken gefüllt)"""
+        today = date.today()
+
+        # Erstelle Einträge für heute und vor 5 Tagen
+        practice_today = DailyPractice(date=today, minutes_practiced=20.0)
+        practice_5_days_ago = DailyPractice(
+            date=today - timedelta(days=5),
+            minutes_practiced=15.0
+        )
+        db.session.add(practice_today)
+        db.session.add(practice_5_days_ago)
+        db.session.commit()
+
+        full_data = StatisticsService.get_full_30_days_practice()
+
+        # Sollte 30 Einträge haben (mit 0 für Tage ohne Übung)
+        self.assertEqual(len(full_data), 30)
+
+        # Heute sollte 20 Minuten haben
+        self.assertEqual(full_data[-1]['minutes'], 20.0)
+        self.assertEqual(full_data[-1]['date'], today.strftime('%Y-%m-%d'))
+
+        # Vor 5 Tagen sollte 15 Minuten haben
+        self.assertEqual(full_data[-6]['minutes'], 15.0)
+
+        # Andere Tage sollten 0 haben
+        self.assertEqual(full_data[-2]['minutes'], 0.0)  # Gestern
+        self.assertEqual(full_data[-3]['minutes'], 0.0)  # Vorgestern
+
+    def test_get_full_30_days_practice_all_zeros(self):
+        """Test: 30 Tage ohne Übung gibt nur Nullen"""
+        full_data = StatisticsService.get_full_30_days_practice()
+
+        self.assertEqual(len(full_data), 30)
+        # Alle sollten 0 Minuten haben
+        for day in full_data:
+            self.assertEqual(day['minutes'], 0.0)
+
+    def test_daily_practice_separate_days(self):
+        """Test: Verschiedene Tage werden separat gespeichert"""
+        today = date.today()
+        yesterday = today - timedelta(days=1)
+
+        StatisticsService.update_daily_practice(10.0)  # Heute
+
+        # Simuliere gestern durch direkten DB-Eintrag
+        practice_yesterday = DailyPractice(date=yesterday, minutes_practiced=20.0)
+        db.session.add(practice_yesterday)
+        db.session.commit()
+
+        # Verifiziere separate Einträge
+        practice_today = DailyPractice.query.filter_by(date=today).first()
+        practice_yesterday_db = DailyPractice.query.filter_by(date=yesterday).first()
+
+        self.assertEqual(practice_today.minutes_practiced, 10.0)
+        self.assertEqual(practice_yesterday_db.minutes_practiced, 20.0)
+
+    # ========================
+    # Statistics Calculations (Integration)
+    # ========================
+
+    def test_end_to_end_statistic_save(self):
+        """Test: Kompletter Workflow - Berechnen und Speichern"""
+        # Berechne Statistiken
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input="hello world",
+            current_text="hello world",
+            elapsed_time=10.0
+        )
+
+        # Speichere in DB
+        saved_stat = StatisticsService.save_lesson_statistics(
+            lesson_index=5,
+            chars_per_minute=stats['typing_speed'],
+            error_rate=stats['error_rate'],
+            wpm=stats['words_per_minute'],
+            training_duration=10.0
+        )
+
+        # Verifiziere dass gespeicherte Daten abrufbar sind
+        has_stats = StatisticsService.has_lesson_statistics(5)
+        self.assertTrue(has_stats)
+
+        data = StatisticsService.get_lesson_statistics_data(5)
+        self.assertEqual(len(data['dates']), 1)
+        self.assertEqual(data['error_rate'][0], 0.0)  # Perfekte Eingabe
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_lesson_service.py

@@ -0,0 +1,118 @@
+"""
+Unit Tests für LessonService
+"""
+import unittest
+from services.lesson_service import LessonService
+
+
+class TestLessonService(unittest.TestCase):
+    """Tests für die LessonService-Klasse"""
+
+    def setUp(self):
+        """Setup für jeden Test - Erstellt Test-Lektionen"""
+        self.test_lessons = [
+            {"lesson": 1, "title": "Lektion 1", "text": "Test text 1"},
+            {"lesson": 2, "title": "Lektion 2", "text": "Test text 2"},
+            {"lesson": 3, "title": "Lektion 3", "text": "Test text 3"}
+        ]
+        self.service = LessonService(self.test_lessons)
+
+    def test_init(self):
+        """Test: Initialisierung des Service"""
+        self.assertEqual(len(self.service.lessons), 3)
+        self.assertEqual(self.service.lessons[0]["title"], "Lektion 1")
+
+    def test_validate_lesson_index_valid(self):
+        """Test: Validierung eines gültigen Lektionsindex"""
+        self.assertTrue(self.service.validate_lesson_index(0))
+        self.assertTrue(self.service.validate_lesson_index(1))
+        self.assertTrue(self.service.validate_lesson_index(2))
+
+    def test_validate_lesson_index_invalid(self):
+        """Test: Validierung ungültiger Lektionsindizes"""
+        self.assertFalse(self.service.validate_lesson_index(-1))
+        self.assertFalse(self.service.validate_lesson_index(3))
+        self.assertFalse(self.service.validate_lesson_index(100))
+
+    def test_get_next_lesson_index_normal(self):
+        """Test: Nächster Lektionsindex im normalen Fall"""
+        self.assertEqual(self.service.get_next_lesson_index(0), 1)
+        self.assertEqual(self.service.get_next_lesson_index(1), 2)
+
+    def test_get_next_lesson_index_wrap_around(self):
+        """Test: Nächster Lektionsindex bei Wrap-Around (Ende -> Anfang)"""
+        self.assertEqual(self.service.get_next_lesson_index(2), 0)
+
+    def test_get_previous_lesson_index_normal(self):
+        """Test: Vorheriger Lektionsindex im normalen Fall"""
+        self.assertEqual(self.service.get_previous_lesson_index(1), 0)
+        self.assertEqual(self.service.get_previous_lesson_index(2), 1)
+
+    def test_get_previous_lesson_index_wrap_around(self):
+        """Test: Vorheriger Lektionsindex bei Wrap-Around (Anfang -> Ende)"""
+        self.assertEqual(self.service.get_previous_lesson_index(0), 2)
+
+    def test_get_lesson_text_valid(self):
+        """Test: Abrufen des Lektionstexts für gültigen Index"""
+        self.assertEqual(self.service.get_lesson_text(0), "Test text 1")
+        self.assertEqual(self.service.get_lesson_text(1), "Test text 2")
+        self.assertEqual(self.service.get_lesson_text(2), "Test text 3")
+
+    def test_get_lesson_text_invalid(self):
+        """Test: Abrufen des Lektionstexts für ungültigen Index gibt Fallback"""
+        self.assertEqual(self.service.get_lesson_text(-1), "Lektion nicht gefunden")
+        self.assertEqual(self.service.get_lesson_text(3), "Lektion nicht gefunden")
+        self.assertEqual(self.service.get_lesson_text(100), "Lektion nicht gefunden")
+
+    def test_get_lesson_title_valid(self):
+        """Test: Abrufen des Lektionstitels für gültigen Index"""
+        self.assertEqual(self.service.get_lesson_title(0), "Lektion 1")
+        self.assertEqual(self.service.get_lesson_title(1), "Lektion 2")
+        self.assertEqual(self.service.get_lesson_title(2), "Lektion 3")
+
+    def test_get_lesson_title_invalid(self):
+        """Test: Abrufen des Lektionstitels für ungültigen Index gibt Fallback"""
+        self.assertEqual(self.service.get_lesson_title(-1), "Unbekannte Lektion")
+        self.assertEqual(self.service.get_lesson_title(3), "Unbekannte Lektion")
+
+    def test_get_lesson_info_valid(self):
+        """Test: Abrufen vollständiger Lektionsinfo"""
+        info = self.service.get_lesson_info(0)
+        self.assertEqual(info['index'], 0)
+        self.assertEqual(info['text'], "Test text 1")
+        self.assertEqual(info['title'], "Lektion 1")
+        self.assertEqual(info['total'], 3)
+
+    def test_get_lesson_info_invalid(self):
+        """Test: Abrufen vollständiger Lektionsinfo für ungültigen Index"""
+        info = self.service.get_lesson_info(100)
+        self.assertEqual(info['index'], 100)
+        self.assertEqual(info['text'], "Lektion nicht gefunden")
+        self.assertEqual(info['title'], "Unbekannte Lektion")
+        self.assertEqual(info['total'], 3)
+
+    def test_get_lesson_count(self):
+        """Test: Anzahl der Lektionen"""
+        self.assertEqual(self.service.get_lesson_count(), 3)
+
+    def test_get_lesson_count_empty(self):
+        """Test: Anzahl der Lektionen bei leerer Liste"""
+        empty_service = LessonService([])
+        self.assertEqual(empty_service.get_lesson_count(), 0)
+
+    def test_get_all_lessons(self):
+        """Test: Abrufen aller Lektionen"""
+        all_lessons = self.service.get_all_lessons()
+        self.assertEqual(len(all_lessons), 3)
+        self.assertEqual(all_lessons[0]["title"], "Lektion 1")
+        self.assertEqual(all_lessons[2]["title"], "Lektion 3")
+
+    def test_get_all_lessons_returns_list(self):
+        """Test: get_all_lessons gibt eine Liste zurück"""
+        lessons_list = self.service.get_all_lessons()
+        self.assertIsInstance(lessons_list, list)
+        self.assertEqual(len(lessons_list), 3)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_progress_service.py.skip

@@ -0,0 +1,248 @@
+"""
+Unit Tests für ProgressService
+"""
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+from datetime import datetime
+from services.progress_service import ProgressService
+from models import Progress, LessonProgress
+
+
+class TestProgressService(unittest.TestCase):
+    """Tests für die ProgressService-Klasse"""
+
+    def setUp(self):
+        """Setup für jeden Test"""
+        self.service = ProgressService()
+
+    # ========================
+    # Global Progress Tests
+    # ========================
+
+    @patch('services.progress_service.Progress')
+    def test_get_or_create_global_progress_existing(self, mock_progress):
+        """Test: Abrufen eines existierenden Progress"""
+        mock_prog = Mock(spec=Progress)
+        mock_prog.current_text_index = 5
+        mock_progress.query.first.return_value = mock_prog
+
+        result = ProgressService.get_or_create_global_progress()
+
+        self.assertEqual(result, mock_prog)
+        self.assertEqual(result.current_text_index, 5)
+        mock_progress.query.first.assert_called_once()
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.Progress')
+    def test_get_or_create_global_progress_create_new(self, mock_progress, mock_db):
+        """Test: Erstellen eines neuen Progress wenn keiner existiert"""
+        mock_progress.query.first.return_value = None
+        new_progress = Mock(spec=Progress)
+        mock_progress.return_value = new_progress
+
+        result = ProgressService.get_or_create_global_progress()
+
+        self.assertEqual(result, new_progress)
+        mock_db.session.add.assert_called_once_with(new_progress)
+        mock_db.session.commit.assert_called_once()
+
+    @patch('services.progress_service.Progress')
+    def test_get_current_lesson_index(self, mock_progress):
+        """Test: Abrufen des aktuellen Lektionsindex"""
+        mock_prog = Mock(spec=Progress)
+        mock_prog.current_text_index = 3
+        mock_progress.query.first.return_value = mock_prog
+
+        result = ProgressService.get_current_lesson_index()
+
+        self.assertEqual(result, 3)
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.Progress')
+    def test_set_current_lesson_index(self, mock_progress, mock_db):
+        """Test: Setzen des aktuellen Lektionsindex"""
+        mock_prog = Mock(spec=Progress)
+        mock_progress.query.first.return_value = mock_prog
+
+        ProgressService.set_current_lesson_index(7)
+
+        self.assertEqual(mock_prog.current_text_index, 7)
+        mock_db.session.commit.assert_called_once()
+
+    # ========================
+    # Lesson Progress Tests
+    # ========================
+
+    @patch('services.progress_service.LessonProgress')
+    def test_get_or_create_lesson_progress_existing(self, mock_lesson_progress):
+        """Test: Abrufen eines existierenden LessonProgress"""
+        mock_progress = Mock(spec=LessonProgress)
+        mock_progress.current_position = 100
+        mock_progress.last_text = "test input"
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = mock_progress
+
+        result = ProgressService.get_or_create_lesson_progress(2)
+
+        self.assertEqual(result, mock_progress)
+        self.assertEqual(result.current_position, 100)
+        mock_lesson_progress.query.filter_by.assert_called_once_with(lesson_index=2)
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.LessonProgress')
+    def test_get_or_create_lesson_progress_create_new(self, mock_lesson_progress, mock_db):
+        """Test: Erstellen eines neuen LessonProgress"""
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = None
+        new_progress = Mock(spec=LessonProgress)
+        mock_lesson_progress.return_value = new_progress
+
+        result = ProgressService.get_or_create_lesson_progress(5)
+
+        mock_lesson_progress.assert_called_once_with(
+            lesson_index=5,
+            current_position=0,
+            last_text="",
+            total_elapsed_time=0,
+            key_stroke_count=0,
+            is_paused=True
+        )
+        mock_db.session.add.assert_called_once_with(new_progress)
+        mock_db.session.commit.assert_called_once()
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.LessonProgress')
+    def test_update_lesson_progress(self, mock_lesson_progress, mock_db):
+        """Test: Aktualisieren eines LessonProgress"""
+        mock_progress = Mock(spec=LessonProgress)
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = mock_progress
+
+        ProgressService.update_lesson_progress(
+            lesson_index=3,
+            cursor_position=50,
+            user_input="hello world",
+            total_elapsed_time=120500,
+            key_stroke_count=150,
+            is_paused=False
+        )
+
+        self.assertEqual(mock_progress.current_position, 50)
+        self.assertEqual(mock_progress.last_text, "hello world")
+        self.assertEqual(mock_progress.total_elapsed_time, 120500)
+        self.assertEqual(mock_progress.key_stroke_count, 150)
+        self.assertFalse(mock_progress.is_paused)
+        mock_db.session.commit.assert_called_once()
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.LessonProgress')
+    def test_reset_lesson_progress(self, mock_lesson_progress, mock_db):
+        """Test: Zurücksetzen eines LessonProgress"""
+        mock_progress = Mock(spec=LessonProgress)
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = mock_progress
+
+        ProgressService.reset_lesson_progress(4)
+
+        self.assertEqual(mock_progress.current_position, 0)
+        self.assertEqual(mock_progress.last_text, "")
+        self.assertEqual(mock_progress.total_elapsed_time, 0)
+        self.assertEqual(mock_progress.key_stroke_count, 0)
+        self.assertTrue(mock_progress.is_paused)
+        mock_db.session.commit.assert_called_once()
+
+    @patch('services.progress_service.LessonProgress')
+    def test_get_lesson_progress_data(self, mock_lesson_progress):
+        """Test: Abrufen der Lesson Progress Daten"""
+        mock_progress = Mock(spec=LessonProgress)
+        mock_progress.current_position = 75
+        mock_progress.last_text = "test"
+        mock_progress.total_elapsed_time = 60.0
+        mock_progress.key_stroke_count = 80
+        mock_progress.is_paused = False
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = mock_progress
+
+        result = ProgressService.get_lesson_progress_data(1)
+
+        self.assertEqual(result['current_position'], 75)
+        self.assertEqual(result['last_text'], "test")
+        self.assertEqual(result['total_elapsed_time'], 60.0)
+        self.assertEqual(result['key_stroke_count'], 80)
+        self.assertFalse(result['is_paused'])
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.LessonProgress')
+    def test_get_lesson_progress_data_creates_new_if_not_found(self, mock_lesson_progress, mock_db):
+        """Test: get_lesson_progress_data erstellt neuen Eintrag wenn nicht vorhanden"""
+        # First call returns None, second call returns the new progress
+        mock_lesson_progress.query.filter_by.return_value.first.side_effect = [None, Mock(
+            current_position=0,
+            last_text="",
+            total_elapsed_time=0,
+            key_stroke_count=0,
+            is_paused=True
+        )]
+        new_progress = Mock(spec=LessonProgress)
+        mock_lesson_progress.return_value = new_progress
+
+        result = ProgressService.get_lesson_progress_data(99)
+
+        # Should create new entry and return default values
+        self.assertEqual(result['current_position'], 0)
+        self.assertEqual(result['last_text'], "")
+
+    @patch('services.progress_service.db')
+    @patch('services.progress_service.LessonProgress')
+    def test_complete_lesson(self, mock_lesson_progress, mock_db):
+        """Test: Lektion abschließen"""
+        mock_progress = Mock(spec=LessonProgress)
+        mock_lesson_progress.query.filter_by.return_value.first.return_value = mock_progress
+
+        ProgressService.complete_lesson(5)
+
+        # Sollte Progress zurücksetzen
+        self.assertEqual(mock_progress.current_position, 0)
+        self.assertEqual(mock_progress.last_text, "")
+        self.assertEqual(mock_progress.total_elapsed_time, 0)
+        self.assertEqual(mock_progress.key_stroke_count, 0)
+        self.assertTrue(mock_progress.is_paused)
+
+    # ========================
+    # Completion Check Tests
+    # ========================
+
+    def test_check_lesson_completed_true(self):
+        """Test: Lektion ist abgeschlossen"""
+        result = ProgressService.check_lesson_completed(
+            cursor_position=100,
+            user_input_length=100,
+            lesson_text_length=100
+        )
+        self.assertTrue(result)
+
+    def test_check_lesson_completed_cursor_not_at_end(self):
+        """Test: Lektion nicht abgeschlossen - Cursor nicht am Ende"""
+        result = ProgressService.check_lesson_completed(
+            cursor_position=50,
+            user_input_length=100,
+            lesson_text_length=100
+        )
+        self.assertFalse(result)
+
+    def test_check_lesson_completed_input_too_short(self):
+        """Test: Lektion nicht abgeschlossen - Eingabe zu kurz"""
+        result = ProgressService.check_lesson_completed(
+            cursor_position=100,
+            user_input_length=50,
+            lesson_text_length=100
+        )
+        self.assertFalse(result)
+
+    def test_check_lesson_completed_both_incomplete(self):
+        """Test: Lektion nicht abgeschlossen - beides unvollständig"""
+        result = ProgressService.check_lesson_completed(
+            cursor_position=50,
+            user_input_length=50,
+            lesson_text_length=100
+        )
+        self.assertFalse(result)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_settings_service.py

@@ -0,0 +1,214 @@
+"""
+Unit Tests für SettingsService
+"""
+import unittest
+from services.settings_service import SettingsService
+
+
+class TestSettingsServiceValidation(unittest.TestCase):
+    """Tests für Validierungsmethoden (ohne DB-Zugriff)"""
+
+    # ========================
+    # Metronome Mode Validation
+    # ========================
+
+    def test_validate_metronome_mode_automatic(self):
+        """Test: 'automatic' ist gültiger Metronom-Modus"""
+        self.assertTrue(SettingsService.validate_metronome_mode('automatic'))
+
+    def test_validate_metronome_mode_explicit(self):
+        """Test: 'explicit' ist gültiger Metronom-Modus"""
+        self.assertTrue(SettingsService.validate_metronome_mode('explicit'))
+
+    def test_validate_metronome_mode_invalid(self):
+        """Test: Ungültige Metronom-Modi"""
+        self.assertFalse(SettingsService.validate_metronome_mode('manual'))
+        self.assertFalse(SettingsService.validate_metronome_mode('auto'))
+        self.assertFalse(SettingsService.validate_metronome_mode(''))
+        self.assertFalse(SettingsService.validate_metronome_mode('AUTOMATIC'))
+
+    # ========================
+    # Metronome Speed Validation
+    # ========================
+
+    def test_validate_metronome_speed_valid_range(self):
+        """Test: Gültige Metronom-Geschwindigkeiten (20-300)"""
+        self.assertTrue(SettingsService.validate_metronome_speed(20))
+        self.assertTrue(SettingsService.validate_metronome_speed(60))
+        self.assertTrue(SettingsService.validate_metronome_speed(100))
+        self.assertTrue(SettingsService.validate_metronome_speed(150))
+        self.assertTrue(SettingsService.validate_metronome_speed(300))
+
+    def test_validate_metronome_speed_too_low(self):
+        """Test: Zu niedrige Metronom-Geschwindigkeit"""
+        self.assertFalse(SettingsService.validate_metronome_speed(19))
+        self.assertFalse(SettingsService.validate_metronome_speed(0))
+        self.assertFalse(SettingsService.validate_metronome_speed(-10))
+
+    def test_validate_metronome_speed_too_high(self):
+        """Test: Zu hohe Metronom-Geschwindigkeit"""
+        self.assertFalse(SettingsService.validate_metronome_speed(301))
+        self.assertFalse(SettingsService.validate_metronome_speed(500))
+        self.assertFalse(SettingsService.validate_metronome_speed(1000))
+
+    def test_validate_metronome_speed_boundary_values(self):
+        """Test: Grenzwerte (20 und 300)"""
+        self.assertTrue(SettingsService.validate_metronome_speed(20))
+        self.assertTrue(SettingsService.validate_metronome_speed(300))
+        self.assertFalse(SettingsService.validate_metronome_speed(19))
+        self.assertFalse(SettingsService.validate_metronome_speed(301))
+
+    # ========================
+    # Target Error Rate Validation
+    # ========================
+
+    def test_validate_target_error_rate_valid_range(self):
+        """Test: Gültige Fehlerraten (0-100)"""
+        self.assertTrue(SettingsService.validate_target_error_rate(0))
+        self.assertTrue(SettingsService.validate_target_error_rate(5))
+        self.assertTrue(SettingsService.validate_target_error_rate(10))
+        self.assertTrue(SettingsService.validate_target_error_rate(50))
+        self.assertTrue(SettingsService.validate_target_error_rate(100))
+
+    def test_validate_target_error_rate_negative(self):
+        """Test: Negative Fehlerraten sind ungültig"""
+        self.assertFalse(SettingsService.validate_target_error_rate(-1))
+        self.assertFalse(SettingsService.validate_target_error_rate(-10))
+
+    def test_validate_target_error_rate_too_high(self):
+        """Test: Fehlerraten über 100 sind ungültig"""
+        self.assertFalse(SettingsService.validate_target_error_rate(101))
+        self.assertFalse(SettingsService.validate_target_error_rate(200))
+
+    def test_validate_target_error_rate_boundary_values(self):
+        """Test: Grenzwerte (0 und 100)"""
+        self.assertTrue(SettingsService.validate_target_error_rate(0))
+        self.assertTrue(SettingsService.validate_target_error_rate(100))
+        self.assertFalse(SettingsService.validate_target_error_rate(-1))
+        self.assertFalse(SettingsService.validate_target_error_rate(101))
+
+    # ========================
+    # Max BPM Speed Validation
+    # ========================
+
+    def test_validate_max_bpm_speed_valid_range(self):
+        """Test: Gültige Max-BPM-Geschwindigkeiten (40-200)"""
+        self.assertTrue(SettingsService.validate_max_bpm_speed(40))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(60))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(100))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(150))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(200))
+
+    def test_validate_max_bpm_speed_too_low(self):
+        """Test: Zu niedrige Max-BPM-Geschwindigkeit"""
+        self.assertFalse(SettingsService.validate_max_bpm_speed(39))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(0))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(-10))
+
+    def test_validate_max_bpm_speed_too_high(self):
+        """Test: Zu hohe Max-BPM-Geschwindigkeit"""
+        self.assertFalse(SettingsService.validate_max_bpm_speed(201))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(300))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(500))
+
+    def test_validate_max_bpm_speed_boundary_values(self):
+        """Test: Grenzwerte (40 und 200)"""
+        self.assertTrue(SettingsService.validate_max_bpm_speed(40))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(200))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(39))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(201))
+
+    # ========================
+    # Speed Display Validation
+    # ========================
+
+    def test_validate_speed_display_zpm(self):
+        """Test: 'zpm' ist gültiges Display-Format"""
+        self.assertTrue(SettingsService.validate_speed_display('zpm'))
+
+    def test_validate_speed_display_wpm(self):
+        """Test: 'wpm' ist gültiges Display-Format"""
+        self.assertTrue(SettingsService.validate_speed_display('wpm'))
+
+    def test_validate_speed_display_invalid(self):
+        """Test: Ungültige Display-Formate"""
+        self.assertFalse(SettingsService.validate_speed_display('cpm'))
+        self.assertFalse(SettingsService.validate_speed_display('bpm'))
+        self.assertFalse(SettingsService.validate_speed_display('ZPM'))
+        self.assertFalse(SettingsService.validate_speed_display(''))
+        self.assertFalse(SettingsService.validate_speed_display('words'))
+
+    # ========================
+    # Metronome Sound Validation
+    # ========================
+
+    def test_validate_metronome_sound_valid(self):
+        """Test: Gültige Metronom-Sounds"""
+        self.assertTrue(SettingsService.validate_metronome_sound('beep'))
+        self.assertTrue(SettingsService.validate_metronome_sound('click'))
+        self.assertTrue(SettingsService.validate_metronome_sound('woodblock'))
+
+    def test_validate_metronome_sound_invalid(self):
+        """Test: Ungültige Metronom-Sounds"""
+        self.assertFalse(SettingsService.validate_metronome_sound('bell'))
+        self.assertFalse(SettingsService.validate_metronome_sound('BEEP'))
+        self.assertFalse(SettingsService.validate_metronome_sound(''))
+        self.assertFalse(SettingsService.validate_metronome_sound('tick'))
+
+    # ========================
+    # Edge Cases & Type Safety
+    # ========================
+
+    def test_validate_with_string_numbers(self):
+        """Test: String-Zahlen sollten False geben (Type Safety)"""
+        # Python's comparison operators werden String mit Int vergleichen
+        # "100" < 20 gibt False, "100" <= 300 gibt True bei String-Vergleich
+        # Aber diese Tests sollten idealerweise Type-safe sein
+        try:
+            result = SettingsService.validate_metronome_speed("60")
+            # Wenn keine Exception, dann wurde String als Zahl behandelt
+            # Das ist OK, aber nicht ideal
+            self.assertIsInstance(result, bool)
+        except TypeError:
+            # Wenn TypeError, dann ist die Methode type-safe (gut!)
+            pass
+
+    def test_validate_comprehensive_settings(self):
+        """Test: Umfassende Validierung eines kompletten Settings-Sets"""
+        # Gültige Settings
+        valid_settings = {
+            'metronome_mode': 'automatic',
+            'metronome_speed': 60,
+            'target_error_rate': 5,
+            'max_bpm_speed': 100,
+            'speed_display': 'zpm',
+            'metronome_sound': 'beep'
+        }
+
+        self.assertTrue(SettingsService.validate_metronome_mode(valid_settings['metronome_mode']))
+        self.assertTrue(SettingsService.validate_metronome_speed(valid_settings['metronome_speed']))
+        self.assertTrue(SettingsService.validate_target_error_rate(valid_settings['target_error_rate']))
+        self.assertTrue(SettingsService.validate_max_bpm_speed(valid_settings['max_bpm_speed']))
+        self.assertTrue(SettingsService.validate_speed_display(valid_settings['speed_display']))
+        self.assertTrue(SettingsService.validate_metronome_sound(valid_settings['metronome_sound']))
+
+        # Ungültige Settings
+        invalid_settings = {
+            'metronome_mode': 'manual',
+            'metronome_speed': 400,
+            'target_error_rate': 150,
+            'max_bpm_speed': 300,
+            'speed_display': 'cpm',
+            'metronome_sound': 'bell'
+        }
+
+        self.assertFalse(SettingsService.validate_metronome_mode(invalid_settings['metronome_mode']))
+        self.assertFalse(SettingsService.validate_metronome_speed(invalid_settings['metronome_speed']))
+        self.assertFalse(SettingsService.validate_target_error_rate(invalid_settings['target_error_rate']))
+        self.assertFalse(SettingsService.validate_max_bpm_speed(invalid_settings['max_bpm_speed']))
+        self.assertFalse(SettingsService.validate_speed_display(invalid_settings['speed_display']))
+        self.assertFalse(SettingsService.validate_metronome_sound(invalid_settings['metronome_sound']))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_statistics_service.py

@@ -0,0 +1,240 @@
+"""
+Unit Tests für StatisticsService
+"""
+import unittest
+from services.statistics_service import StatisticsService
+
+
+class TestStatisticsServiceCalculations(unittest.TestCase):
+    """Tests für Statistik-Berechnungen (ohne DB-Zugriff)"""
+
+    def test_calculate_typing_statistics_perfect_input(self):
+        """Test: Perfekte Eingabe ohne Fehler"""
+        user_input = "hello world"
+        current_text = "hello world"
+        elapsed_time = 10.0  # 10 Sekunden
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 11)
+        self.assertEqual(stats['incorrect_chars'], 0)
+        self.assertEqual(stats['total_chars'], 11)
+        self.assertEqual(stats['error_rate'], 0.0)
+        self.assertEqual(stats['accuracy'], 100.0)
+        self.assertGreater(stats['typing_speed'], 0)
+        self.assertGreater(stats['words_per_minute'], 0)
+
+    def test_calculate_typing_statistics_with_errors(self):
+        """Test: Eingabe mit Fehlern"""
+        user_input = "hallo world"  # 'a' statt 'e'
+        current_text = "hello world"
+        elapsed_time = 10.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 10)  # alle außer 'a'
+        self.assertEqual(stats['incorrect_chars'], 1)
+        self.assertEqual(stats['total_chars'], 11)
+        self.assertGreater(stats['error_rate'], 0)
+        self.assertLess(stats['accuracy'], 100.0)
+
+    def test_calculate_typing_statistics_all_wrong(self):
+        """Test: Alle Zeichen falsch"""
+        user_input = "xxxxx"
+        current_text = "hello"
+        elapsed_time = 5.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 0)
+        self.assertEqual(stats['incorrect_chars'], 5)
+        self.assertEqual(stats['error_rate'], 100.0)
+        self.assertEqual(stats['accuracy'], 0.0)
+
+    def test_calculate_typing_statistics_empty_input(self):
+        """Test: Leere Eingabe"""
+        user_input = ""
+        current_text = "hello"
+        elapsed_time = 5.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 0)
+        self.assertEqual(stats['incorrect_chars'], 0)
+        self.assertEqual(stats['total_chars'], 0)
+        self.assertEqual(stats['error_rate'], 0.0)
+        self.assertEqual(stats['accuracy'], 0.0)
+
+    def test_calculate_typing_statistics_too_fast(self):
+        """Test: Zu schnelle Eingabe (< 1 Sekunde) gibt 0 zurück"""
+        user_input = "hello"
+        current_text = "hello"
+        elapsed_time = 0.5  # Unter 1 Sekunde
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # Sollte 0 zurückgeben wegen unrealistischer Zeit
+        self.assertEqual(stats['typing_speed'], 0)
+        self.assertEqual(stats['words_per_minute'], 0)
+
+    def test_calculate_typing_statistics_realistic_speed(self):
+        """Test: Realistische Tippgeschwindigkeit"""
+        # 60 Zeichen in 60 Sekunden = 60 ZPM = 12 WPM
+        user_input = "a" * 60
+        current_text = "a" * 60
+        elapsed_time = 60.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # 60 chars / 60 sec * 60 = 60 ZPM
+        self.assertEqual(stats['typing_speed'], 60)
+        # 60 correct chars / 5 / 1 minute = 12 WPM
+        self.assertEqual(stats['words_per_minute'], 12.0)
+
+    def test_calculate_typing_statistics_speed_limit(self):
+        """Test: Geschwindigkeitsbegrenzung (max 1000 ZPM, 200 WPM)"""
+        # Unrealistisch schnelle Eingabe
+        user_input = "a" * 1000
+        current_text = "a" * 1000
+        elapsed_time = 1.0  # 1 Sekunde
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # Sollte auf max. Werte begrenzt sein
+        self.assertLessEqual(stats['typing_speed'], 1000)
+        self.assertLessEqual(stats['words_per_minute'], 200.0)
+
+    def test_calculate_typing_statistics_partial_correct(self):
+        """Test: Teilweise korrekte Eingabe"""
+        user_input = "hello xxx"  # Erste 5 korrekt, dann falsch
+        current_text = "hello world"
+        elapsed_time = 10.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 6)  # "hello "
+        self.assertEqual(stats['incorrect_chars'], 3)  # "xxx"
+        self.assertEqual(stats['total_chars'], 9)
+
+    def test_calculate_typing_statistics_longer_than_text(self):
+        """Test: Eingabe länger als Zieltext (alle Extra-Zeichen sind Fehler)"""
+        user_input = "hello world extra"
+        current_text = "hello world"
+        elapsed_time = 10.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['correct_chars'], 11)  # "hello world"
+        self.assertEqual(stats['incorrect_chars'], 6)  # " extra"
+        self.assertEqual(stats['total_chars'], 17)
+
+    def test_calculate_typing_statistics_error_rate_calculation(self):
+        """Test: Fehlerrate-Berechnung"""
+        # 10 Zeichen, 2 falsch = 20% Fehlerrate
+        user_input = "heXlo worXd"
+        current_text = "hello world"
+        elapsed_time = 10.0
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        self.assertEqual(stats['incorrect_chars'], 2)
+        self.assertEqual(stats['total_chars'], 11)
+        # 2/11 * 100 ≈ 18.2%
+        self.assertAlmostEqual(stats['error_rate'], 18.2, delta=0.1)
+        self.assertAlmostEqual(stats['accuracy'], 81.8, delta=0.1)
+
+    def test_calculate_typing_statistics_duration_per_char(self):
+        """Test: Durchschnittliche Zeit pro Zeichen"""
+        user_input = "hello"  # 5 Zeichen
+        current_text = "hello"
+        elapsed_time = 5.0  # 5 Sekunden
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # 5 sec / 5 chars = 1.0 sec/char
+        self.assertEqual(stats['duration_per_char'], 1.0)
+
+    def test_calculate_typing_statistics_wpm_formula(self):
+        """Test: WPM-Formel (korrekte Zeichen / 5 / Minuten)"""
+        # 100 korrekte Zeichen in 2 Minuten
+        user_input = "a" * 100
+        current_text = "a" * 100
+        elapsed_time = 120.0  # 2 Minuten
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # 100 / 5 / 2 = 10 WPM
+        self.assertEqual(stats['words_per_minute'], 10.0)
+
+    def test_calculate_typing_statistics_rounding(self):
+        """Test: Rundung der Ergebnisse"""
+        user_input = "hello world test"
+        current_text = "hello world test"
+        elapsed_time = 7.123  # Ungerade Zeit
+
+        stats = StatisticsService.calculate_typing_statistics(
+            user_input, current_text, elapsed_time
+        )
+
+        # Alle Werte sollten gerundet sein
+        self.assertIsInstance(stats['typing_speed'], int)  # Ganzzahl
+        self.assertIsInstance(stats['error_rate'], float)
+        self.assertIsInstance(stats['words_per_minute'], float)
+        self.assertIsInstance(stats['accuracy'], float)
+
+        # Überprüfe Dezimalstellen
+        error_rate_str = str(stats['error_rate'])
+        if '.' in error_rate_str:
+            decimals = len(error_rate_str.split('.')[1])
+            self.assertLessEqual(decimals, 1)  # Max 1 Dezimalstelle
+
+
+class TestStatisticsServiceHelpers(unittest.TestCase):
+    """Tests für Helper-Methoden ohne DB-Zugriff"""
+
+    def test_calculate_chars_per_minute_from_stats(self):
+        """Test: Berechnung aus Statistik-Dict"""
+        # Wenn wir die typing_speed erhalten, sollte sie korrekt sein
+        stats = StatisticsService.calculate_typing_statistics(
+            "hello", "hello", 5.0
+        )
+
+        # 5 chars / 5 sec * 60 = 60 ZPM
+        self.assertEqual(stats['typing_speed'], 60)
+
+    def test_calculate_wpm_from_stats(self):
+        """Test: WPM-Berechnung aus Statistik-Dict"""
+        stats = StatisticsService.calculate_typing_statistics(
+            "hello", "hello", 5.0
+        )
+
+        # 5 correct chars / 5 / (5/60 minutes) = 12 WPM
+        self.assertEqual(stats['words_per_minute'], 12.0)
+
+
+if __name__ == '__main__':
+    unittest.main()