Sprint 15: Suche, Ausweis, Teilen, Widget

- Volltext-Suche im Tagebuch (LIKE über Titel/Text/Tags, Debounce 350ms)
- Digitaler Heimtierausweis als druckbare HTML-Seite (/ausweis/{dog_id})
  Enthält Impfungen, Medikamente, Allergien, Tierärzte, Chip-Nr.
- Hund teilen: Einladungslink-System (dog_shares-Tabelle, /teilen/{token})
  Geteilte Hunde erscheinen in der Hundeliste, Tagebuch/Gesundheit lesbar
- Widget-Seite /#widget: zufälliges Tagebuchbild + nächste Erinnerung
  Als PWA-Shortcut im Manifest verankert
- SW-Cache by-v144, APP_VER 117

backend/routes/diary.py

@@ -33,9 +33,17 @@ class DiaryUpdate(BaseModel):
 
 
 def _own_dog(dog_id: int, user_id: int, conn):
+    """Eigener Hund ODER geteilter Hund (angenommene Einladung)."""
     dog = conn.execute(
         "SELECT id FROM dogs WHERE id=? AND user_id=?", (dog_id, user_id)
     ).fetchone()
+    if not dog:
+        dog = conn.execute(
+            """SELECT d.id FROM dogs d
+               JOIN dog_shares ds ON ds.dog_id = d.id
+               WHERE d.id=? AND ds.shared_with_id=? AND ds.accepted_at IS NOT NULL""",
+            (dog_id, user_id)
+        ).fetchone()
     if not dog:
         raise HTTPException(404, "Hund nicht gefunden.")
     return dog
@@ -82,18 +90,30 @@ def _entry_dict(row, dog_ids_map: dict) -> dict:
 
 @router.get("/{dog_id}/diary")
 async def list_diary(dog_id: int, limit: int = 20, offset: int = 0,
+                     q: Optional[str] = None,
                      user=Depends(get_current_user)):
     with db() as conn:
         _own_dog(dog_id, user["id"], conn)
-        # Einträge des primären Hundes SOWIE Einträge wo der Hund als weiterer zugeordnet ist
-        rows = conn.execute(
-            """SELECT DISTINCT d.* FROM diary d
-               LEFT JOIN diary_dogs dd ON dd.diary_id = d.id
-               WHERE d.dog_id = ? OR dd.dog_id = ?
-               ORDER BY d.datum DESC, d.created_at DESC
-               LIMIT ? OFFSET ?""",
-            (dog_id, dog_id, limit, offset)
-        ).fetchall()
+        if q:
+            pattern = f"%{q}%"
+            rows = conn.execute(
+                """SELECT DISTINCT d.* FROM diary d
+                   LEFT JOIN diary_dogs dd ON dd.diary_id = d.id
+                   WHERE (d.dog_id = ? OR dd.dog_id = ?)
+                     AND (d.titel LIKE ? OR d.text LIKE ? OR d.tags LIKE ?)
+                   ORDER BY d.datum DESC, d.created_at DESC
+                   LIMIT ? OFFSET ?""",
+                (dog_id, dog_id, pattern, pattern, pattern, limit, offset)
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                """SELECT DISTINCT d.* FROM diary d
+                   LEFT JOIN diary_dogs dd ON dd.diary_id = d.id
+                   WHERE d.dog_id = ? OR dd.dog_id = ?
+                   ORDER BY d.datum DESC, d.created_at DESC
+                   LIMIT ? OFFSET ?""",
+                (dog_id, dog_id, limit, offset)
+            ).fetchall()
         ids = [r["id"] for r in rows]
         dogs_map = _fetch_dog_ids(conn, ids)
 

backend/routes/dogs.py

@@ -38,10 +38,19 @@ class DogUpdate(BaseModel):
 @router.get("")
 async def list_dogs(user=Depends(get_current_user)):
     with db() as conn:
-        rows = conn.execute(
-            "SELECT * FROM dogs WHERE user_id=? ORDER BY id", (user["id"],)
+        own = conn.execute(
+            "SELECT *, NULL AS shared_by, NULL AS share_role FROM dogs WHERE user_id=? ORDER BY id",
+            (user["id"],)
         ).fetchall()
-    return [dict(r) for r in rows]
+        shared = conn.execute(
+            """SELECT d.*, u.name AS shared_by, ds.role AS share_role
+               FROM dog_shares ds
+               JOIN dogs d ON d.id = ds.dog_id
+               JOIN users u ON u.id = ds.owner_id
+               WHERE ds.shared_with_id = ? AND ds.accepted_at IS NOT NULL""",
+            (user["id"],)
+        ).fetchall()
+    return [dict(r) for r in own] + [dict(r) for r in shared]
 
 
 @router.post("")

backend/routes/sharing.py

@@ -0,0 +1,141 @@
+"""BAN YARO — Hund teilen (Familie/Partner)"""
+
+import secrets
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from database import db
+from auth import get_current_user
+
+# Hunde-spezifische Routen  →  eingebunden unter /api/dogs
+dog_router = APIRouter()
+
+# Token-basierte Routen  →  eingebunden unter /api/share
+share_router = APIRouter()
+
+
+class ShareInvite(BaseModel):
+    role: str = "editor"   # viewer | editor
+
+
+# ------------------------------------------------------------------
+# POST /api/dogs/{dog_id}/share  →  Einladungs-Link erzeugen
+# ------------------------------------------------------------------
+@dog_router.post("/{dog_id}/share", status_code=201)
+async def create_share(dog_id: int, data: ShareInvite,
+                       user=Depends(get_current_user)):
+    if data.role not in ("viewer", "editor"):
+        raise HTTPException(400, "Rolle muss 'viewer' oder 'editor' sein.")
+
+    with db() as conn:
+        dog = conn.execute(
+            "SELECT id, name FROM dogs WHERE id=? AND user_id=?",
+            (dog_id, user["id"])
+        ).fetchone()
+        if not dog:
+            raise HTTPException(404, "Hund nicht gefunden.")
+
+        token = secrets.token_urlsafe(24)
+        conn.execute(
+            """INSERT INTO dog_shares (dog_id, owner_id, invite_token, role)
+               VALUES (?, ?, ?, ?)""",
+            (dog_id, user["id"], token, data.role),
+        )
+    return {"token": token, "invite_path": f"/teilen/{token}"}
+
+
+# ------------------------------------------------------------------
+# GET /api/dogs/{dog_id}/shares  →  aktive Einladungen auflisten
+# ------------------------------------------------------------------
+@dog_router.get("/{dog_id}/shares")
+async def list_shares(dog_id: int, user=Depends(get_current_user)):
+    with db() as conn:
+        dog = conn.execute(
+            "SELECT id FROM dogs WHERE id=? AND user_id=?",
+            (dog_id, user["id"])
+        ).fetchone()
+        if not dog:
+            raise HTTPException(404, "Nicht gefunden.")
+        rows = conn.execute(
+            """SELECT ds.id, ds.invite_token, ds.role, ds.accepted_at,
+                      u.name AS shared_with_name, u.email AS shared_with_email
+               FROM dog_shares ds
+               LEFT JOIN users u ON u.id = ds.shared_with_id
+               WHERE ds.dog_id = ?
+               ORDER BY ds.created_at DESC""",
+            (dog_id,)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ------------------------------------------------------------------
+# DELETE /api/dogs/{dog_id}/share/{share_id}  →  Freigabe widerrufen
+# ------------------------------------------------------------------
+@dog_router.delete("/{dog_id}/share/{share_id}", status_code=204)
+async def revoke_share(dog_id: int, share_id: int,
+                       user=Depends(get_current_user)):
+    with db() as conn:
+        dog = conn.execute(
+            "SELECT id FROM dogs WHERE id=? AND user_id=?",
+            (dog_id, user["id"])
+        ).fetchone()
+        if not dog:
+            raise HTTPException(404, "Nicht gefunden.")
+        conn.execute(
+            "DELETE FROM dog_shares WHERE id=? AND dog_id=?",
+            (share_id, dog_id)
+        )
+
+
+# ------------------------------------------------------------------
+# POST /api/share/accept/{token}  →  Einladung annehmen
+# ------------------------------------------------------------------
+@share_router.post("/accept/{token}")
+async def accept_share(token: str, user=Depends(get_current_user)):
+    with db() as conn:
+        share = conn.execute(
+            """SELECT ds.*, d.name AS dog_name, u.name AS owner_name
+               FROM dog_shares ds
+               JOIN dogs d ON d.id = ds.dog_id
+               JOIN users u ON u.id = ds.owner_id
+               WHERE ds.invite_token = ?""",
+            (token,)
+        ).fetchone()
+
+        if not share:
+            raise HTTPException(404, "Einladungslink ungültig oder abgelaufen.")
+        if share["owner_id"] == user["id"]:
+            raise HTTPException(400, "Das ist dein eigener Hund.")
+        if share["accepted_at"]:
+            return {"message": "Bereits angenommen.", "dog_name": share["dog_name"]}
+
+        conn.execute(
+            """UPDATE dog_shares
+               SET shared_with_id = ?, accepted_at = datetime('now')
+               WHERE invite_token = ?""",
+            (user["id"], token),
+        )
+    return {
+        "message":    "Einladung angenommen!",
+        "dog_name":   share["dog_name"],
+        "owner_name": share["owner_name"],
+    }
+
+
+# ------------------------------------------------------------------
+# GET /api/share/info/{token}  →  Info vor dem Annehmen (kein Auth nötig)
+# ------------------------------------------------------------------
+@share_router.get("/info/{token}")
+async def share_info(token: str):
+    with db() as conn:
+        share = conn.execute(
+            """SELECT d.name AS dog_name, d.foto_url, d.rasse,
+                      u.name AS owner_name, ds.role, ds.accepted_at
+               FROM dog_shares ds
+               JOIN dogs d ON d.id = ds.dog_id
+               JOIN users u ON u.id = ds.owner_id
+               WHERE ds.invite_token = ?""",
+            (token,)
+        ).fetchone()
+    if not share:
+        raise HTTPException(404, "Einladungslink ungültig.")
+    return dict(share)

backend/routes/widget.py

@@ -0,0 +1,56 @@
+"""BAN YARO — Widget-Snapshot Endpoint"""
+
+import json, random
+from fastapi import APIRouter, Depends
+from database import db
+from auth import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/snapshot")
+async def widget_snapshot(user=Depends(get_current_user)):
+    """Liefert kompakte Widget-Daten: Hund, nächste Erinnerung, zufälliges Tagebuchbild."""
+    with db() as conn:
+        # Aktiver Hund (erster oder letzter genutzter)
+        dog = conn.execute(
+            "SELECT id, name, rasse, foto_url FROM dogs WHERE user_id=? ORDER BY id LIMIT 1",
+            (user["id"],)
+        ).fetchone()
+
+        if not dog:
+            return {"dog": None}
+
+        dog_id = dog["id"]
+
+        # Nächste fällige Erinnerung
+        reminder = conn.execute(
+            """SELECT bezeichnung, naechstes, typ FROM health
+               WHERE dog_id=? AND naechstes IS NOT NULL AND naechstes >= date('now')
+               ORDER BY naechstes ASC LIMIT 1""",
+            (dog_id,)
+        ).fetchone()
+
+        # Zufälliges Tagebuchbild (letzte 50 Einträge mit Bild)
+        photos = conn.execute(
+            """SELECT media_url, titel, datum FROM diary
+               WHERE dog_id=? AND media_url IS NOT NULL
+               ORDER BY datum DESC LIMIT 50""",
+            (dog_id,)
+        ).fetchall()
+
+        random_photo = dict(random.choice(photos)) if photos else None
+
+        # Anzahl überfälliger Erinnerungen
+        overdue = conn.execute(
+            """SELECT COUNT(*) as n FROM health
+               WHERE dog_id=? AND naechstes IS NOT NULL AND naechstes < date('now')""",
+            (dog_id,)
+        ).fetchone()["n"]
+
+    return {
+        "dog":          dict(dog),
+        "reminder":     dict(reminder) if reminder else None,
+        "random_photo": random_photo,
+        "overdue":      overdue,
+    }