diff --git a/.coveragerc b/.coveragerc deleted file mode 100644 index f16bad5..0000000 --- a/.coveragerc +++ /dev/null @@ -1,25 +0,0 @@ -[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 diff --git a/.githooks/pre-commit b/.githooks/pre-commit deleted file mode 100755 index 99e0c9d..0000000 --- a/.githooks/pre-commit +++ /dev/null @@ -1,46 +0,0 @@ -#!/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 diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml deleted file mode 100644 index a0fd13a..0000000 --- a/.github/workflows/coverage.yml +++ /dev/null @@ -1,90 +0,0 @@ -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 - }); diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml deleted file mode 100644 index 8261a49..0000000 --- a/.github/workflows/tests.yml +++ /dev/null @@ -1,116 +0,0 @@ -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 diff --git a/.gitignore b/.gitignore index e2bcad9..bcba0fd 100644 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,6 @@ __pycache__/ to_do_list.txt *.off -infos/ # C extensions *.so @@ -183,12 +182,6 @@ 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/ diff --git a/CI_CD.md b/CI_CD.md deleted file mode 100644 index 404ac77..0000000 --- a/CI_CD.md +++ /dev/null @@ -1,319 +0,0 @@ -# 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! 🎉 diff --git a/CLAUDE.md b/CLAUDE.md index a72b57e..f2509ae 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -77,47 +77,6 @@ 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 diff --git a/HILFE.md b/HILFE.md index fae1945..e8f6002 100644 --- a/HILFE.md +++ b/HILFE.md @@ -1,4 +1,4 @@ -# 📖 Typewriter Trainer - Online-Hilfe (v0.5.0) +# 📖 Typewriter Trainer - Online-Hilfe (v0.4.5) 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.5.0 - Mit ❤️ entwickelt für effektives Tipptraining* +*Typewriter Trainer v0.4.5 - Mit ❤️ entwickelt für effektives Tipptraining* diff --git a/PROJECT_STRUCTURE.md b/PROJECT_STRUCTURE.md index d28b840..1bd62a1 100644 --- a/PROJECT_STRUCTURE.md +++ b/PROJECT_STRUCTURE.md @@ -253,4 +253,4 @@ Alle sensiblen Dateien sind bereits in `.gitignore` aufgelistet. --- **Letzte Aktualisierung**: 2025-10-27 -**Version**: v0.5.0 _(siehe [VERSION](VERSION) Datei)_ +**Version**: v0.4.5 _(siehe [VERSION](VERSION) Datei)_ diff --git a/README.md b/README.md index c070bec..b0c6d97 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Typewriter Tutor - Adaptiver Tipptrainer -**Version:** v0.5.0 _(siehe [VERSION](VERSION) Datei)_ +**Version:** v0.4.5 _(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,7 +97,6 @@ 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 @@ -110,15 +109,8 @@ typewriter/ ├── static/ │ ├── css/ │ │ └── style.css # Styling (Dark/Light Mode) -│ ├── 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 +│ ├── js/ +│ │ └── script.js # Client-Logik & Adaptives Metronom │ └── favicon.svg # Schreibmaschinen-Icon │ ├── templates/ @@ -205,117 +197,37 @@ Die Statistik-Seite (`/statistics`) bietet: - **Datenexport**: CSV und JSON-Download Ihrer Statistiken - **Verlaufsanalyse**: Sehen Sie Ihre Fortschritte über mehrere Sitzungen -## 🧪 Tests & CI/CD +## 🧪 Tests -Das Projekt enthält eine umfassende Test-Suite mit **80 Tests** (100% Erfolgsrate) und vollständiger CI/CD-Integration. +Das Projekt enthält umfangreiche Test-Suites: -### 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):** +### App-Tests (18 Tests) ```bash -# 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 +python -m unittest test_app -v ``` -**Legacy Tests (40 Tests):** -```bash -# App-Tests (18 Tests) -python -m unittest test_app -v +Testet: +- Statistik-Berechnungen +- API-Endpoints +- Input-Validierung +- Datenbank-Operationen +- CSV/JSON-Export -# Metronom-Tests (22 Tests) +### Metronom-Tests (22 Tests) +```bash python test_metronome_velocity.py ``` -### Was wird getestet? +Testet: +- Alle 5 Anpassungsregeln +- Realistische Szenarien (Anfänger bis Experte) +- Edge Cases und Grenzfälle +- Enthält detaillierte Simulation -**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) +Siehe [`README_METRONOME_TESTS.md`](README_METRONOME_TESTS.md) für Details. ## 🔧 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: @@ -457,17 +369,7 @@ Contributions sind willkommen! Bitte: > **Hinweis:** Die aktuelle Versionsnummer wird zentral in der [VERSION](VERSION) Datei verwaltet. -### 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 +### Version 0.4.5 (Aktuell) - ✅ **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 @@ -520,6 +422,7 @@ 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. diff --git a/VERSION b/VERSION index b043aa6..a423f7f 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v0.5.0 +v0.4.5 diff --git a/app.py b/app.py index 0167eed..12862be 100644 --- a/app.py +++ b/app.py @@ -1,14 +1,15 @@ -""" -Flask Application - Typewriter Tutor -Modularized version with Blueprints -""" - -import logging import os -from flask import Flask +import json +import re +import logging +import csv +import secrets +from io import StringIO +from typing import Dict, List, Any, Optional +from flask import Flask, render_template, request, jsonify, session, Response, make_response, send_from_directory from flask_wtf.csrf import CSRFProtect -from models import db -from services import helpers +from models import db, Progress, Statistic, LessonStatistic, LessonProgress, DailyPractice, UserSettings +from datetime import datetime, date, timedelta # Logging konfigurieren logging.basicConfig( @@ -17,78 +18,1338 @@ logging.basicConfig( ) logger = logging.getLogger(__name__) -# Flask App erstellen +# Versionsnummer aus VERSION-Datei laden +def get_version() -> str: + """Liest die Versionsnummer aus der VERSION-Datei""" + version_file = os.path.join(os.path.dirname(__file__), 'VERSION') + try: + with open(version_file, 'r') as f: + return f.read().strip() + except Exception: + return '0.4.0' + +VERSION = get_version() + +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(__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 + app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///typewriter.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False -app.secret_key = helpers.get_or_create_secret_key() +app.secret_key = get_or_create_secret_key() # CSRF-Schutz aktivieren csrf = CSRFProtect(app) -# Datenbank initialisieren -db.init_app(app) - -# Initialisiere Pfade für helpers -with app.app_context(): - helpers.initialize_paths(app.root_path) - -# VERSION aus helpers laden -VERSION = helpers.get_version() - # Globale Template-Variablen @app.context_processor def inject_globals(): """Stellt globale Variablen für alle Templates bereit""" return {'APP_VERSION': VERSION} +db.init_app(app) -# Blueprints importieren und registrieren -from routes.main import main_bp -from routes.training import training_bp -from routes.statistics import statistics_bp -from routes.settings import settings_bp -from routes.session import session_bp -from routes.utils import utils_bp +# 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."} +] -app.register_blueprint(main_bp) -app.register_blueprint(training_bp) -app.register_blueprint(statistics_bp) -app.register_blueprint(settings_bp) -app.register_blueprint(session_bp) -app.register_blueprint(utils_bp) +# Laden der Lektionen aus der JSON-Datei +DATA_PATH = os.path.join(app.root_path, "data", "lessons.json") +lessons = [] -# CSRF-Ausnahme für Shutdown-Route -csrf.exempt(utils_bp) +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() -> 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(lesson_index: int) -> LessonProgress: + """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( + 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() + 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(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() -> 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] + +# Prüfe Datenbank-Status +def check_database_status(): + """ + 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. + """ + from sqlalchemy import inspect, text + + 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 + +# Datenbank-Status prüfen und Lektionen laden +with app.app_context(): + db_ready = check_database_status() + + if not db_ready: + logger.error("Anwendung kann nicht gestartet werden - Datenbank nicht bereit") + logger.error("Siehe Warnungen oben für Lösungsschritte") + import sys + sys.exit(1) + + # Versuche Lektionen zu laden + load_lessons() + + # Falls keine Lektionen geladen wurden, erstelle Beispieldaten + if not lessons: + logger.warning("Keine Lektionen verfügbar, erstelle Beispiel-Lektionen...") + lessons = create_sample_lessons() + + logger.info(f"{len(lessons)} Lektionen geladen") + +@app.route('/') +def welcome(): + """Begrüßungsseite / Landing Page""" + return render_template('welcome.html') + +@app.route('/train') +def train(): + """Hauptseite des Tipptrainers""" + try: + # Hole den globalen Fortschritt aus der Datenbank (speichert nur current_text_index) + progress = Progress.query.first() + + if not progress: + # Falls keine Daten vorhanden sind, initialisiere + progress = Progress( + current_text_index=0, + current_position=0, + last_text="" + ) + db.session.add(progress) + db.session.commit() + logger.info("Neuen globalen Fortschritt initialisiert") + + # Lade gespeicherte Benutzereinstellungen aus der Datenbank + user_settings = get_or_create_user_settings() + + # Bestimme die aktuelle Lektion + current_lesson_index = progress.current_text_index + + # Wenn eine gespeicherte Lektion in UserSettings existiert und der Progress noch initial ist, + # verwende die gespeicherte Lektion + if current_lesson_index == 0 and user_settings.current_lesson_index > 0: + current_lesson_index = user_settings.current_lesson_index + progress.current_text_index = current_lesson_index + db.session.commit() + + # Validiere Lektionsindex + if not lessons or current_lesson_index >= len(lessons): + current_lesson_index = 0 + progress.current_text_index = 0 + db.session.commit() + + # Hole den aktuellen Text + current_text = lessons[current_lesson_index]['text'] if lessons else "Keine Lektionen verfügbar" + + # Lade lektionsspezifische Fortschrittsdaten + lesson_progress = get_or_create_lesson_progress(current_lesson_index) + + # Daten aus LessonProgress + user_input = lesson_progress.last_text + cursor_position = lesson_progress.current_position + total_elapsed_time = lesson_progress.total_elapsed_time or 0 + key_stroke_count = lesson_progress.key_stroke_count or 0 + is_paused = lesson_progress.is_paused if lesson_progress.is_paused is not None else True + + # Netto-Trainingszeit (wird in JavaScript SessionManager verwaltet) + net_training_time = total_elapsed_time + + logger.debug(f"Lade Lektion {current_lesson_index}: Position={cursor_position}, Eingabe-Länge={len(user_input)}") + + # Bestimme den Lektionstitel + current_lesson_title = "Unbekannte Lektion" + if lessons and current_lesson_index < len(lessons): + lesson = lessons[current_lesson_index] + current_lesson_title = lesson.get('title', f"Lektion {current_lesson_index + 1}") + + # Metronom-Einstellungen aus Datenbank laden + metronome_enabled = user_settings.metronome_enabled + metronome_bpm = user_settings.metronome_bpm + metronome_sound = user_settings.metronome_sound + metronome_mode = user_settings.metronome_mode + metronome_speed = user_settings.metronome_speed + target_error_rate = user_settings.target_error_rate + max_bpm_speed = getattr(user_settings, 'max_bpm_speed', 100) # Fallback für Kompatibilität + speed_display = user_settings.speed_display + + # Synchronisiere Session mit DB + 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 + + return render_template('index.html', + current_text=current_text, + current_position=cursor_position, + last_text=user_input, + total_elapsed_time=total_elapsed_time, + net_training_time=net_training_time, + key_stroke_count=key_stroke_count, + is_paused=is_paused, + lessons=lessons, + current_lesson_title=current_lesson_title, + current_lesson_index=current_lesson_index, + metronome_enabled=metronome_enabled, + metronome_bpm=metronome_bpm, + metronome_sound=metronome_sound, + metronome_mode=metronome_mode, + metronome_speed=metronome_speed, + target_error_rate=target_error_rate, + max_bpm_speed=max_bpm_speed, + speed_display=speed_display) -# Datenbank-Status prüfen und Lektionen laden (nur wenn nicht im Test-Modus) -if not app.config.get('TESTING', False) and os.environ.get('FLASK_TESTING') != 'true': - with app.app_context(): - db_ready = helpers.check_database_status(db.engine) + except Exception as e: + logger.error(f"Fehler in index(): {e}", exc_info=True) + # Auch im Fehlerfall Metronom-Standardwerte übergeben + 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') - if not db_ready: - logger.error("Anwendung kann nicht gestartet werden - Datenbank nicht bereit") - logger.error("Siehe Warnungen oben für Lösungsschritte") - import sys - sys.exit(1) +@app.route('/debug') +def debug(): + """Debug-Route zum Überprüfen der Lektionen und Konfiguration""" + # Debug-Endpoint nur im Debug-Modus verfügbar + if not app.debug: + from flask import abort + abort(404) - # Versuche Lektionen zu laden - helpers.load_lessons() + 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': app.root_path, + 'fallback_used': lessons == FALLBACK_LESSONS + } + + return jsonify(debug_info) - # Falls keine Lektionen geladen wurden, erstelle Beispieldaten - if not helpers.lessons: - logger.warning("Keine Lektionen verfügbar, erstelle Beispiel-Lektionen...") - helpers.lessons = helpers.create_sample_lessons() +@app.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 - logger.info(f"{len(helpers.lessons)} Lektionen geladen") +@app.route('/recreate_lessons', methods=['POST']) +def recreate_lessons(): + """Endpoint zum Neuerstellen der Lektionen-Datei""" + global lessons + try: + lessons = create_sample_lessons() + return jsonify({ + 'status': 'success', + 'message': 'Beispiel-Lektionen erfolgreich erstellt', + 'lessons_loaded': len(lessons) + }) + except Exception as e: + return jsonify({ + 'status': 'error', + 'message': f'Fehler beim Erstellen der Lektionen: {e}' + }), 500 +@app.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)) + + # Hole den globalen Fortschritt (für lesson_index) + progress = Progress.query.first() + + if not progress: + return jsonify({'error': 'Progress nicht gefunden'}), 400 + + try: + # Hole lektionsspezifischen Fortschritt + lesson_index = progress.current_text_index + lesson_progress = get_or_create_lesson_progress(lesson_index) + + # Aktualisiere lektionsspezifische Daten + 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 + + # Prüfe, ob die Lektion abgeschlossen ist + lesson_completed = cursor_position >= len(current_text) and len(user_input) == len(current_text) + + if lesson_completed: + # Speichere Statistik für abgeschlossene Lektion + logger.info(f"Lektion {lesson_index} abgeschlossen! Speichere Statistik...") + + # Berechne finale Statistiken + stats = calculate_statistics(user_input, current_text, elapsed_time) + + # Speichere in LessonStatistic + lesson_stat = LessonStatistic( + 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 # Millisekunden zu Sekunden + ) + db.session.add(lesson_stat) + + # Setze LessonProgress zurück + 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 + + logger.info(f"Lektion {lesson_index} zurückgesetzt") + + # Speichere in der Datenbank + db.session.commit() + + # Speichere zusätzliche Zustandsdaten auch in der Session (für Kompatibilität) + 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 + + # Berechne Statistiken mit echter Zeit + stats = calculate_statistics(user_input, current_text, elapsed_time) + + # Füge lesson_completed zu Response hinzu + stats['lesson_completed'] = lesson_completed + + 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 + +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) + } + +@app.route('/next_text', methods=['POST']) +def next_text(): + """Wechselt zum nächsten Text""" + try: + progress = Progress.query.first() + + if not progress: + return jsonify({'error': 'Progress nicht gefunden'}), 400 + + if not lessons: + return jsonify({'error': 'Keine Lektionen verfügbar'}), 400 + + # Wechsel zum nächsten Text + old_lesson_index = progress.current_text_index + + if progress.current_text_index < len(lessons) - 1: + progress.current_text_index += 1 + else: + # Wenn wir am Ende sind, starten wir von vorne + progress.current_text_index = 0 + + new_lesson_index = progress.current_text_index + db.session.commit() + + # Lade LessonProgress für neue Lektion (wird automatisch erstellt falls nicht vorhanden) + lesson_progress = get_or_create_lesson_progress(new_lesson_index) + + # Synchronisiere Session mit der neuen Lektion + session['total_elapsed_time'] = lesson_progress.total_elapsed_time + session['net_training_time'] = lesson_progress.total_elapsed_time + session['key_stroke_count'] = lesson_progress.key_stroke_count + session['is_paused'] = lesson_progress.is_paused + + # Bestimme den Titel der neuen Lektion + new_lesson = lessons[new_lesson_index] + lesson_title = new_lesson.get('title', f"Lektion {new_lesson_index + 1}") + + logger.info(f"Lektionswechsel: {old_lesson_index} -> {new_lesson_index}") + + return jsonify({ + 'text': new_lesson['text'], + 'index': new_lesson_index, + 'total': len(lessons), + 'title': lesson_title, + '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 + }) + + except Exception as e: + logger.error(f"Fehler in next_text: {e}", exc_info=True) + return jsonify({'error': 'Interner Serverfehler'}), 500 + +@app.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 + + if lesson_index < 0 or lesson_index >= len(lessons): + return jsonify({'error': 'Lektionsindex außerhalb des gültigen Bereichs'}), 400 + + progress = Progress.query.first() + if not progress: + return jsonify({'error': 'Progress nicht gefunden'}), 400 + + old_lesson_index = progress.current_text_index + + # Setze neue Lektion + progress.current_text_index = lesson_index + db.session.commit() + + # Lade LessonProgress für neue Lektion (wird automatisch erstellt falls nicht vorhanden) + lesson_progress = get_or_create_lesson_progress(lesson_index) + + # Synchronisiere Session mit der neuen Lektion + session['total_elapsed_time'] = lesson_progress.total_elapsed_time + session['net_training_time'] = lesson_progress.total_elapsed_time + session['key_stroke_count'] = lesson_progress.key_stroke_count + session['is_paused'] = lesson_progress.is_paused + + # Bestimme den Titel der neuen Lektion + new_lesson = lessons[lesson_index] + lesson_title = new_lesson.get('title', f"Lektion {lesson_index + 1}") + + logger.info(f"Lektionswechsel: {old_lesson_index} -> {lesson_index}") + + return jsonify({ + 'text': new_lesson['text'], + 'title': lesson_title, + '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 + }) + + except Exception as e: + logger.error(f"Fehler in set_lesson: {e}", exc_info=True) + return jsonify({'error': 'Interner Serverfehler'}), 500 + +@app.route('/save_lesson_statistics', methods=['POST']) +def save_lesson_statistics(): + """Speichert die Statistiken für eine abgeschlossene Lektion""" + 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(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 + + logger.debug(f"Empfangene Statistik: lesson_index={lesson_index}, chars_per_minute={chars_per_minute}, error_rate={error_rate}, wpm={wpm}, training_duration={training_duration}") + + # Neue Statistik für die Lektion erstellen + try: + 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("Statistik erfolgreich in Datenbank gespeichert") + + 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 + +@app.route('/reset_lesson', methods=['POST']) +def reset_lesson(): + """Setzt den Fortschritt der aktuellen Lektion zurück""" + try: + # Hole den globalen Fortschritt + progress = Progress.query.first() + if not progress: + return jsonify({'error': 'Progress nicht gefunden'}), 400 + + lesson_index = progress.current_text_index + + # Hole oder erstelle LessonProgress für aktuelle Lektion + lesson_progress = get_or_create_lesson_progress(lesson_index) + + # Setze alle Werte zurück + 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") + + return jsonify({ + 'status': 'success', + 'message': 'Lektion zurückgesetzt', + 'lesson_index': lesson_index + }) + + except Exception as e: + db.session.rollback() + logger.error(f"Fehler in reset_lesson: {e}", exc_info=True) + return jsonify({'error': 'Interner Serverfehler'}), 500 + +@app.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 lesson_index < 0 or lesson_index >= len(lessons): + return jsonify({'error': 'Lektionsindex außerhalb des gültigen Bereichs'}), 400 + + # Lösche alle Statistiken für diese Lektion + 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 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 + +@app.route('/statistics') +def statistics(): + """Zeigt die Statistik-Seite mit Diagrammen""" + try: + # Hole den aktuellen Fortschritt für die voreingestellte Lektion + progress = Progress.query.first() + current_lesson_index = progress.current_text_index if progress else 0 + + # Prüfe für jede Lektion, ob Statistik-Daten vorhanden sind + lesson_has_data = [] + for i in range(len(lessons)): + has_data = LessonStatistic.query.filter_by(lesson_index=i).first() is not None + lesson_has_data.append(has_data) + + # Hole die Einstellung für die Geschwindigkeitsanzeige aus der Session + 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') + +@app.route('/get_lesson_statistics/') +def get_lesson_statistics(lesson_index: int) -> Response: + """Gibt die Statistiken für eine bestimmte Lektion zurück""" + try: + stats = LessonStatistic.query.filter_by(lesson_index=lesson_index)\ + .order_by(LessonStatistic.created_at.asc())\ + .all() + + data = { + '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] + } + + 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 + +@app.route('/export/statistics/csv') +def export_statistics_csv() -> Response: + """Exportiert alle Statistiken als CSV-Datei""" + try: + # Hole alle Statistiken + stats = LessonStatistic.query.order_by( + LessonStatistic.lesson_index.asc(), + LessonStatistic.created_at.asc() + ).all() + + # CSV erstellen + output = StringIO() + writer = csv.writer(output) + + # Header + writer.writerow(['Datum', 'Lektion-Nr', 'Lektionstitel', 'Zeichen/Min', 'Fehlerrate %', 'Wörter/Min']) + + # Daten + for stat in stats: + lesson_title = "Unbekannt" + if stat.lesson_index < len(lessons): + lesson_title = lessons[stat.lesson_index].get('title', f"Lektion {stat.lesson_index + 1}") + + 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}" + ]) + + # Response erstellen + 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 + +@app.route('/export/statistics/json') +def export_statistics_json() -> Response: + """Exportiert alle Statistiken als JSON-Datei""" + try: + # Hole alle Statistiken + stats = LessonStatistic.query.order_by( + LessonStatistic.lesson_index.asc(), + LessonStatistic.created_at.asc() + ).all() + + # JSON-Daten erstellen + from datetime import datetime + export_data = { + 'export_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), + 'total_entries': len(stats), + 'statistics': [] + } + + for stat in stats: + lesson_title = "Unbekannt" + if stat.lesson_index < len(lessons): + lesson_title = lessons[stat.lesson_index].get('title', f"Lektion {stat.lesson_index + 1}") + + 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) + }) + + # Response erstellen + 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 + +@app.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"
{hilfe_content}
") + except Exception as e: + logger.error(f"Fehler beim Laden der Hilfe: {e}") + return render_template('hilfe.html', hilfe_html="

Hilfe konnte nicht geladen werden.

") + +@app.route('/images/') +def serve_images(filename): + """Serviert Bilder aus dem images-Verzeichnis""" + return send_from_directory('images', filename) + +@app.route('/settings') +def settings(): + """Einstellungsseite""" + # Lade Einstellungen aus Datenbank mit Defaults + user_settings = get_or_create_user_settings() + current_settings = { + 'metronome_mode': user_settings.metronome_mode, + 'metronome_speed': user_settings.metronome_speed, + 'target_error_rate': user_settings.target_error_rate, + 'max_bpm_speed': getattr(user_settings, 'max_bpm_speed', 100), + 'speed_display': user_settings.speed_display + } + return render_template('settings.html', settings=current_settings) + +@app.route('/save_settings', methods=['POST']) +def save_settings(): + """Speichert die Einstellungen persistent in der Datenbank""" + try: + data = request.get_json() + if not data: + return jsonify({'error': 'Keine Daten empfangen'}), 400 + + # Validiere metronome_mode + metronome_mode = data.get('metronome_mode', 'automatic') + if metronome_mode not in ['automatic', 'explicit']: + return jsonify({'error': 'Ungültiger Metronom-Modus'}), 400 + + # Validiere numerische Werte + 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 + + # Bereichsvalidierung + if not (20 <= metronome_speed <= 300): + return jsonify({'error': 'Metronom-Geschwindigkeit muss zwischen 20 und 300 liegen'}), 400 + + if not (0 <= target_error_rate <= 100): + return jsonify({'error': 'Fehlerrate muss zwischen 0 und 100 liegen'}), 400 + + if not (40 <= max_bpm_speed <= 200): + return jsonify({'error': 'Maximale BPM-Geschwindigkeit muss zwischen 40 und 200 liegen'}), 400 + + # Validiere speed_display + speed_display = data.get('speed_display', 'zpm') + if speed_display not in ['zpm', 'wpm']: + return jsonify({'error': 'Ungültige Geschwindigkeitsanzeige'}), 400 + + # Speichere in Datenbank + progress = Progress.query.first() + current_lesson = progress.current_text_index if progress else 0 + + save_user_settings( + current_lesson_index=current_lesson, + metronome_enabled=True, # Metronome bleibt aktiviert + 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 + +@app.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 + + # Validierung + enabled = bool(data.get('enabled', False)) + + try: + bpm = int(data.get('bpm', 60)) + except (ValueError, TypeError): + return jsonify({'error': 'Ungültiger BPM-Wert'}), 400 + + # Erweiterte Validierung mit detaillierten Fehlermeldungen + 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 sound not in ['beep', 'click', 'woodblock']: + sound = 'beep' # Fallback auf Standard + + 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 + +@app.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 + + # Hole die aktuelle Session-Zeit (in Sekunden) + total_elapsed_time = float(data.get('total_elapsed_time', 0)) + minutes_practiced = total_elapsed_time / 60.0 + + # Aktualisiere die tägliche Übungszeit + if minutes_practiced > 0: + update_daily_practice(minutes_practiced) + + # Speichere alle aktuellen Einstellungen + progress = Progress.query.first() + current_lesson = progress.current_text_index if progress else 0 + + save_user_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 + +@app.route('/session_end') +def session_end(): + """Zeigt die Endseite mit Übungsstatistiken der letzten 30 Tage""" + try: + # Hole die letzten 30 Tage + practice_data = get_last_30_days_practice() + + # Erstelle vollständige Daten für alle 30 Tage (auch Tage ohne Übung) + today = date.today() + full_data = [] + + for i in range(29, -1, -1): # Von 29 Tagen zurück bis heute + current_date = today - timedelta(days=i) + date_str = current_date.strftime('%Y-%m-%d') + + # Suche nach Daten für diesen Tag + 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 + }) + + # Berechne Gesamtstatistiken + 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) + +@app.route('/shutdown', methods=['POST']) +@csrf.exempt +def shutdown(): + """Beendet den Flask-Server (nur für lokale Desktop-Nutzung)""" + try: + logger.info("Server-Shutdown angefordert") + + # Nur im Debug-Mode erlauben + if not app.debug: + return jsonify({'error': 'Shutdown nur im Debug-Mode erlaubt'}), 403 + + # Verzögert beenden, damit die Response noch gesendet werden kann + import threading + def shutdown_server(): + import time + 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 if __name__ == '__main__': logger.info("=" * 50) logger.info("Tipptrainer gestartet") - logger.info(f"Version: {VERSION}") - logger.info(f"Lektionen geladen: {len(helpers.lessons)}") + logger.info(f"Lektionen geladen: {len(lessons)}") logger.info(f"Debug-Info verfügbar unter: http://127.0.0.1:5000/debug") logger.info("=" * 50) diff --git a/convert_txt_files_to_lessons_json.py b/convert_txt_files_to_lessons_json.py deleted file mode 100755 index 2a4c462..0000000 --- a/convert_txt_files_to_lessons_json.py +++ /dev/null @@ -1,305 +0,0 @@ -#!/usr/bin/env python3 -""" -Konvertiert TXT-Dateien in eine lessons.json Datei. - -Format der TXT-Dateien: - Titel: - Untertitel: (wird übersprungen) - Anweisung: - - - -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: - Untertitel: (wird ignoriert) - Anweisung: - - - - # 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() diff --git a/data/lessons.json b/data/lessons.json index 8111b5e..82273ce 100644 --- a/data/lessons.json +++ b/data/lessons.json @@ -1,260 +1,217 @@ [ { - "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", - "task": "Diese Lektion mindestens 5 mal fehlerfrei abschließen!" + "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" }, { - "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", - "task": "Übe die Wörter, bis du sie ohne Hinschauen tippen kannst." + "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" }, { - "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", - "task": "Konzentriere dich auf gleichmäßiges Tempo." + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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;", - "task": "dummy" + "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;" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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;", - "task": "dummy" + "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;" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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,", - "task": "dummy" + "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," }, { - "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;", - "task": "dummy" + "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;" }, { - "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ö", - "task": "dummy" + "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ö" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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.", - "task": "dummy" + "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." }, { - "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,", - "task": "dummy" + "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," }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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", - "task": "dummy" + "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" }, { - "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,", - "task": "dummy" + "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," }, { - "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", - "task": "dummy" + "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" }, { - "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;", - "task": "dummy" + "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;" }, { - "lesson": "100", + "lesson": 100, "title": "Test", - "text": "asdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö", - "task": "dummy" + "text": "asdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö\nasdf\njklö" } -] \ No newline at end of file +] diff --git a/routes/__init__.py b/routes/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/routes/main.py b/routes/main.py deleted file mode 100644 index 3e17bb1..0000000 --- a/routes/main.py +++ /dev/null @@ -1,49 +0,0 @@ -""" -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"
{hilfe_content}
") - except Exception as e: - logger.error(f"Fehler beim Laden der Hilfe: {e}") - return render_template('hilfe.html', hilfe_html="

Hilfe konnte nicht geladen werden.

") - - -@main_bp.route('/images/') -def serve_images(filename): - """Serviert Bilder aus dem images-Verzeichnis""" - return send_from_directory('images', filename) diff --git a/routes/session.py b/routes/session.py deleted file mode 100644 index 868ff14..0000000 --- a/routes/session.py +++ /dev/null @@ -1,87 +0,0 @@ -""" -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) diff --git a/routes/settings.py b/routes/settings.py deleted file mode 100644 index adbd018..0000000 --- a/routes/settings.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -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 diff --git a/routes/statistics.py b/routes/statistics.py deleted file mode 100644 index 6c34e73..0000000 --- a/routes/statistics.py +++ /dev/null @@ -1,182 +0,0 @@ -""" -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/') -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 diff --git a/routes/training.py b/routes/training.py deleted file mode 100644 index afeaa52..0000000 --- a/routes/training.py +++ /dev/null @@ -1,215 +0,0 @@ -""" -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 diff --git a/routes/utils.py b/routes/utils.py deleted file mode 100644 index effaea9..0000000 --- a/routes/utils.py +++ /dev/null @@ -1,161 +0,0 @@ -""" -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 diff --git a/run_coverage.sh b/run_coverage.sh deleted file mode 100755 index 2780c8e..0000000 --- a/run_coverage.sh +++ /dev/null @@ -1,32 +0,0 @@ -#!/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 "" diff --git a/services/__init__.py b/services/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/services/helpers.py b/services/helpers.py deleted file mode 100644 index 90e1c71..0000000 --- a/services/helpers.py +++ /dev/null @@ -1,380 +0,0 @@ -""" -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) - } diff --git a/services/lesson_service.py b/services/lesson_service.py deleted file mode 100644 index 5ebe8ee..0000000 --- a/services/lesson_service.py +++ /dev/null @@ -1,151 +0,0 @@ -""" -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) - } diff --git a/services/progress_service.py b/services/progress_service.py deleted file mode 100644 index 48a5f73..0000000 --- a/services/progress_service.py +++ /dev/null @@ -1,183 +0,0 @@ -""" -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") diff --git a/services/settings_service.py b/services/settings_service.py deleted file mode 100644 index 7b71f47..0000000 --- a/services/settings_service.py +++ /dev/null @@ -1,206 +0,0 @@ -""" -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'] diff --git a/services/statistics_service.py b/services/statistics_service.py deleted file mode 100644 index 971dd37..0000000 --- a/services/statistics_service.py +++ /dev/null @@ -1,250 +0,0 @@ -""" -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 diff --git a/services/training_service.py b/services/training_service.py deleted file mode 100644 index 9b9d131..0000000 --- a/services/training_service.py +++ /dev/null @@ -1,258 +0,0 @@ -""" -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 - } diff --git a/static/js/main.js b/static/js/main.js index 432ce7e..44249fa 100644 --- a/static/js/main.js +++ b/static/js/main.js @@ -565,7 +565,6 @@ class TypewriterApp { this.textDisplayManager.resetScroll(); this.uiManager.updateLessonTitle(data.title); - this.uiManager.updateLessonTask(data.task); this.uiManager.updateLessonHighlight(data.index); this.uiManager.showPlay(); @@ -602,7 +601,6 @@ class TypewriterApp { this.textDisplayManager.resetScroll(); this.uiManager.updateLessonTitle(data.title); - this.uiManager.updateLessonTask(data.task); this.uiManager.updateLessonHighlight(lessonIndex); this.uiManager.showPlay(); diff --git a/static/js/ui.js b/static/js/ui.js index 33a6014..6633d8a 100644 --- a/static/js/ui.js +++ b/static/js/ui.js @@ -143,23 +143,6 @@ 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 diff --git a/templates/hilfe.html b/templates/hilfe.html index fd07ccf..b0b2db7 100644 --- a/templates/hilfe.html +++ b/templates/hilfe.html @@ -131,7 +131,7 @@ - + ← Zurück zum Trainer diff --git a/templates/index.html b/templates/index.html index ce749a9..2d7f103 100644 --- a/templates/index.html +++ b/templates/index.html @@ -55,7 +55,7 @@ - @@ -93,11 +93,6 @@ tabindex="0"> -
- {%- if current_lesson_task and current_lesson_task != 'dummy' -%} - {{- current_lesson_task -}} - {%- endif -%} -