migration: preserve review journal alerts and assistant slice

2026-07-31 11:55:27 +08:00
parent b3df070481
commit 38de3de0a3
20 changed files with 1323 additions and 773 deletions
@@ -1,3 +1,18 @@
-from .service import AlertService
+from .facade import AlertServiceMixin
+from .http import AlertHttpMixin
+from .repository import AlertRepositoryMixin

-__all__ = ["AlertService"]
+__all__ = [
+    "AlertHttpMixin",
+    "AlertRepositoryMixin",
+    "AlertService",
+    "AlertServiceMixin",
+]
+
+
+def __getattr__(name: str):
+    if name == "AlertService":
+        from .service import AlertService
+
+        return AlertService
+    raise AttributeError(name)
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+
+class AlertServiceMixin:
+    def alert_center(self, status: str = "all", as_of: str = "") -> dict[str, Any]:
+        tracking = self.strategy_tracking.list_tracking(self.current_user_id, 12)
+        self.alert_service.sync_strategy_tracking(self.current_user_id, tracking)
+        return self.alert_service.list_alerts(
+            self.current_user_id, status, as_of
+        )
+
+    def create_alert(self, payload: dict[str, Any]) -> dict[str, Any]:
+        alert_id = self.alert_service.create_manual(self.current_user_id, payload)
+        return {"id": alert_id, **self.alert_center()}
+
+    def mark_alert_read(self, alert_id: int) -> dict[str, Any]:
+        self.alert_service.mark_read(self.current_user_id, alert_id)
+        return self.alert_center()
+
+    def mark_all_alerts_read(self, as_of: str = "") -> dict[str, Any]:
+        compact_date = self.alert_service.calendar_date(as_of or date.today().isoformat())
+        self.alert_service.mark_all_read(self.current_user_id, compact_date)
+        return self.alert_center(as_of=compact_date)
+
+    def delete_alert(self, alert_id: int) -> dict[str, Any]:
+        deleted = self.alert_service.delete(self.current_user_id, alert_id)
+        return {"deleted": deleted, **self.alert_center()}
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import json
+from http import HTTPStatus
+
+
+class AlertHttpMixin:
+    def save_alert(self) -> None:
+        try:
+            body = self.read_json_body()
+            self.send_json(
+                {"ok": True, **self.application_service.create_alert(body)},
+                HTTPStatus.CREATED,
+            )
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+
+class AlertRepositoryMixin:
+    def save_alert(
+        self,
+        user_id: int,
+        kind: str,
+        title: str,
+        content: str,
+        available_date: str,
+        code: str,
+        dedupe_key: str,
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO alerts
+                    (user_id, kind, title, content, available_date, code, dedupe_key,
+                     is_read, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+                ON CONFLICT(user_id, dedupe_key) DO UPDATE SET
+                    title=excluded.title, content=excluded.content,
+                    available_date=excluded.available_date, updated_at=excluded.updated_at
+                """,
+                (
+                    int(user_id), kind, title, content, available_date, code,
+                    dedupe_key, now, now,
+                ),
+            )
+            row = connection.execute(
+                "SELECT id FROM alerts WHERE user_id = ? AND dedupe_key = ?",
+                (int(user_id), dedupe_key),
+            ).fetchone()
+        return int(row["id"])
+
+    def list_alerts(
+        self, user_id: int, as_of: str, unread_only: bool = False, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            if unread_only:
+                rows = connection.execute(
+                    """
+                    SELECT id, kind, title, content, available_date, code, is_read,
+                           created_at, updated_at, read_at
+                    FROM alerts
+                    WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                    ORDER BY available_date DESC, id DESC LIMIT ?
+                    """,
+                    (int(user_id), as_of, max(1, min(300, int(limit)))),
+                ).fetchall()
+            else:
+                rows = connection.execute(
+                    """
+                    SELECT id, kind, title, content, available_date, code, is_read,
+                           created_at, updated_at, read_at
+                    FROM alerts WHERE user_id = ?
+                    ORDER BY CASE WHEN available_date > ? THEN 0 ELSE 1 END,
+                             is_read, available_date, id DESC LIMIT ?
+                    """,
+                    (int(user_id), as_of, max(1, min(300, int(limit)))),
+                ).fetchall()
+        return [{**dict(row), "is_read": bool(row["is_read"])} for row in rows]
+
+    def count_unread_alerts(self, user_id: int, as_of: str) -> int:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT COUNT(*) AS total FROM alerts
+                WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                """,
+                (int(user_id), as_of),
+            ).fetchone()
+        return int(row["total"] if row else 0)
+
+    def mark_alert_read(self, user_id: int, alert_id: int) -> bool:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            cursor = connection.execute(
+                """
+                UPDATE alerts SET is_read = 1, read_at = ?, updated_at = ?
+                WHERE id = ? AND user_id = ?
+                """,
+                (now, now, int(alert_id), int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def mark_all_alerts_read(self, user_id: int, as_of: str) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            cursor = connection.execute(
+                """
+                UPDATE alerts SET is_read = 1, read_at = ?, updated_at = ?
+                WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                """,
+                (now, now, int(user_id), as_of),
+            )
+            return int(cursor.rowcount)
+
+    def delete_alert(self, user_id: int, alert_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM alerts WHERE id = ? AND user_id = ?",
+                (int(alert_id), int(user_id)),
+            )
+            return cursor.rowcount > 0