feat: Notruf mit Kontaktdaten + Geoposition anreichern (Backend, Phase 1+3)

Notruf-Meldungen tragen jetzt das Notfall-Profil der auslösenden Person und —
falls vom Gerät mitgeschickt — die Geoposition. Kanal-Rollen:
- E-Mail: Voll-Dossier (Name, Adresse, Telefone, Geburtsdatum, med. Hinweise,
  Koordinaten + Karten-Link + Genauigkeit + Zeit; sonst "nicht verfügbar")
- SMS: kompakt, Name + Adresse + Karten-Link
- Anruf (TTS): Name + Wohnadresse gesprochen, KEINE URL/Koordinaten, Verweis
  auf SMS/E-Mail

- schemas: GeoFix + EmergencyRequest.geo; AdminUserPrefsUpdate um Profilfelder
  erweitert (full_name, Adresse, Telefone, birth_date, medical_notes,
  emergency_contacts/_phones, location_consent) — in user.prefs (keine Migration)
- api/chat: geo an record_manual_emergency durchgereicht
- api/admin: list_users gibt Profilfelder mit zurück (für die spätere Admin-UI)
- emergency.py: _profile/_geo_fields/_maps_link/_location_block/_email_body,
  kanal-spezifische _emergency_texts; record_manual_emergency(..., geo=...)
- Tests: 9 neue (Profil-Injektion, SMS/Call/E-Mail-Texte, Geo→Map-Link,
  ohne-Geo-Fallback, Payload). Suite 237 grün.

Frontend (Phase 2: Browser-Geolocation beim 🆘 + Admin-Profil-UI) steht noch aus.

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

app/safety/emergency.py

@@ -9,6 +9,12 @@ Benachrichtigung von Kontaktpersonen über zwei unabhängige Kanäle (best effor
   ein JSON-POST mit Kanälen, Telefonnummern und fertigen SMS-/Anruf-Texten; den
   konkreten Gateway (Twilio, seven.io, …) verdrahtet der Empfänger dahinter.
 
+Die Meldungen werden mit den Profildaten der auslösenden Person (Name, Adresse,
+Telefon, med. Hinweise) und — falls vom Gerät mitgeschickt — der Geoposition
+angereichert. Kanal-Rollen: die E-Mail trägt das Voll-Dossier, die SMS den
+Karten-Link, der Anruf nennt Name + Wohnadresse gesprochen und verweist für den
+genauen Standort auf SMS/E-Mail (Koordinaten werden NICHT vorgelesen).
+
 Ohne SMTP-Host und ohne Webhook-URL wird nichts versendet und der Nutzer erhält
 einen klaren Hinweis darauf.
 """
@@ -66,6 +72,117 @@ def _csv(raw: str | None) -> list[str]:
     return [v.strip() for v in (raw or "").replace(";", ",").split(",") if v.strip()]
 
 
+# --- Profil & Standort -----------------------------------------------------
+
+def _profile(user) -> dict:
+    """Liest die Notfall-Profildaten der Person aus user.prefs (mit Fallbacks)."""
+    prefs = getattr(user, "prefs", None)
+    prefs = prefs if isinstance(prefs, dict) else {}
+
+    def g(key: str) -> str:
+        v = prefs.get(key)
+        return v.strip() if isinstance(v, str) else ""
+
+    name = g("full_name") or getattr(user, "display_name", "") or getattr(user, "id", "?")
+    street, postal, city = g("street"), g("postal_code"), g("city")
+    city_line = " ".join(p for p in (postal, city) if p)
+    address_short = ", ".join(p for p in (street, city_line) if p)
+    return {
+        "name": name,
+        "street": street,
+        "postal_code": postal,
+        "city": city,
+        "address_short": address_short,
+        "phone_landline": g("phone_landline"),
+        "phone_mobile": g("phone_mobile"),
+        "birth_date": g("birth_date"),
+        "medical_notes": g("medical_notes"),
+    }
+
+
+def _geo_fields(geo) -> dict | None:
+    """Normalisiert die Geoposition (pydantic-Model ODER dict) auf {lat,lon,accuracy,ts}.
+
+    Liefert None, wenn keine brauchbaren Koordinaten vorliegen.
+    """
+    if geo is None:
+        return None
+    if isinstance(geo, dict):
+        d = geo
+    else:
+        d = {k: getattr(geo, k, None) for k in ("lat", "lon", "accuracy", "ts")}
+    if d.get("lat") is None or d.get("lon") is None:
+        return None
+    return {"lat": d["lat"], "lon": d["lon"], "accuracy": d.get("accuracy"), "ts": d.get("ts")}
+
+
+def _maps_link(lat, lon) -> str:
+    return f"https://www.google.com/maps?q={lat},{lon}"
+
+
+def _location_block(geo) -> str:
+    """Mehrzeiliger Standort-Block für die E-Mail (oder klarer 'nicht verfügbar'-Hinweis)."""
+    g = _geo_fields(geo)
+    if not g:
+        return "Standort (Gerät): nicht verfügbar (kein GPS / keine Freigabe)."
+    lines = [
+        f"Standort (Gerät): {g['lat']:.6f}, {g['lon']:.6f}",
+        f"Karte: {_maps_link(g['lat'], g['lon'])}",
+    ]
+    if g.get("accuracy") is not None:
+        lines.append(f"Genauigkeit: ca. {round(g['accuracy'])} m")
+    if g.get("ts"):
+        lines.append(f"Zeitpunkt des Fixes: {g['ts']}")
+    return "\n".join(lines)
+
+
+def _emergency_texts(profile: dict, geo) -> dict[str, str]:
+    """Fertige Texte für SMS und Sprachanruf (vom Webhook-Empfänger genutzt)."""
+    name = profile["name"]
+    addr = profile["address_short"]
+    g = _geo_fields(geo)
+
+    # SMS: kompakt, mit Karten-Link (trägt den genauen Standort)
+    sms = f"NOTRUF: {name} braucht Hilfe."
+    if addr:
+        sms += f" Adresse: {addr}."
+    if g:
+        sms += f" Standort: {_maps_link(g['lat'], g['lon'])}"
+
+    # Anruf: gesprochen — Name + Wohnadresse, KEINE URL/Koordinaten, Verweis auf SMS/E-Mail
+    call = f"Achtung. {name} hat einen Notruf ausgelöst und braucht dringend Hilfe."
+    if addr:
+        call += f" Wohnadresse: {addr}."
+    call += " Genaue Standortdaten und weitere Details stehen in der SMS und der E-Mail."
+
+    return {"sms": sms, "call": call}
+
+
+def _email_body(profile: dict, geo) -> str:
+    """Voll-Dossier für die E-Mail: Angaben zur Person + Standort."""
+    lines = [
+        f"{profile['name']} hat in der Voice-Assistant-App einen Notruf ausgelöst.",
+        "",
+        "Bitte umgehend Kontakt aufnehmen.",
+        "",
+        "— Angaben zur Person —",
+    ]
+    fields = [
+        ("Adresse", profile["address_short"]),
+        ("Mobil", profile["phone_mobile"]),
+        ("Festnetz", profile["phone_landline"]),
+        ("Geburtsdatum", profile["birth_date"]),
+        ("Medizinische Hinweise", profile["medical_notes"]),
+    ]
+    info = [f"{label}: {value}" for label, value in fields if value]
+    lines.extend(info or ["(keine Profilangaben hinterlegt)"])
+    lines += ["", "— Standort —", _location_block(geo), "",
+              "(Diese Meldung wurde automatisch von der Voice-Assistant-App gesendet.)"]
+    return "\n".join(lines)
+
+
+# --- Versandkanäle ---------------------------------------------------------
+
 def _contacts(user, cfg) -> list[str]:
     """Kontakt-E-Mail(s): pro-Nutzer-Pref (CSV) falls vorhanden, sonst Default aus der Config."""
     prefs = getattr(user, "prefs", None) or {}
@@ -102,22 +219,7 @@ def _send_email_sync(to: list[str], subject: str, body: str, cfg) -> bool:
         return False
 
 
-def _emergency_texts(name: str) -> dict[str, str]:
-    """Fertige Texte für die SMS- und Sprachanruf-Kanäle (vom Webhook-Empfänger genutzt)."""
-    return {
-        "sms": (
-            f"NOTRUF: {name} hat in der Voice-Assistant-App Hilfe angefordert. "
-            f"Bitte sofort Kontakt aufnehmen."
-        ),
-        "call": (
-            f"Achtung. {name} hat über die Voice Assistant App einen Notruf ausgelöst. "
-            f"Bitte nehmen Sie umgehend Kontakt auf. "
-            f"Ich wiederhole: {name} braucht dringend Hilfe."
-        ),
-    }
-
-
-def _webhook_payload(user, language: str | None, phones: list[str], channels: list[str], name: str) -> dict:
+def _webhook_payload(user, language, phones, channels, profile, geo) -> dict:
     """Provider-agnostisches Notruf-Payload für den Eskalations-Webhook."""
     return {
         "event": "emergency",
@@ -125,10 +227,11 @@ def _webhook_payload(user, language: str | None, phones: list[str], channels: li
         "source": "voice-assistant",
         "timestamp": datetime.now(timezone.utc).isoformat(),
         "language": (language or "de"),
-        "user": {"id": getattr(user, "id", None), "name": name},
+        "user": {"id": getattr(user, "id", None), "name": profile["name"]},
         "channels": channels,
         "phones": phones,
-        "message": _emergency_texts(name),
+        "geo": _geo_fields(geo),
+        "message": _emergency_texts(profile, geo),
     }
 
 
@@ -148,21 +251,18 @@ async def _post_webhook(url: str, payload: dict, cfg) -> bool:
         return False
 
 
-async def record_manual_emergency(user, store, language: str | None = None, cfg=settings) -> dict:
+async def record_manual_emergency(user, store, language: str | None = None, geo=None, cfg=settings) -> dict:
     """Protokolliert einen bestätigten Notruf, benachrichtigt Kontakte und liefert den Hinweis."""
+    # Bewusst minimaler Log-Eintrag — KEINE Adresse/Koordinaten (Admin-Log bleibt unkritisch).
     store.log_emergency(user.id, "manual", "Vom Nutzer ausgelöster Notruf")
     metrics.inc("emergency_total", {"category": "manual", "source": "user"})
 
-    name = getattr(user, "display_name", None) or getattr(user, "id", "?")
+    profile = _profile(user)
 
-    # Kanal 1: E-Mail (SMTP)
+    # Kanal 1: E-Mail (SMTP) — Voll-Dossier
     to = _contacts(user, cfg)
-    subject = f"🆘 Notruf von {name}"
-    body = (
-        f"{name} hat in der Voice-Assistant-App einen Notruf ausgelöst.\n\n"
-        f"Bitte umgehend Kontakt aufnehmen.\n\n"
-        f"(Diese Meldung wurde automatisch von der Voice-Assistant-App gesendet.)"
-    )
+    subject = f"🆘 Notruf von {profile['name']}"
+    body = _email_body(profile, geo)
     email_sent = await asyncio.to_thread(_send_email_sync, to, subject, body, cfg)
     if email_sent:
         metrics.inc("emergency_notify_total", {"channel": "email"})
@@ -170,7 +270,7 @@ async def record_manual_emergency(user, store, language: str | None = None, cfg=
     # Kanal 2: SMS/Anruf (provider-agnostischer Webhook)
     phones = _phones(user, cfg)
     channels = _csv(cfg.emergency_webhook_channels)
-    payload = _webhook_payload(user, language, phones, channels, name)
+    payload = _webhook_payload(user, language, phones, channels, profile, geo)
     webhook_sent = await _post_webhook(cfg.emergency_webhook_url, payload, cfg)
     if webhook_sent:
         metrics.inc("emergency_notify_total", {"channel": "webhook"})