feat(family): deploy Single-Writer DuckDB backend, Mila parent cockpit & feeding analytics, and Moritz macro tracker

2026-10-17 07:21:49 +02:00
parent ef50d87bd7
commit 5b8432caf4
96 changed files with 16409 additions and 29 deletions
@@ -0,0 +1 @@
+# routes package
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+
+from app.engine import DuckDBEngine
+
+router = APIRouter(tags=["Dashboards"])
+
+
+def get_engine(request: Request) -> DuckDBEngine:
+    return request.app.state.engine
+
+
+@router.get("/mila/dashboard")
+async def get_mila_dashboard(
+    as_of: Optional[str] = Query(default=None, description="Optional target date YYYY-MM-DD"),
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.get_mila_dashboard(as_of_date=as_of)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/moritz/dashboard")
+async def get_moritz_dashboard(
+    as_of: Optional[str] = Query(default=None, description="Optional target date YYYY-MM-DD"),
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.get_moritz_dashboard(as_of_date=as_of)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/mila/day/{date}")
+async def get_mila_day_detail(
+    date: str,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.get_mila_day_detail(target_date=date)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/moritz/day/{date}")
+async def get_moritz_day_detail(
+    date: str,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.get_moritz_day_detail(target_date=date)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/summary/{subject}")
+async def get_summary(
+    subject: str,
+    date: Optional[str] = Query(default=None, description="Target date YYYY-MM-DD"),
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.get_summary(subject=subject, date_str=date)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
@@ -0,0 +1,51 @@
+from typing import Any, Dict, List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+
+from app.engine import DuckDBEngine
+from app.models import EntityPutRequest
+
+router = APIRouter(tags=["Entities"])
+
+
+def get_engine(request: Request) -> DuckDBEngine:
+    return request.app.state.engine
+
+
+@router.post("/entities")
+async def put_entity(
+    req: EntityPutRequest,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.put_entity(req)
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/entities/{collection}")
+async def list_entities(
+    collection: str,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> List[Dict[str, Any]]:
+    try:
+        return engine.list_entities(collection=collection)
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/places/near")
+async def find_places_near(
+    lat: float = Query(..., description="Latitude"),
+    lon: float = Query(..., description="Longitude"),
+    radius_m: float = Query(default=1000.0, description="Radius in meters"),
+    category: Optional[str] = Query(default=None, description="Category filter"),
+    engine: DuckDBEngine = Depends(get_engine),
+) -> List[Dict[str, Any]]:
+    try:
+        return engine.find_places_near(lat=lat, lon=lon, radius_m=radius_m, category=category)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+from fastapi import APIRouter, Depends, HTTPException, Request
+
+from app.engine import DuckDBEngine
+from app.models import EventCreateRequest, EventStopRequest, GarminSyncRequest
+
+router = APIRouter(tags=["Events"])
+
+
+def get_engine(request: Request) -> DuckDBEngine:
+    return request.app.state.engine
+
+
+@router.post("/events")
+async def add_event(
+    req: EventCreateRequest,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.add_event(req)
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/events/stop")
+async def stop_event(
+    req: EventStopRequest,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.stop_event(req)
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/events/{event_id}")
+async def delete_event(
+    event_id: str,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.delete_event(event_id)
+    except ValueError as ve:
+        raise HTTPException(status_code=404, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/garmin/sync")
+async def sync_garmin(
+    req: GarminSyncRequest,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    try:
+        return engine.sync_garmin(req)
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import time
+from fastapi import APIRouter, Depends, HTTPException, Request
+
+from app.engine import DuckDBEngine
+from app.models import QueryRequest, QueryResponse
+
+router = APIRouter(tags=["Generic Queries"])
+
+
+def get_engine(request: Request) -> DuckDBEngine:
+    return request.app.state.engine
+
+
+@router.post("/query", response_model=QueryResponse)
+async def execute_query(
+    req: QueryRequest,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> QueryResponse:
+    t0 = time.perf_counter()
+    try:
+        rows = engine.query(req.query, req.params)
+        duration_ms = round((time.perf_counter() - t0) * 1000, 2)
+        cols = list(rows[0].keys()) if rows else []
+        return QueryResponse(
+            columns=cols,
+            rows=rows,
+            count=len(rows),
+            execution_time_ms=duration_ms,
+        )
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+from fastapi import APIRouter, Depends, HTTPException, Request
+
+from app.config import DATA_DIR
+from app.engine import DuckDBEngine
+from app.git_sync import GitSyncManager
+from app.models import StatusResponse
+
+router = APIRouter(tags=["System"])
+
+
+def get_engine(request: Request) -> DuckDBEngine:
+    return request.app.state.engine
+
+
+def get_git_sync(request: Request) -> Optional[GitSyncManager]:
+    return getattr(request.app.state, "git_sync", None)
+
+
+@router.get("/healthz")
+async def healthz(
+    request: Request,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    git_sync: Optional[GitSyncManager] = get_git_sync(request)
+    conflict = git_sync.is_conflict if git_sync else False
+    status_str = "conflict" if conflict else "ok"
+    return {
+        "status": status_str,
+        "conflict": conflict,
+        "engine_ready": True,
+    }
+
+
+@router.get("/status", response_model=StatusResponse)
+async def status(
+    request: Request,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> StatusResponse:
+    git_sync: Optional[GitSyncManager] = get_git_sync(request)
+    counts = engine.get_table_counts()
+    return StatusResponse(
+        status=git_sync.status if git_sync else "ok",
+        git_conflict=git_sync.is_conflict if git_sync else False,
+        last_sync_time=git_sync.last_sync_time if git_sync else None,
+        last_commit_hash=git_sync.last_commit_hash if git_sync else None,
+        last_error=git_sync.last_error if git_sync else None,
+        data_dir=str(engine.data_dir),
+        table_counts=counts,
+    )
+
+
+@router.post("/git/sync")
+async def trigger_sync(
+    request: Request,
+    engine: DuckDBEngine = Depends(get_engine),
+) -> Dict[str, Any]:
+    git_sync: Optional[GitSyncManager] = get_git_sync(request)
+    if not git_sync:
+        raise HTTPException(status_code=400, detail="Git sync is not configured")
+
+    success = git_sync.pull_rebase()
+    if success:
+        engine.reload_all()
+        return {
+            "status": "ok",
+            "message": "Git pull --rebase completed and DuckDB reloaded.",
+            "commit": git_sync.last_commit_hash,
+        }
+    else:
+        return {
+            "status": git_sync.status,
+            "conflict": git_sync.is_conflict,
+            "error": git_sync.last_error,
+        }