Merge pull request #135 from bg-playground/copilot/add-notification-system

Add notification system with bell UI and event hooks

Author: bg-playground

backend/app/api/links.py

@@ -187,6 +187,16 @@ async def review_suggestion(
         resource_id=str(suggestion_id),
         details={"feedback": review.feedback, "status": review.status.value},
     )
+
+    try:
+        from app.services.notification_service import notify_suggestion_reviewed
+
+        await notify_suggestion_reviewed(
+            db, reviewer_user_id=current_user.id, suggestion_count=1, status=review.status.value
+        )
+    except Exception:
+        pass
+
     return reviewed
 
 
@@ -214,4 +224,13 @@ async def bulk_review_suggestions(
         },
     )
 
+    try:
+        from app.services.notification_service import notify_suggestion_reviewed
+
+        await notify_suggestion_reviewed(
+            db, reviewer_user_id=current_user.id, suggestion_count=reviewed, status=request.status.value
+        )
+    except Exception:
+        pass
+
     return {"message": f"Reviewed {reviewed} suggestions", "count": reviewed, "status": request.status}

backend/app/api/notifications.py

@@ -0,0 +1,74 @@
+"""API endpoints for Notifications"""
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.dependencies import get_current_user
+from app.crud.notification import get_notifications, get_unread_count, mark_all_as_read, mark_as_read
+from app.db.session import get_db
+from app.models.user import User
+from app.schemas.notification import NotificationListResponse, NotificationResponse
+
+router = APIRouter()
+
+
+@router.get("/notifications", response_model=NotificationListResponse)
+async def list_notifications(
+    unread_only: bool = Query(False, description="Return only unread notifications"),
+    limit: int = Query(50, ge=1, le=200, description="Maximum results to return"),
+    offset: int = Query(0, ge=0, description="Number of results to skip"),
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """List the current user's notifications."""
+    notifications, total = await get_notifications(
+        db,
+        user_id=current_user.id,
+        unread_only=unread_only,
+        limit=limit,
+        offset=offset,
+    )
+    unread_count = await get_unread_count(db, user_id=current_user.id)
+    return NotificationListResponse(
+        notifications=notifications,
+        unread_count=unread_count,
+        total=total,
+    )
+
+
+@router.get("/notifications/unread-count", response_model=dict)
+async def unread_count(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Get unread notification count for the current user."""
+    count = await get_unread_count(db, user_id=current_user.id)
+    return {"unread_count": count}
+
+
+@router.patch("/notifications/{notification_id}/read", response_model=NotificationResponse)
+async def mark_notification_read(
+    notification_id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Mark a single notification as read."""
+    notification = await mark_as_read(db, notification_id=notification_id, user_id=current_user.id)
+    if not notification:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Notification {notification_id} not found",
+        )
+    return notification
+
+
+@router.post("/notifications/mark-all-read", response_model=dict)
+async def mark_all_notifications_read(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Mark all notifications as read for the current user."""
+    count = await mark_all_as_read(db, user_id=current_user.id)
+    return {"marked_read": count}

backend/app/api/requirements.py

@@ -49,6 +49,18 @@ async def create_requirement(
         details={"title": new_requirement.title},
     )
 
+    try:
+        from app.services.notification_service import notify_requirement_created
+
+        await notify_requirement_created(
+            db,
+            creator_user_id=current_user.id,
+            requirement_title=new_requirement.title,
+            metadata={"requirement_id": str(new_requirement.id)},
+        )
+    except Exception:
+        pass
+
     # Trigger auto-suggestion generation in background if enabled
     if settings.AUTO_SUGGESTIONS_ENABLED:
         background_tasks.add_task(

backend/app/api/suggestions.py

@@ -165,6 +165,18 @@ async def generate_suggestions(
             details=result,
         )
 
+        try:
+            from app.services.notification_service import notify_suggestions_generated
+
+            await notify_suggestions_generated(
+                db,
+                user_id=current_user.id,
+                suggestions_created=result.get("suggestions_created", 0),
+                pairs_analyzed=result.get("pairs_analyzed", 0),
+            )
+        except Exception:
+            pass
+
         return {"message": "Suggestion generation completed", "results": result}
 
     except ImportError as e:

backend/app/api/test_cases.py

@@ -45,6 +45,18 @@ async def create_test_case(
         details={"title": new_test_case.title},
     )
 
+    try:
+        from app.services.notification_service import notify_test_case_created
+
+        await notify_test_case_created(
+            db,
+            creator_user_id=current_user.id,
+            test_case_title=new_test_case.title,
+            metadata={"test_case_id": str(new_test_case.id)},
+        )
+    except Exception:
+        pass
+
     # Trigger auto-suggestion generation in background if enabled
     if settings.AUTO_SUGGESTIONS_ENABLED:
         background_tasks.add_task(

backend/app/crud/notification.py

@@ -0,0 +1,115 @@
+"""CRUD operations for Notifications"""
+
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.notification import Notification, NotificationType
+from app.models.user import User
+
+
+async def create_notification(
+    db: AsyncSession,
+    user_id: UUID,
+    type: NotificationType,
+    title: str,
+    message: str,
+    metadata: dict[str, Any] | None = None,
+) -> Notification:
+    """Create a single notification for a user."""
+    notification = Notification(
+        user_id=user_id,
+        type=type,
+        title=title,
+        message=message,
+        metadata_=metadata,
+    )
+    db.add(notification)
+    await db.commit()
+    await db.refresh(notification)
+    return notification
+
+
+async def create_notification_for_all_users(
+    db: AsyncSession,
+    type: NotificationType,
+    title: str,
+    message: str,
+    metadata: dict[str, Any] | None = None,
+    exclude_user_id: UUID | None = None,
+) -> list[Notification]:
+    """Create a notification for all active users, optionally excluding one."""
+    query = select(User).where(User.is_active.is_(True))  # type: ignore[attr-defined]
+    if exclude_user_id is not None:
+        query = query.where(User.id != exclude_user_id)
+    result = await db.execute(query)
+    users = result.scalars().all()
+
+    notifications = [
+        Notification(
+            user_id=u.id,
+            type=type,
+            title=title,
+            message=message,
+            metadata_=metadata,
+        )
+        for u in users
+    ]
+    db.add_all(notifications)
+    await db.commit()
+    return notifications
+
+
+async def get_notifications(
+    db: AsyncSession,
+    user_id: UUID,
+    unread_only: bool = False,
+    limit: int = 50,
+    offset: int = 0,
+) -> tuple[list[Notification], int]:
+    """Get notifications for a user. Returns (notifications, total)."""
+    query = select(Notification).where(Notification.user_id == user_id)
+    if unread_only:
+        query = query.where(Notification.read.is_(False))  # type: ignore[attr-defined]
+
+    count_result = await db.execute(select(func.count()).select_from(query.subquery()))
+    total = count_result.scalar_one()
+
+    query = query.order_by(Notification.created_at.desc()).offset(offset).limit(limit)
+    result = await db.execute(query)
+    return list(result.scalars().all()), total
+
+
+async def get_unread_count(db: AsyncSession, user_id: UUID) -> int:
+    """Get unread notification count for a user."""
+    result = await db.execute(
+        select(func.count()).where(Notification.user_id == user_id, Notification.read.is_(False))  # type: ignore[attr-defined]
+    )
+    return result.scalar_one()
+
+
+async def mark_as_read(db: AsyncSession, notification_id: UUID, user_id: UUID) -> Notification | None:
+    """Mark a single notification as read. Returns None if not found or not owned by user."""
+    result = await db.execute(
+        select(Notification).where(Notification.id == notification_id, Notification.user_id == user_id)
+    )
+    notification = result.scalar_one_or_none()
+    if notification is None:
+        return None
+    notification.read = True
+    await db.commit()
+    await db.refresh(notification)
+    return notification
+
+
+async def mark_all_as_read(db: AsyncSession, user_id: UUID) -> int:
+    """Mark all notifications as read for a user. Returns number of updated rows."""
+    result = await db.execute(
+        update(Notification)
+        .where(Notification.user_id == user_id, Notification.read.is_(False))  # type: ignore[attr-defined]
+        .values(read=True)
+    )
+    await db.commit()
+    return result.rowcount  # type: ignore[attr-defined]

backend/app/main.py

@@ -3,7 +3,18 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from app.api import analytics, audit_log, auth, links, requirements, suggestions, test_cases, traceability, users
+from app.api import (
+    analytics,
+    audit_log,
+    auth,
+    links,
+    notifications,
+    requirements,
+    suggestions,
+    test_cases,
+    traceability,
+    users,
+)
 from app.config import settings
 from app.db.session import init_db
 
@@ -28,6 +39,7 @@
 app.include_router(analytics.router, prefix=settings.API_V1_PREFIX, tags=["analytics"])
 app.include_router(audit_log.router, prefix=settings.API_V1_PREFIX, tags=["audit_log"])
 app.include_router(users.router, prefix=settings.API_V1_PREFIX, tags=["users"])
+app.include_router(notifications.router, prefix=settings.API_V1_PREFIX, tags=["notifications"])
 
 
 @app.on_event("startup")

backend/app/models/__init__.py

@@ -3,6 +3,7 @@
 from .audit_log import AuditLog
 from .base import Base, TimestampMixin
 from .link import LinkSource, LinkType, RequirementTestCaseLink
+from .notification import Notification, NotificationType
 from .requirement import PriorityLevel, Requirement, RequirementStatus, RequirementType
 from .suggestion import LinkSuggestion, SuggestionMethod, SuggestionStatus
 from .test_case import AutomationStatus, TestCase, TestCaseStatus, TestCaseType
@@ -12,6 +13,8 @@
     "AuditLog",
     "Base",
     "TimestampMixin",
+    "Notification",
+    "NotificationType",
     "Requirement",
     "RequirementType",
     "PriorityLevel",

backend/app/models/notification.py

@@ -0,0 +1,34 @@
+"""Notification model"""
+
+import enum
+import uuid
+
+from sqlalchemy import Boolean, Column, DateTime, Enum, ForeignKey, String, Text
+from sqlalchemy.sql import func
+
+from .base import Base
+from .requirement import GUID, JSON
+
+
+class NotificationType(str, enum.Enum):
+    SUGGESTIONS_GENERATED = "suggestions_generated"
+    COVERAGE_DROP = "coverage_drop"
+    SUGGESTION_REVIEWED = "suggestion_reviewed"
+    REQUIREMENT_CREATED = "requirement_created"
+    TEST_CASE_CREATED = "test_case_created"
+
+
+class Notification(Base):
+    __tablename__ = "notifications"
+
+    id = Column(GUID(), primary_key=True, default=uuid.uuid4)
+    user_id = Column(GUID(), ForeignKey("users.id"), nullable=False, index=True)
+    type = Column(Enum(NotificationType), nullable=False)
+    title = Column(String(255), nullable=False)
+    message = Column(Text, nullable=False)
+    read = Column(Boolean, default=False, nullable=False)
+    metadata_ = Column("metadata", JSON(), nullable=True)
+    created_at = Column(DateTime, nullable=False, server_default=func.now())
+
+    def __repr__(self):
+        return f"<Notification(id={self.id}, type={self.type}, user_id={self.user_id})>"

backend/app/schemas/notification.py

@@ -0,0 +1,28 @@
+"""Schemas for Notification"""
+
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict
+
+from app.models.notification import NotificationType
+
+
+class NotificationResponse(BaseModel):
+    id: UUID
+    user_id: UUID
+    type: NotificationType
+    title: str
+    message: str
+    read: bool
+    metadata_: dict[str, Any] | None
+    created_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NotificationListResponse(BaseModel):
+    notifications: list[NotificationResponse]
+    unread_count: int
+    total: int