From af43371a5bbf148dafa0b311fe64e56f6aaa7b9d Mon Sep 17 00:00:00 2001 From: neodk2004 Date: Sat, 18 Jul 2026 17:48:48 +0200 Subject: [PATCH] Demo-Login fuer Vorfuehrungen (open.md Punkt 1) - nutzer.ist_demo-Spalte, permanentes Konto demo/demo wird in init_db() automatisch angelegt - Vorausgefuellte fiktive Patientin "Grete Musterfrau" (Pflegegrad 3, 1 Antrag, 2 Leistungen, 2 Aufgaben, 1 Pflegetagebuch-Eintrag) - _demo_seed() - Automatischer Reset alle 6 Stunden per Lazy-Check (kein Cron/Thread noetig): _demo_reset_faellig()/_demo_reset() geprueft bei Login und bei jedem Request (global_auth_check), damit auch eine laufende Sitzung die 6h-Grenze nicht verpasst - Demo-Konto von der Abo-Zahlungspflicht ausgenommen (_hat_aktiven_ zugang) - wurde erst beim Testen entdeckt: bei aktiver Zahlungspflicht waere das Demo-Konto sonst mit "Zahlung erforderlich" ausgesperrt worden, was fuer eine Vorfuehrung inakzeptabel waere - E-Mail-Versand (api/email/senden + /test) fuer das Demo-Konto gesperrt (403) - verhindert Missbrauch der echten SMTP-Konfiguration durch Demo-Besucher - Login-Screen: neuer "Demo ausprobieren"-Button; Topbar zeigt waehrend einer Demo-Sitzung ein "Demo-Modus"-Badge open.md: Reihenfolge sortiert (Docker-Containerisierung und React+ Postgres-Migration als getrennte Aufgaben markiert, da voellig unterschiedlicher Umfang), Punkt 1 als erledigt markiert. Verifiziert: Login, vorausgefuellte Patientendaten, Isolation (Demo sieht nur eigene Patientin), erzwungener Reset (Patient-ID aendert sich, demo_reset_at aktualisiert), E-Mail-Sperre (403), Abo-Ausnahme (Zugriff bleibt moeglich auch bei abo_pflicht=1), Login-Button und Demo-Badge visuell per Playwright bestaetigt. --- CLAUDE.md | 15 ++- open.md | 37 +++++++ pflegepilot_alpha_v2/pflegepilot/app.py | 97 ++++++++++++++++++- .../pflegepilot/templates/index.html | 8 ++ 4 files changed, 153 insertions(+), 4 deletions(-) create mode 100644 open.md diff --git a/CLAUDE.md b/CLAUDE.md index ff16ecc..8fa7921 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -82,13 +82,26 @@ The frontend was originally desktop-only (zero `@media` queries, fixed 228px sid The product owner wants the app to cost **4.99 €/month per account**, provider likely **PayPal** (not yet integrated — no account/API keys exist yet). Since there's no live payment method, the paywall is built but wired to a **global off switch** so it can't lock anyone out before PayPal actually works: - `einstellungen` key `abo_pflicht` (`"1"`/`"0"`, default off) — read via `_abo_pflicht_aktiv()`. Toggle lives in the Backend-Einstellungen "Abo & Zahlung" card. **Leave this off until PayPal is actually wired up.** -- `nutzer.abo_bis` (date, NULL = never granted) / `nutzer.abo_typ` (`'kostenlos_admin'` | future `'paypal'`) track access per account. `_hat_aktiven_zugang(u)` is the single source of truth: always true for admins, always true while `abo_pflicht` is off, otherwise `abo_bis >= today`. +- `nutzer.abo_bis` (date, NULL = never granted) / `nutzer.abo_typ` (`'kostenlos_admin'` | future `'paypal'`) track access per account. `_hat_aktiven_zugang(u)` is the single source of truth: always true for admins, always true for the demo account (`ist_demo`, see "Demo account" below — it must never hit the paywall regardless of `abo_pflicht`), always true while `abo_pflicht` is off, otherwise `abo_bis >= today`. - `global_auth_check()` enforces this on every `/api/*` call except a small allowlist (`/api/abo/status`, `/api/abo/aktivieren`, `/api/auth/logout`) — returns **402 Payment Required** (`code: "abo_erforderlich"`) when blocked, so a blocked user can still see their status and (eventually) pay. - `POST /api/abo/aktivieren` is an intentional **stub** (501, "noch nicht verfügbar") — real PayPal Checkout/Subscriptions integration replaces this later; do not fake a success response here. - Admin can grant free access via `POST /api/admin/nutzer//abo-freischalten` (`{monate, begruendung}`, 1–12 months, extends from the later of today/existing `abo_bis`, admin-only, audit-logged like the other admin-dashboard actions) — this is the "1 Monat kostenlos freischalten" capability the operator asked for, surfaced as a "Freischalten" button per row in the Admin-Dashboard. - Frontend: `curAbo`/`aboBlockiert` globals are set in `initApp()` from `GET /api/abo/status`. `go(name)` redirects any navigation to the `meinabo` page while `aboBlockiert` is true, so a blocked account always lands on its own status/pay screen instead of a broken page. `pgMeinAbo()` is that page (status, price, stub PayPal button) and doubles as the always-available "check my subscription" view when unblocked. - When actually integrating PayPal: replace `/api/abo/aktivieren`'s stub body with real Checkout/Subscription creation, add a webhook endpoint to update `abo_bis`/`abo_typ` on payment events, and only then flip `abo_pflicht` to `"1"`. +## Demo account + +A permanent `demo`/`demo` account (`nutzer.ist_demo=1`) exists for showing the app to prospects, created automatically in `init_db()` if missing. It's a completely ordinary `nutzer`-role account — no special-casing in the isolation model — with two exceptions layered on top: + +- **Immune to the subscription paywall**: `_hat_aktiven_zugang()` returns `True` for `ist_demo` accounts unconditionally, *before* the `abo_pflicht` check. Don't remove this — a demo visitor must never see "Zahlung erforderlich" regardless of the operator's billing settings. (This was caught by testing, not designed in from the start — worth re-checking if `_hat_aktiven_zugang()` is ever refactored.) +- **Cannot send real email**: `POST /api/email/senden` and `/api/email/test` both return 403 for `ist_demo` accounts, so a demo visitor can never trigger outbound mail through the operator's real SMTP relay. + +**Auto-reset every 6 hours**, lazily rather than via a background thread/cron (this app has no task scheduler and stays that way — a lazy check fits the existing "one Flask process, no queue" architecture and can't miss a tick across restarts): `_demo_reset_faellig()` compares the `einstellungen` key `demo_reset_at` against `now`; `_demo_reset()` deletes every patient owned by the demo account (cascades to antraege/leistungen/aufgaben/pflegetagebuch/dokumente via the existing `ON DELETE CASCADE` FKs — SQLite enforces this because `get_db()` sets `PRAGMA foreign_keys = ON`), then reseeds one fictional pre-filled patient (`_demo_seed()`: "Grete Musterfrau", Pflegegrad 3, one Antrag, two Leistungen, two Aufgaben, one Pflegetagebuch-Eintrag) and bumps `demo_reset_at`. The check/reset call happens in two places — `api_auth_login()` (fresh state at the start of every demo session) and `global_auth_check()` (catches a session that's still open when the 6h boundary passes mid-visit) — both call the same `_demo_reset_faellig()`/`_demo_reset()` pair, so there's one source of truth for "is a reset due." + +The demo account can create up to 2 more patients itself (same 3-per-account cap as any `nutzer` account) via the normal interview flow — nothing special needed there, it's just an ordinary account under the hood. + +Frontend: `#demo-badge` in the topbar (toggled in `initApp()` from `me.ist_demo`) makes it visually obvious when a session is in demo mode. Login screen has a dedicated "Demo ausprobieren" button (`doDemoLogin()`) that fills the credentials and reuses `doLogin()` — no separate login code path. + ## Known constraints worth knowing before touching auth/security-sensitive code - `app.secret_key` in `app.py` is a hardcoded string, not loaded from an environment variable. diff --git a/open.md b/open.md new file mode 100644 index 0000000..ba65fe7 --- /dev/null +++ b/open.md @@ -0,0 +1,37 @@ +offene Aufgaben: sortiere die Aufgaben nach korrekter Reihenfolge, schreibe nach dieser zeile um für KI-Lesbarkeit, fertige aufgaben durchstreichen und als erledigt markieren. + +Reihenfolge unten nach Abhängigkeit/Aufwand sortiert (nicht nach ursprünglicher Nummerierung). Punkt "Docker" wurde in zwei getrennte Aufgaben aufgeteilt, da "in Docker packen" und "Migration zu React+Postgres" völlig unterschiedlicher Umfang sind und nicht als ein Task behandelt werden sollten. + +- [x] ~~**1. Demo-Login für Vorführungen**~~ *(erledigt)* + - ~~Eigener Login, zeigt eine erfundene/fiktive Person als "Familienmitglied"~~ + - ~~Nutzer kann im Demo-Modus eine Test-Person anlegen~~ + - ~~Demo-Inhalte müssen komplett vorausgefüllt sein (nicht leer)~~ + - ~~Demo-Datenbestand setzt sich automatisch alle 6 Stunden zurück~~ + - Umsetzung: `nutzer.ist_demo`-Konto "demo"/"demo", "Demo ausprobieren"-Button auf dem Login-Screen, "Demo-Modus"-Badge in der Topbar, vorausgefüllte fiktive Patientin "Grete Musterfrau" (Antrag, 2 Leistungen, 2 Aufgaben, Pflegetagebuch), Lazy-Reset alle 6h bei Login/Request (kein Cron/Thread nötig), E-Mail-Versand im Demo-Konto gesperrt (403), Demo-Konto von der Abo-Zahlungspflicht ausgenommen. Details siehe CLAUDE.md. + +- [ ] **2. Docker-Containerisierung der aktuellen App (Flask + SQLite, kein Rewrite)** + - App als Docker-Image/Compose-Setup lauffähig machen, so wie sie heute ist + - Isolierung zwischen App-Container und Datenbank (getrennte Services/Volumes) + - Keine Secrets/Env-Werte in der docker-compose.yml selbst — eigene .env-Datei dafür (keine .env.example nötig, Solo-Projekt) + - Ports müssen über Variablen konfigurierbar sein, nicht hart codiert + +- [ ] **3. Update-Benachrichtigung / Changelog-System** + - Nach dem ersten Login nach einem Update: kurzer anklickbarer Hinweis, was sich geändert hat + - Ein Klick auf "Gelesen" reicht, um den Hinweis zu schließen + - Optional: dauerhaftes Icon in der Sidebar, um alle vergangenen Changelogs als Historie nachzulesen + - Setzt eine einfache Versionierung des Deployments voraus (siehe Punkt 4 unten), damit die App weiß, "was ist neu seit dem letzten Login" + +- [ ] **4. ⚠️ Separates Grossvorhaben: Migration zu React + PostgreSQL** + - Vollständiger Technologiewechsel weg von Flask/vanilla-JS/SQLite — deutlich grösserer Umfang als die Punkte oben, keine Nebenbei-Aufgabe + - Braucht eine eigene Versionierungs-/Update-Strategie, da die App online ist und nicht für immer im jetzigen Stack bleiben wird + - Bevor hier irgendetwas beginnt: eigene Planungsrunde nötig (Umfang, Reihenfolge der Migration, ob schrittweise oder Neubau, Datenmigration aus der bestehenden SQLite-DB) + + + + + + + + + + diff --git a/pflegepilot_alpha_v2/pflegepilot/app.py b/pflegepilot_alpha_v2/pflegepilot/app.py index 9d64bac..a6a46d8 100644 --- a/pflegepilot_alpha_v2/pflegepilot/app.py +++ b/pflegepilot_alpha_v2/pflegepilot/app.py @@ -62,6 +62,7 @@ def init_db(): "ALTER TABLE patienten ADD COLUMN nutzer_id INTEGER REFERENCES nutzer(id)", "ALTER TABLE nutzer ADD COLUMN abo_bis TEXT", "ALTER TABLE nutzer ADD COLUMN abo_typ TEXT", + "ALTER TABLE nutzer ADD COLUMN ist_demo INTEGER DEFAULT 0", """CREATE TABLE IF NOT EXISTS admin_audit_log ( id INTEGER PRIMARY KEY AUTOINCREMENT, admin_id INTEGER, @@ -115,6 +116,16 @@ def init_db(): ("admin", generate_password_hash("admin"), "Administrator", "admin") ) db.commit() + # Demo-Konto anlegen, falls noch keins existiert (fuer Vorfuehrungen - + # eigener Nutzer, ganz normal durch die bestehende Isolation gedeckt) + if not db.execute("SELECT id FROM nutzer WHERE benutzername='demo'").fetchone(): + db.execute( + "INSERT INTO nutzer (benutzername, passwort_hash, name, rolle, ist_demo) VALUES (?,?,?,?,1)", + ("demo", generate_password_hash("demo"), "Demo-Konto", "nutzer") + ) + db.commit() + if _demo_reset_faellig(): + _demo_reset() # ─── Settings helper ───────────────────────────────────────────────────────── def get_setting(key, default=None): @@ -131,7 +142,7 @@ def _get_current_user(): return None try: return get_db().execute( - "SELECT id, benutzername, name, rolle, abo_bis, abo_typ FROM nutzer WHERE id=? AND aktiv=1", (uid,) + "SELECT id, benutzername, name, rolle, abo_bis, abo_typ, ist_demo FROM nutzer WHERE id=? AND aktiv=1", (uid,) ).fetchone() except Exception: return None @@ -215,6 +226,8 @@ def _hat_aktiven_zugang(u): return False if u["rolle"] == "admin": return True + if u["ist_demo"]: + return True # Demo-Konto ist immer nutzbar, unabhaengig von der Zahlungspflicht if not _abo_pflicht_aktiv(): return True abo_bis = u["abo_bis"] if "abo_bis" in u.keys() else None @@ -234,6 +247,74 @@ def _add_monate(d, monate): tag = min(d.day, tage_im_monat[monat - 1]) return date(jahr, monat, tag) +# ─── Demo-Konto: automatischer Reset alle 6 Stunden ────────────────────────── +# Kein Background-Thread/Scheduler noetig - wird "lazy" bei jedem Login bzw. +# jedem Request des Demo-Kontos geprueft. Passt zum Rest der App (ein Prozess, +# keine Task-Queue) und ist robust gegen Server-Neustarts (kein verpasster Tick). +DEMO_RESET_INTERVAL_STUNDEN = 6 + +def _demo_reset_faellig(): + letzter = get_setting("demo_reset_at") + if not letzter: + return True + try: + vergangen = (datetime.now() - datetime.strptime(letzter, "%Y-%m-%d %H:%M:%S")).total_seconds() + return vergangen > DEMO_RESET_INTERVAL_STUNDEN * 3600 + except Exception: + return True + +def _demo_seed(db, demo_uid): + heute = date.today() + cur = db.execute(""" + INSERT INTO patienten (vorname,nachname,geburtsdatum,strasse,plz,ort, + telefon,email,krankenkasse,versichertennummer,versicherungsart, + pflegegrad,pflegeperson,zielgruppe,notizen,nutzer_id) + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + """, ("Grete", "Musterfrau", "1946-04-12", "Beispielweg 3", "80331", "München", + "089/0000000", "", "AOK Bayern", "D999888777", "GKV", + 3, "Tochter (privat)", "alterspflege", + "Demo-Patientin – wird automatisch alle 6 Stunden zurückgesetzt.", demo_uid)) + pid = cur.lastrowid + db.execute(""" + INSERT INTO antraege (patient_id,typ,status,antragsdatum,bescheid_datum, + beantragter_pflegegrad,zugeteilter_pflegegrad,notizen) + VALUES (?,?,?,?,?,?,?,?) + """, (pid, "erstantrag", "genehmigt", + (heute - timedelta(days=60)).isoformat(), (heute - timedelta(days=20)).isoformat(), + 3, 3, "Demo-Antrag – Erstantrag genehmigt")) + db.execute("""INSERT INTO leistungen (patient_id,typ,bezeichnung,betrag,einheit,aktiv,seit,notizen) + VALUES (?,?,?,?,?,1,?,?)""", + (pid, "pflegegeld", "Pflegegeld Grad 3", 573, "monatlich", + (heute - timedelta(days=20)).isoformat(), "573 €")) + db.execute("""INSERT INTO leistungen (patient_id,typ,bezeichnung,betrag,einheit,aktiv,seit,notizen) + VALUES (?,?,?,?,?,1,?,?)""", + (pid, "entlastung", "Entlastungsbetrag", 131, "monatlich", + (heute - timedelta(days=20)).isoformat(), "131 €")) + db.execute("""INSERT INTO aufgaben (patient_id,titel,beschreibung,prioritaet,faellig_am) + VALUES (?,?,?,?,?)""", + (pid, "Pflegetagebuch heute ausfüllen", "Demo-Aufgabe", "hoch", heute.isoformat())) + db.execute("""INSERT INTO aufgaben (patient_id,titel,beschreibung,prioritaet,faellig_am) + VALUES (?,?,?,?,?)""", + (pid, "Entlastungsbetrag abrechnen", "Demo-Aufgabe", "normal", (heute + timedelta(days=5)).isoformat())) + db.execute("""INSERT INTO pflegetagebuch (patient_id,datum,koerperpflege,mobilitaet,allgemein) + VALUES (?,?,?,?,?)""", + (pid, (heute - timedelta(days=1)).isoformat(), "Hilfe beim Waschen benötigt", + "Rollator im Innenbereich", "Guter Tag, freundliche Stimmung")) + db.commit() + return pid + +def _demo_reset(): + db = get_db() + demo = db.execute("SELECT id FROM nutzer WHERE benutzername='demo'").fetchone() + if not demo: + return + db.execute("DELETE FROM patienten WHERE nutzer_id=?", (demo["id"],)) # Kaskade raeumt Antraege/Leistungen/Aufgaben/Tagebuch/Dokumente mit auf + db.commit() + _demo_seed(db, demo["id"]) + db.execute("INSERT OR REPLACE INTO einstellungen (schluessel, wert) VALUES ('demo_reset_at', ?)", + (datetime.now().strftime("%Y-%m-%d %H:%M:%S"),)) + db.commit() + def login_required(f): @functools.wraps(f) def decorated(*args, **kwargs): @@ -262,6 +343,8 @@ def global_auth_check(): u = _get_current_user() if not u: return jsonify({"error": "Nicht angemeldet"}), 401 + if u["ist_demo"] and _demo_reset_faellig(): + _demo_reset() # Abo-Gate: nur relevant, solange abo_pflicht aktiv ist (siehe _hat_aktiven_zugang). # Auth/Abo-Endpunkte bleiben immer erreichbar, damit man Status sehen und # (künftig) bezahlen kann, auch wenn der Zugang gerade gesperrt ist. @@ -291,7 +374,7 @@ def api_auth_me(): if not u: return jsonify({"error": "Nicht angemeldet"}), 401 return jsonify({"id": u["id"], "benutzername": u["benutzername"], - "name": u["name"] or u["benutzername"], "rolle": u["rolle"]}) + "name": u["name"] or u["benutzername"], "rolle": u["rolle"], "ist_demo": bool(u["ist_demo"])}) @app.route("/api/auth/login", methods=["POST"]) def api_auth_login(): @@ -304,7 +387,9 @@ def api_auth_login(): if not u or not check_password_hash(u["passwort_hash"], passwort): return jsonify({"error": "Ungültige Zugangsdaten"}), 401 session["nutzer_id"] = u["id"] - return jsonify({"ok": True, "name": u["name"] or u["benutzername"], "rolle": u["rolle"]}) + if u["ist_demo"] and _demo_reset_faellig(): + _demo_reset() + return jsonify({"ok": True, "name": u["name"] or u["benutzername"], "rolle": u["rolle"], "ist_demo": bool(u["ist_demo"])}) @app.route("/api/auth/logout", methods=["POST"]) def api_auth_logout(): @@ -1182,6 +1267,9 @@ def _smtp_send(to, subject, body, pdf_base64="", pdf_dateiname="Dokument.pdf"): @app.route("/api/email/senden", methods=["POST"]) def api_email_senden(): + u = _get_current_user() + if u and u["ist_demo"]: + return jsonify({"error": "E-Mail-Versand ist im Demo-Konto nicht verfügbar."}), 403 d = request.json or {} empfaenger = (d.get("empfaenger") or "").strip() betreff = d.get("betreff") or "Nachricht von Pflegepilot" @@ -1204,6 +1292,9 @@ def api_email_senden(): @app.route("/api/email/test", methods=["POST"]) def api_email_test(): + u = _get_current_user() + if u and u["ist_demo"]: + return jsonify({"error": "E-Mail-Versand ist im Demo-Konto nicht verfügbar."}), 403 try: c = _smtp_cfg() if not c["server"] or not c["user"]: diff --git a/pflegepilot_alpha_v2/pflegepilot/templates/index.html b/pflegepilot_alpha_v2/pflegepilot/templates/index.html index 3ba28d2..5f9e5be 100644 --- a/pflegepilot_alpha_v2/pflegepilot/templates/index.html +++ b/pflegepilot_alpha_v2/pflegepilot/templates/index.html @@ -387,6 +387,7 @@ textarea{resize:vertical;min-height:80px}
+
Standard-Zugangsdaten: admin / admin
Bitte nach dem ersten Login ändern.
@@ -433,6 +434,7 @@ textarea{resize:vertical;min-height:80px}
Dashboard
+
Lade…
@@ -1153,6 +1155,7 @@ async function initApp(){ if(uw){uw.style.display='flex';} const un=document.getElementById('sb-user-name');if(un)un.textContent=me.name||me.benutzername; const ur=document.getElementById('sb-user-role');if(ur)ur.textContent=me.rolle==='admin'?'Administrator':'Nutzer'; + document.getElementById('demo-badge')?.classList.toggle('hidden',!me.ist_demo); // Admin-nav nur für admin sichtbar const adm=document.querySelector('.sb-admin'); if(adm)adm.style.display=me.rolle==='admin'?'':'none'; @@ -1184,6 +1187,11 @@ async function doLogin(){ if(err)err.textContent=r.error||'Anmeldung fehlgeschlagen'; } } +async function doDemoLogin(){ + document.getElementById('lo-user').value='demo'; + document.getElementById('lo-pw').value='demo'; + await doLogin(); +} async function doLogout(){ await fetch('/api/auth/logout',{method:'POST'}); curUser=null;