feat: integrate nudging

Author: lc-spxl

alembic/versions/001_initial_schema.py

@@ -48,6 +48,9 @@ def upgrade() -> None:
         sa.Column(
             "email_notifications", sa.Boolean(), nullable=False, server_default="false"
         ),
+        sa.Column(
+            "webpush_enabled", sa.Boolean(), nullable=False, server_default="false"
+        ),
         sa.Column(
             "created_at",
             sa.DateTime(timezone=True),

src/celine/webapp/api/deps.py

@@ -10,6 +10,7 @@
 from celine.sdk.auth import JwtUser
 from celine.sdk.auth.static import StaticTokenProvider
 from celine.sdk.dt import DTClient
+from celine.sdk.nudging.client import NudgingClient
 
 
 def get_user_from_request(request: Request) -> JwtUser:
@@ -60,6 +61,18 @@ def get_dt_client(request: Request) -> DTClient:
     )
 
 
+def get_nudging_client(request: Request) -> NudgingClient:
+    if not settings.nudging_api_url:
+        raise HTTPException(
+            status_code=503,
+            detail="Nudging API not configured",
+        )
+
+    raw_token = get_raw_token(request)
+
+    return NudgingClient(base_url=settings.nudging_api_url, default_token=raw_token)
+
+
 def get_client_ip(request: Request) -> str:
     """Extract client IP from request headers."""
     forwarded = request.headers.get("X-Forwarded-For")
@@ -75,3 +88,4 @@ def get_client_ip(request: Request) -> str:
 UserDep = Annotated[JwtUser, Depends(get_user_from_request)]
 DbDep = Annotated[AsyncSession, Depends(get_db)]
 DTDep = Annotated[DTClient, Depends(get_dt_client)]
+NudgingDep = Annotated[NudgingClient, Depends(get_nudging_client)]

src/celine/webapp/api/notifications.py

@@ -1,52 +1,36 @@
 """Notification-related API routes."""
 
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any
-from fastapi import APIRouter, Request, HTTPException
-from sqlalchemy import select, desc, delete
+import asyncio
+from fastapi import APIRouter, HTTPException
+from sqlalchemy import select
 
-from celine.webapp.api.deps import UserDep, DbDep
+from celine.webapp.api.deps import NudgingDep, UserDep, DbDep
 from celine.webapp.api.schemas import (
     NotificationItem,
+    PushSubscriptionPayload,
+    PushSubscriptionUnsubscribePayload,
     VapidKeyResponse,
-    WebPushUnsubscribeRequest,
     SuccessResponse,
 )
-from celine.webapp.db import WebPushSubscription
-from celine.webapp.settings import settings as app_settings
+from celine.webapp.db.user_settings import update_user_settings
 
+from celine.sdk.openapi.nudging.models import (
+    SubscribeRequest,
+    WebPushSubscriptionIn,
+    WebPushKeysIn,
+    UnsubscribeRequest,
+)
 
 router = APIRouter(prefix="/api/notifications", tags=["notifications"])
 
 
 @router.get("", response_model=list[NotificationItem])
 async def list_notifications(
-    user: UserDep,
-    db: DbDep,
+    user: UserDep, db: DbDep, nudging_client: NudgingDep
 ) -> list[NotificationItem]:
     """List user notifications."""
 
-    # TODO
-    @dataclass(frozen=True)
-    class TestNotification:
-        id: str
-        title: str
-        body: str
-        severity: str
-        created_at: datetime
-        read_at: datetime | None
-
-    notifications: list[TestNotification] = [
-        TestNotification(
-            id="0000001",
-            created_at=datetime.now(),
-            title="Welcome to the REC Webapp (example)",
-            body="Learn more about the app from your energy community manager",
-            severity="info",
-            read_at=None,
-        )
-    ]
+    res = await nudging_client.list_notifications(token=user.token)
 
     return [
         NotificationItem(
@@ -60,8 +44,9 @@ class TestNotification:
                 else "warning" if n.severity == "warning" else "info"
             ),
             read_at=n.read_at.isoformat() if n.read_at else None,
+            deleted_at=n.deleted_at.isoformat() if n.deleted_at else None,
         )
-        for n in notifications
+        for n in res
     ]
 
 
@@ -70,76 +55,113 @@ async def enable_notifications(
     user: UserDep,
     db: DbDep,
 ) -> SuccessResponse:
-    """Enable notifications for user."""
+    # TODO
+    await update_user_settings(user_id=user.sub, db=db, email_notifications=True)
+    return SuccessResponse()
+
+
+@router.post("/disable", response_model=SuccessResponse)
+async def disable_notifications(
+    user: UserDep,
+    db: DbDep,
+) -> SuccessResponse:
+    # TODO
+    await update_user_settings(user_id=user.sub, db=db, email_notifications=False)
+    return SuccessResponse()
+
+
+# NOTE: /read-all must be registered before /{id}/read so FastAPI does not
+# capture the literal string "read-all" as a notification id.
+@router.post("/read-all", response_model=SuccessResponse)
+async def mark_all_notifications_read(
+    user: UserDep,
+    nudging_client: NudgingDep,
+) -> SuccessResponse:
+    """Mark every unread notification as read for the current user.
+
+    The nudging service has no bulk-mark-read endpoint, so we fetch the
+    unread list and fan out individual mark_read calls concurrently.
+    """
+    unread = await nudging_client.list_notifications(unread_only=True, token=user.token)
+
+    if unread:
+        await asyncio.gather(
+            *[nudging_client.mark_read(n.id, token=user.token) for n in unread]
+        )
+
+    return SuccessResponse()
+
 
-    # Idempotent placeholder: in a real implementation this might
-    # register the user in the nudging tool
+@router.post("/{notification_id}/read", response_model=SuccessResponse)
+async def mark_notification_read(
+    notification_id: str,
+    user: UserDep,
+    nudging_client: NudgingDep,
+) -> SuccessResponse:
+    """Mark a single notification as read. Idempotent."""
+    result = await nudging_client.mark_read(notification_id, token=user.token)
+    if result is None:
+        raise HTTPException(status_code=404, detail="Notification not found")
     return SuccessResponse()
 
 
 @router.get("/webpush/vapid-public-key", response_model=VapidKeyResponse)
 async def vapid_public_key(
-    user: UserDep,
-    db: DbDep,
+    nudging_client: NudgingDep,
 ) -> VapidKeyResponse:
     """Get VAPID public key for web push."""
-    return VapidKeyResponse(public_key=app_settings.vapid_public_key)
+    res = await nudging_client.get_vapid_public_key()
+    if res is None:
+        raise HTTPException(500, "Failed to fetch VAPID public key")
+    return VapidKeyResponse(public_key=res.public_key)
 
 
 @router.post("/webpush/subscribe", response_model=SuccessResponse)
 async def webpush_subscribe(
-    request: Request,
     user: UserDep,
     db: DbDep,
+    nudging_client: NudgingDep,
+    payload: PushSubscriptionPayload,
 ) -> SuccessResponse:
-    """Subscribe to web push notifications."""
-
-    data = await request.json()
-    endpoint = data.get("endpoint")
-
-    if not endpoint:
-        raise HTTPException(status_code=400, detail="subscription endpoint missing")
+    """Enable notifications for user."""
+    await nudging_client.subscribe(
+        body=SubscribeRequest(
+            subscription=WebPushSubscriptionIn(
+                endpoint=payload.endpoint,
+                keys=WebPushKeysIn(
+                    p256dh=payload.p256dh,
+                    auth=payload.auth,
+                ),
+            )
+        ),
+        token=user.token,
+    )
 
-    # Check if subscription already exists
-    result = await db.execute(
-        select(WebPushSubscription).filter(
-            WebPushSubscription.user_id == user.sub,
-            WebPushSubscription.endpoint == endpoint,
-        )
+    await update_user_settings(
+        user_id=user.sub,
+        db=db,
+        webpush_enabled=True,
     )
-    existing = result.scalar_one_or_none()
-
-    if existing:
-        # Update existing subscription
-        existing.subscription_json = data
-        await db.commit()
-    else:
-        # Create new subscription
-        subscription = WebPushSubscription(
-            user_id=user.sub,
-            endpoint=endpoint,
-            subscription_json=data,
-        )
-        db.add(subscription)
-        await db.commit()
 
     return SuccessResponse()
 
 
 @router.post("/webpush/unsubscribe", response_model=SuccessResponse)
 async def webpush_unsubscribe(
-    body: WebPushUnsubscribeRequest,
     user: UserDep,
     db: DbDep,
+    nudging_client: NudgingDep,
+    payload: PushSubscriptionUnsubscribePayload,
 ) -> SuccessResponse:
-    """Unsubscribe from web push notifications."""
+    await nudging_client.unsubscribe(
+        body=UnsubscribeRequest(endpoint=payload.endpoint),
+        token=user.token,
+    )
 
-    await db.execute(
-        delete(WebPushSubscription).filter(
-            WebPushSubscription.user_id == user.sub,
-            WebPushSubscription.endpoint == body.endpoint,
-        )
+    await update_user_settings(
+        user_id=user.sub,
+        db=db,
+        webpush_enabled=False,
     )
-    await db.commit()
 
     return SuccessResponse()

src/celine/webapp/api/schemas.py

@@ -64,6 +64,7 @@ class NotificationItem(BaseModel):
     body: str
     severity: Literal["info", "warning", "critical"]
     read_at: Optional[str] = None
+    deleted_at: Optional[str] = None
 
 
 # Settings
@@ -72,7 +73,12 @@ class SettingsModel(BaseModel):
 
     simple_mode: bool = False
     font_scale: float = Field(default=1.0, ge=0.9, le=1.3)
-    notifications: dict = Field(default_factory=lambda: {"email_enabled": False})
+    notifications: dict = Field(
+        default_factory=lambda: {
+            "email_enabled": False,
+            "webpush_enabled": False,
+        }
+    )
 
 
 # WebPush
@@ -93,3 +99,16 @@ class SuccessResponse(BaseModel):
     """Generic success response."""
 
     ok: bool = True
+
+
+class PushSubscriptionPayload(BaseModel):
+    """What the browser sends after navigator.serviceWorker.pushManager.subscribe()"""
+
+    endpoint: str
+    p256dh: str
+    auth: str
+
+
+class PushSubscriptionUnsubscribePayload(BaseModel):
+
+    endpoint: str

src/celine/webapp/api/settings_routes.py

@@ -6,7 +6,7 @@
 from celine.webapp.api.deps import UserDep, DbDep
 from celine.webapp.api.schemas import SettingsModel
 from celine.webapp.db import Settings
-
+from celine.webapp.db.user_settings import load_user_settings, update_user_settings
 
 router = APIRouter(prefix="/api", tags=["settings"])
 
@@ -17,21 +17,7 @@ async def get_settings(
     db: DbDep,
 ) -> SettingsModel:
     """Get user settings."""
-
-    result = await db.execute(select(Settings).filter(Settings.user_id == user.sub))
-    settings = result.scalar_one_or_none()
-
-    if not settings:
-        settings = Settings(
-            user_id=user.sub,
-            simple_mode=False,
-            font_scale=1.0,
-            email_notifications=False,
-        )
-        db.add(settings)
-        await db.commit()
-        await db.refresh(settings)
-
+    settings = await load_user_settings(user.sub, db)
     return SettingsModel(
         simple_mode=settings.simple_mode,
         font_scale=settings.font_scale,
@@ -50,18 +36,13 @@ async def update_settings(
     data = await request.json()
     model = SettingsModel.model_validate(data)
 
-    result = await db.execute(select(Settings).filter(Settings.user_id == user.sub))
-    settings = result.scalar_one_or_none()
-
-    if not settings:
-        settings = Settings(user_id=user.sub)
-        db.add(settings)
-
-    settings.simple_mode = model.simple_mode
-    settings.font_scale = model.font_scale
-    settings.email_notifications = bool(model.notifications.get("email_enabled"))
-
-    await db.commit()
-    await db.refresh(settings)
+    await update_user_settings(
+        user_id=user.sub,
+        db=db,
+        simple_mode=model.simple_mode,
+        font_scale=model.font_scale,
+        email_notifications=bool(model.notifications.get("email_enabled")),
+        webpush_enabled=bool(model.notifications.get("webpush_enabled")),
+    )
 
     return model