Multi-user sharing, groups, and in-app notifications

Backend: - Alembic migration 0025: groups, group_memberships, project_shares, note_shares, notifications tables - models: Group, GroupMembership, ProjectShare, NoteShare, Notification - services/access.py: permission resolution (viewer/editor/admin/owner) - services/groups.py + routes/groups.py: full group CRUD + membership - services/sharing.py + routes/shares.py: project/note sharing API - services/notifications.py: in-app notification create/list/mark-read - routes/in_app_notifications.py: GET/POST notification endpoints - routes/users.py: user search endpoint - services/projects.py + services/notes.py: *_for_user variants - routes updated to use *_for_user on get/list; adds permission field - app.py: register all new blueprints Frontend: - api/client.ts: ShareEntry, GroupEntry, NotificationEntry types + helpers - stores/notifications.ts: Pinia store with polling - NotificationBell.vue: bell icon + badge + dropdown toggle + 60s poll - NotificationsPanel.vue: unread notification list with mark-all-read - ShareDialog.vue: teleport modal for sharing projects/notes with users/groups - SharedWithMeView.vue: /shared route listing shared projects and notes - AppHeader: NotificationBell, Shared nav link - ProjectView, NoteViewerView, TaskViewerView: Share button + ShareDialog - SettingsView: Groups admin tab with create/delete groups + member mgmt - router: /shared route Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-03-11 15:37:00 -04:00
parent 878b149f4d
commit c7ef709633
31 changed files with 3147 additions and 16 deletions
@@ -249,3 +249,199 @@ def start_notification_loop() -> None:
    global _notification_task
    if _notification_task is None or _notification_task.done():
        _notification_task = asyncio.create_task(_notification_loop())
+
+
+# ---------------------------------------------------------------------------
+# In-app notifications (Notification model — shares, group events)
+# ---------------------------------------------------------------------------
+
+async def create_in_app_notification(user_id: int, notif_type: str, payload: dict):
+    """Create an in-app Notification record."""
+    from fabledassistant.models.notification import Notification
+    async with async_session() as session:
+        n = Notification(user_id=user_id, type=notif_type, payload=payload)
+        session.add(n)
+        await session.commit()
+        await session.refresh(n)
+        return n
+
+
+async def _fire_push_notif(user_id: int, title: str, body: str, url: str) -> None:
+    try:
+        from fabledassistant.services.push import send_push_notification
+        await send_push_notification(user_id, title, body, url=url)
+    except Exception:
+        logger.exception("Push notification failed for user %d", user_id)
+
+
+async def _fire_share_email(user_id: int, subject: str, body_text: str) -> None:
+    try:
+        if not await is_smtp_configured():
+            return
+        async with async_session() as session:
+            user = await session.get(User, user_id)
+        if user and user.email:
+            html = _email_html(subject, f"<p>{body_text.replace(chr(10), '<br>')}</p>")
+            await send_email(user.email, subject, html)
+    except Exception:
+        logger.exception("Share email notification failed for user %d", user_id)
+
+
+async def _group_member_ids(group_id: int) -> list[int]:
+    from fabledassistant.models.group import GroupMembership
+    async with async_session() as session:
+        rows = (await session.execute(
+            select(GroupMembership.user_id).where(GroupMembership.group_id == group_id)
+        )).scalars().all()
+        return list(rows)
+
+
+async def notify_project_shared(
+    project_id: int,
+    permission: str,
+    invited_by_user_id: int,
+    target_user_id: int | None,
+    target_group_id: int | None,
+) -> None:
+    from fabledassistant.models.project import Project
+    async with async_session() as session:
+        project = await session.get(Project, project_id)
+        inviter = await session.get(User, invited_by_user_id)
+    if not project or not inviter:
+        return
+
+    recipients: list[int] = []
+    if target_user_id:
+        recipients = [target_user_id]
+    elif target_group_id:
+        recipients = [uid for uid in await _group_member_ids(target_group_id) if uid != invited_by_user_id]
+
+    url = f"/projects/{project_id}"
+    msg = f"{inviter.username} shared \"{project.title}\" with you as {permission}"
+
+    for uid in recipients:
+        await create_in_app_notification(uid, "project_shared", {
+            "project_id": project_id,
+            "project_title": project.title,
+            "permission": permission,
+            "invited_by": inviter.username,
+            "url": url,
+        })
+        asyncio.create_task(_fire_push_notif(uid, "Project shared with you", msg, url))
+        asyncio.create_task(_fire_share_email(uid, f"[Fabled] {inviter.username} shared a project with you", msg))
+
+
+async def notify_note_shared(
+    note_id: int,
+    permission: str,
+    invited_by_user_id: int,
+    target_user_id: int | None,
+    target_group_id: int | None,
+) -> None:
+    from fabledassistant.models.note import Note
+    async with async_session() as session:
+        note = await session.get(Note, note_id)
+        inviter = await session.get(User, invited_by_user_id)
+    if not note or not inviter:
+        return
+
+    recipients: list[int] = []
+    if target_user_id:
+        recipients = [target_user_id]
+    elif target_group_id:
+        recipients = [uid for uid in await _group_member_ids(target_group_id) if uid != invited_by_user_id]
+
+    route = "tasks" if note.is_task else "notes"
+    url = f"/{route}/{note_id}"
+    msg = f"{inviter.username} shared \"{note.title}\" with you as {permission}"
+
+    for uid in recipients:
+        await create_in_app_notification(uid, "note_shared", {
+            "note_id": note_id,
+            "note_title": note.title,
+            "permission": permission,
+            "invited_by": inviter.username,
+            "url": url,
+        })
+        asyncio.create_task(_fire_push_notif(uid, "Note shared with you", msg, url))
+        asyncio.create_task(_fire_share_email(uid, f"[Fabled] {inviter.username} shared a note with you", msg))
+
+
+async def notify_group_added(
+    group_id: int, role: str, invited_by_user_id: int, target_user_id: int
+) -> None:
+    from fabledassistant.models.group import Group
+    async with async_session() as session:
+        group = await session.get(Group, group_id)
+        inviter = await session.get(User, invited_by_user_id)
+    if not group or not inviter:
+        return
+
+    url = f"/groups/{group_id}"
+    msg = f"{inviter.username} added you to group \"{group.name}\" as {role}"
+
+    await create_in_app_notification(target_user_id, "group_added", {
+        "group_id": group_id,
+        "group_name": group.name,
+        "role": role,
+        "invited_by": inviter.username,
+        "url": url,
+    })
+    asyncio.create_task(_fire_push_notif(target_user_id, "Added to a group", msg, url))
+    asyncio.create_task(_fire_share_email(target_user_id, "[Fabled] You've been added to a group", msg))
+
+
+async def list_in_app_notifications(user_id: int, unread_only: bool = True) -> list[dict]:
+    from fabledassistant.models.notification import Notification
+    async with async_session() as session:
+        q = select(Notification).where(Notification.user_id == user_id)
+        if unread_only:
+            q = q.where(Notification.read_at.is_(None))
+        q = q.order_by(Notification.created_at.desc()).limit(50)
+        rows = (await session.execute(q)).scalars().all()
+        return [n.to_dict() for n in rows]
+
+
+async def unread_notification_count(user_id: int) -> int:
+    from fabledassistant.models.notification import Notification
+    async with async_session() as session:
+        result = await session.execute(
+            select(func.count()).where(
+                Notification.user_id == user_id,
+                Notification.read_at.is_(None),
+            )
+        )
+        return result.scalar() or 0
+
+
+async def mark_notification_read(user_id: int, notification_id: int) -> bool:
+    from fabledassistant.models.notification import Notification
+    from datetime import timezone as tz
+    async with async_session() as session:
+        n = (await session.execute(
+            select(Notification).where(
+                Notification.id == notification_id,
+                Notification.user_id == user_id,
+            )
+        )).scalar_one_or_none()
+        if not n:
+            return False
+        from datetime import datetime
+        n.read_at = datetime.now(tz.utc)
+        await session.commit()
+        return True
+
+
+async def mark_all_notifications_read(user_id: int) -> int:
+    from fabledassistant.models.notification import Notification
+    from datetime import datetime, timezone as tz
+    from sqlalchemy import update as sa_update
+    async with async_session() as session:
+        result = await session.execute(
+            sa_update(Notification)
+            .where(Notification.user_id == user_id, Notification.read_at.is_(None))
+            .values(read_at=datetime.now(tz.utc))
+            .returning(Notification.id)
+        )
+        await session.commit()
+        return len(result.fetchall())