efddd15025
* Add account system foundation: email/password auth with cookie sessions Introduce the app's first authoritative, user-owned data in a separate data/accounts.sqlite (SQLAlchemy), kept apart from the disposable derived-cache DB. Wire fastapi-users for email/password signup, cookie-based login/logout, and a session-check endpoint, backed by a database session strategy so logins survive restarts and are revocable. - db.py: async (aiosqlite) + sync SQLAlchemy engines over accounts.sqlite, WAL + foreign keys, create_db_and_tables(). - models.py: User, AccessToken, Subscription, Notification tables. - users.py: pwdlib hashing, HttpOnly cookie transport (path-scoped, SameSite=Lax, Secure via env), DatabaseStrategy sessions, current-user dependencies. - schemas.py: user + subscription + notification Pydantic models. - app.py: mount auth/register/users routers on v2, create tables at startup. - Pin fastapi-users[sqlalchemy]/aiosqlite; ignore data/accounts.sqlite*. * Add account header entry and auth modal (frontend) account.js self-injects a header entry (following the units.js pattern) that shows a Sign in button when logged out and an account menu when logged in, plus an auth modal reusing the existing .mp-overlay/.mp-modal chrome for email/password sign-in and account creation. A shared apiFetch helper sends the same-origin cookie for authed calls; exported getUser/openAuth/onAuthChange back later phases. Imported by every page entry module. On narrow screens the entry collapses to an icon-only button so it doesn't crowd the title. Enforce an 8-character minimum password in the user manager. * Add subscription CRUD API and the alerts management page Backend api_accounts.py adds user-scoped, cookie-authenticated endpoints to create/list/update/delete subscriptions (and the notification reads used next): POST snaps lat/lon to a grid cell, resolves a label, and rejects a duplicate location+kind with 409; PATCH/DELETE are ownership-checked (404 on mismatch). Mounted on the v2 prefix. Frontend subscriptions.js + subscriptions.html serve the /alerts page: a sign-in gate when logged out, an add flow that reuses the shared map picker and an editor modal (kind, watched metrics, 95-99 percentile, two-sided), and a card list with inline threshold/active edits and remove. Reachable from the account menu. * Add background subscription evaluation engine notify.py runs a daemon thread that periodically evaluates every active subscription: it groups them by grid cell, reads history from the parquet cache only (never spends archive quota) plus the hourly recent/forecast bundle, and grades candidate days with the existing grading.grade_day. A watched metric that lands at or beyond the threshold percentile fires a 'high' alert; a two-sided subscription also fires 'low' for the symmetric cold/calm/dry tail (precip stays one-directional). Observed subscriptions look at the last few recorded days, forecast subscriptions at the coming week. Two guards keep it quiet: a UNIQUE(subscription, event_date, metric, direction, kind) constraint dedups repeat events, and a per-subscription weekly cap (last_notified_at) limits each alert to one notification per 7 days. The loop tolerates a bad cell or an upstream rate limit without aborting the pass. Started and stopped from the app lifespan; gated by THERMOGRAPH_ENABLE_NOTIFIER. * Add in-app notification center (header bell) Extend account.js with a notification bell beside the account menu: an unread badge, a dropdown listing recent notifications (title, body, relative time), a per-item mark-read on click, and a Mark all read action, all through the cookie-authed notifications API. Unread state refreshes on open and polls every two minutes while signed in; polling stops on sign-out. Styled to match the app, responsive down to mobile. * Harden accounts: expired-session cleanup, engine tests, ops docs - notify.py sweeps expired login sessions (access tokens past their lifetime) once per evaluation pass. - Add hermetic unit tests for the evaluation engine's trigger detection (high/low tails, precip one-directional, normal = no trigger) and notification wording. - Document accounts.sqlite (authoritative, back it up), the single-worker requirement for the in-process evaluator, and the new env vars in DEPLOY.md.
114 lines
3 KiB
Python
114 lines
3 KiB
Python
"""Pydantic request/response models for accounts, subscriptions, notifications.
|
|
|
|
The User* schemas are fastapi-users' base schemas extended with display_name; the
|
|
Subscription*/Notification* models are the app's first request bodies and shape the
|
|
JSON the frontend sends and receives.
|
|
"""
|
|
import uuid
|
|
from typing import Literal
|
|
|
|
from fastapi_users import schemas
|
|
from pydantic import BaseModel, Field, field_validator
|
|
|
|
import grading
|
|
|
|
# Canonical metric keys a subscription may watch (kept in lockstep with grading).
|
|
ALLOWED_METRICS = tuple(grading.CLIMO_METRICS)
|
|
DEFAULT_METRICS = ["tmax", "feels", "precip"]
|
|
|
|
|
|
# --- users (fastapi-users) ---------------------------------------------------
|
|
class UserRead(schemas.BaseUser[uuid.UUID]):
|
|
display_name: str | None = None
|
|
|
|
|
|
class UserCreate(schemas.BaseUserCreate):
|
|
display_name: str | None = None
|
|
|
|
|
|
class UserUpdate(schemas.BaseUserUpdate):
|
|
display_name: str | None = None
|
|
|
|
|
|
# --- subscriptions -----------------------------------------------------------
|
|
def _check_metrics(v: list[str]) -> list[str]:
|
|
if not v:
|
|
raise ValueError("pick at least one metric")
|
|
bad = [m for m in v if m not in ALLOWED_METRICS]
|
|
if bad:
|
|
raise ValueError(f"unknown metric(s): {', '.join(bad)}")
|
|
# de-dupe, preserve order
|
|
seen, out = set(), []
|
|
for m in v:
|
|
if m not in seen:
|
|
seen.add(m)
|
|
out.append(m)
|
|
return out
|
|
|
|
|
|
class SubscriptionIn(BaseModel):
|
|
lat: float = Field(ge=-90, le=90)
|
|
lon: float = Field(ge=-180, le=180)
|
|
label: str | None = None
|
|
threshold: int = Field(ge=95, le=99)
|
|
metrics: list[str] = Field(default_factory=lambda: list(DEFAULT_METRICS))
|
|
kind: Literal["observed", "forecast"] = "observed"
|
|
two_sided: bool = True
|
|
|
|
@field_validator("metrics")
|
|
@classmethod
|
|
def _metrics(cls, v):
|
|
return _check_metrics(v)
|
|
|
|
|
|
class SubscriptionPatch(BaseModel):
|
|
threshold: int | None = Field(default=None, ge=95, le=99)
|
|
metrics: list[str] | None = None
|
|
two_sided: bool | None = None
|
|
active: bool | None = None
|
|
|
|
@field_validator("metrics")
|
|
@classmethod
|
|
def _metrics(cls, v):
|
|
return _check_metrics(v) if v is not None else v
|
|
|
|
|
|
class SubscriptionOut(BaseModel):
|
|
id: int
|
|
cell_id: str
|
|
label: str | None
|
|
lat: float
|
|
lon: float
|
|
threshold: int
|
|
metrics: list[str]
|
|
kind: str
|
|
two_sided: bool
|
|
active: bool
|
|
last_notified_at: float | None
|
|
created_at: float
|
|
|
|
model_config = {"from_attributes": True}
|
|
|
|
|
|
# --- notifications -----------------------------------------------------------
|
|
class NotificationOut(BaseModel):
|
|
id: int
|
|
subscription_id: int
|
|
event_date: str
|
|
metric: str
|
|
direction: str
|
|
kind: str
|
|
percentile: float
|
|
value: float | None
|
|
grade: str | None
|
|
title: str
|
|
body: str | None
|
|
created_at: float
|
|
read_at: float | None
|
|
|
|
model_config = {"from_attributes": True}
|
|
|
|
|
|
class NotificationList(BaseModel):
|
|
notifications: list[NotificationOut]
|
|
unread_count: int
|