功能(提醒)：统一项目提醒中心与桌面通知链路

增加通用提醒状态、数据库迁移和定时同步，覆盖风险时效、文件回执、项目里程碑、访视窗口与协作申请。

新增网页端和桌面端提醒中心、真实投递诊断与固定隐私通知正文，并补齐登录来源聚合、测试和说明文档。

backend/app/services/notification_service.py

@@ -8,10 +8,24 @@ from fastapi import HTTPException, status
 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.models.desktop_notification import DesktopNotificationDelivery
 from app.models.notification import Notification
 from app.schemas.notification import GeneralNotificationFeed
 
 
+async def _requeue_desktop_delivery(db: AsyncSession, notification_id: uuid.UUID) -> None:
+    """Allow an escalated/reopened reminder to be delivered again by the desktop channel."""
+    await db.execute(
+        update(DesktopNotificationDelivery)
+        .where(DesktopNotificationDelivery.notification_id == notification_id)
+        .values(
+            claim_token=None,
+            claimed_at=None,
+            delivered_at=None,
+        )
+    )
+
+
 async def create_recipient_notifications(
     db: AsyncSession,
     *,
@@ -25,6 +39,9 @@ async def create_recipient_notifications(
     source_type: str,
     source_id: str,
     dedupe_key: str,
+    source_version: str | None = None,
+    requires_action: bool = True,
+    due_at: datetime | None = None,
 ) -> None:
     recipients = set(recipient_ids)
     if not recipients:
@@ -46,10 +63,78 @@ async def create_recipient_notifications(
             action_path=action_path,
             source_type=source_type,
             source_id=source_id,
+            source_version=source_version,
             dedupe_key=dedupe_key,
+            requires_action=requires_action,
+            due_at=due_at,
         ))
 
 
+async def sync_state_notification(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    recipient_id: uuid.UUID,
+    category: str,
+    priority: str,
+    title: str,
+    message: str,
+    action_path: str,
+    source_type: str,
+    source_id: str,
+    source_version: str,
+    active: bool,
+    due_at: datetime | None = None,
+    requires_action: bool = True,
+    dedupe_key: str | None = None,
+) -> None:
+    """Synchronize one actionable business state into a recipient reminder."""
+    dedupe_key = dedupe_key or f"state:{source_type}:{source_id}"
+    item = await db.scalar(select(Notification).where(
+        Notification.recipient_id == recipient_id,
+        Notification.dedupe_key == dedupe_key,
+    ))
+    now = datetime.now(timezone.utc)
+    if not active:
+        if item and item.resolved_at is None:
+            item.resolved_at = now
+            item.read_at = item.read_at or now
+        return
+    if item is None:
+        db.add(Notification(
+            study_id=study_id,
+            recipient_id=recipient_id,
+            category=category,
+            priority=priority,
+            title=title,
+            message=message,
+            action_path=action_path,
+            source_type=source_type,
+            source_id=source_id,
+            source_version=source_version,
+            dedupe_key=dedupe_key,
+            requires_action=requires_action,
+            due_at=due_at,
+        ))
+        return
+
+    should_notify_again = item.resolved_at is not None or item.source_version != source_version
+    item.study_id = study_id
+    item.category = category
+    item.priority = priority
+    item.title = title
+    item.message = message
+    item.action_path = action_path
+    item.source_version = source_version
+    item.requires_action = requires_action
+    item.due_at = due_at
+    if should_notify_again:
+        item.read_at = None
+        item.created_at = now
+        await _requeue_desktop_delivery(db, item.id)
+    item.resolved_at = None
+
+
 async def sync_aggregate_notification(
     db: AsyncSession,
     *,
@@ -63,6 +148,7 @@ async def sync_aggregate_notification(
     source_type: str,
     source_id: str,
     count: int,
+    due_at: datetime | None = None,
 ) -> None:
     dedupe_key = f"aggregate:{source_type}:{source_id}"
     item = await db.scalar(select(Notification).where(
@@ -89,32 +175,83 @@ async def sync_aggregate_notification(
             source_id=source_id,
             source_version=version,
             dedupe_key=dedupe_key,
+            requires_action=True,
+            due_at=due_at,
         ))
         return
     previous_count = int(item.source_version or 0)
+    item.category = category
     item.priority = priority
     item.title = title
     item.message = message
     item.action_path = action_path
     item.source_version = version
+    item.due_at = due_at
     if item.resolved_at is not None or count > previous_count:
         item.read_at = None
         item.created_at = now
+        await _requeue_desktop_delivery(db, item.id)
     item.resolved_at = None
 
 
+async def resolve_missing_recipient_sources(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    recipient_id: uuid.UUID,
+    source_type: str,
+    active_source_ids: set[str],
+) -> None:
+    filters = [
+        Notification.study_id == study_id,
+        Notification.recipient_id == recipient_id,
+        Notification.source_type == source_type,
+        Notification.resolved_at.is_(None),
+    ]
+    if active_source_ids:
+        filters.append(Notification.source_id.not_in(active_source_ids))
+    now = datetime.now(timezone.utc)
+    await db.execute(
+        update(Notification)
+        .where(*filters)
+        .values(resolved_at=now, read_at=func.coalesce(Notification.read_at, now))
+    )
+
+
 async def resolve_source_notifications(
     db: AsyncSession,
     *,
     source_type: str,
     source_id: str,
+    recipient_id: uuid.UUID | None = None,
+) -> None:
+    filters = [
+        Notification.source_type == source_type,
+        Notification.source_id == source_id,
+        Notification.resolved_at.is_(None),
+    ]
+    if recipient_id is not None:
+        filters.append(Notification.recipient_id == recipient_id)
+    now = datetime.now(timezone.utc)
+    await db.execute(
+        update(Notification)
+        .where(*filters)
+        .values(resolved_at=now, read_at=func.coalesce(Notification.read_at, now))
+    )
+
+
+async def resolve_recipient_study_notifications(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    recipient_id: uuid.UUID,
 ) -> None:
     now = datetime.now(timezone.utc)
     await db.execute(
         update(Notification)
         .where(
-            Notification.source_type == source_type,
-            Notification.source_id == source_id,
+            Notification.study_id == study_id,
+            Notification.recipient_id == recipient_id,
             Notification.resolved_at.is_(None),
         )
         .values(resolved_at=now, read_at=func.coalesce(Notification.read_at, now))
@@ -126,7 +263,11 @@ async def list_feed(
     *,
     study_id: uuid.UUID,
     recipient_id: uuid.UUID,
+    skip: int = 0,
     limit: int = 10,
+    category: str | None = None,
+    unread_only: bool = False,
+    requires_action: bool | None = None,
 ) -> GeneralNotificationFeed:
     active_filter = (
         Notification.study_id == study_id,
@@ -136,13 +277,36 @@ async def list_feed(
     unread_count = int(await db.scalar(
         select(func.count(Notification.id)).where(*active_filter, Notification.read_at.is_(None))
     ) or 0)
+
+    filters = [
+        Notification.study_id == study_id,
+        Notification.recipient_id == recipient_id,
+        Notification.resolved_at.is_(None),
+    ]
+    if category:
+        filters.append(Notification.category == category)
+    if unread_only:
+        filters.append(Notification.read_at.is_(None))
+    if requires_action is not None:
+        filters.append(Notification.requires_action.is_(requires_action))
+    total_count = int(await db.scalar(
+        select(func.count(Notification.id)).where(*filters)
+    ) or 0)
     items = (await db.scalars(
         select(Notification)
-        .where(*active_filter)
-        .order_by(Notification.read_at.is_not(None), Notification.created_at.desc())
-        .limit(max(1, min(limit, 50)))
+        .where(*filters)
+        .order_by(
+            Notification.read_at.is_not(None),
+            Notification.created_at.desc(),
+        )
+        .offset(max(0, skip))
+        .limit(max(1, min(limit, 100)))
     )).all()
-    return GeneralNotificationFeed(unread_count=unread_count, items=list(items))
+    return GeneralNotificationFeed(
+        unread_count=unread_count,
+        total_count=total_count,
+        items=list(items),
+    )
 
 
 async def mark_read(
@@ -161,7 +325,10 @@ async def mark_read(
     if item is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="通知不存在")
     if item.read_at is None:
-        item.read_at = datetime.now(timezone.utc)
+        now = datetime.now(timezone.utc)
+        item.read_at = now
+        if not item.requires_action:
+            item.resolved_at = now
         await db.commit()
         await db.refresh(item)
     return item
@@ -173,6 +340,7 @@ async def mark_all_read(
     study_id: uuid.UUID,
     recipient_id: uuid.UUID,
 ) -> None:
+    now = datetime.now(timezone.utc)
     await db.execute(
         update(Notification)
         .where(
@@ -180,7 +348,19 @@ async def mark_all_read(
             Notification.recipient_id == recipient_id,
             Notification.resolved_at.is_(None),
             Notification.read_at.is_(None),
+            Notification.requires_action.is_(False),
         )
-        .values(read_at=datetime.now(timezone.utc))
+        .values(read_at=now, resolved_at=now)
+    )
+    await db.execute(
+        update(Notification)
+        .where(
+            Notification.study_id == study_id,
+            Notification.recipient_id == recipient_id,
+            Notification.resolved_at.is_(None),
+            Notification.read_at.is_(None),
+            Notification.requires_action.is_(True),
+        )
+        .values(read_at=now)
     )
     await db.commit()