new features

cpv3/modules/notifications/service.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+
+import redis.asyncio as aioredis
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from cpv3.db.base import utcnow
+from cpv3.infrastructure.settings import get_settings
+from cpv3.modules.jobs.models import Job
+from cpv3.modules.notifications.repository import NotificationRepository
+from cpv3.modules.notifications.schemas import (
+    NotificationCreate,
+    NotificationTypeEnum,
+    WebSocketMessage,
+)
+from cpv3.modules.tasks.schemas import TaskWebhookEvent
+
+logger = logging.getLogger(__name__)
+
+JOB_TYPE_LABELS: dict[str, str] = {
+    "MEDIA_PROBE": "Анализ медиа",
+    "SILENCE_REMOVE": "Удаление тишины",
+    "SILENCE_DETECT": "Обнаружение тишины",
+    "SILENCE_APPLY": "Применение вырезок",
+    "MEDIA_CONVERT": "Конвертация",
+    "TRANSCRIPTION_GENERATE": "Транскрипция",
+    "CAPTIONS_GENERATE": "Генерация субтитров",
+}
+
+STATUS_TITLES: dict[str, str] = {
+    "RUNNING": "Задача запущена",
+    "DONE": "Задача завершена",
+    "FAILED": "Ошибка выполнения",
+}
+
+
+# ---------------------------------------------------------------------------
+# ConnectionManager — singleton for WebSocket pub/sub via Redis
+# ---------------------------------------------------------------------------
+
+_redis_client: aioredis.Redis | None = None
+
+
+async def _get_redis() -> aioredis.Redis:
+    global _redis_client
+    if _redis_client is None:
+        settings = get_settings()
+        _redis_client = aioredis.from_url(settings.redis_url, decode_responses=True)
+    return _redis_client
+
+
+def _channel_name(user_id: uuid.UUID) -> str:
+    return f"notifications:{user_id}"
+
+
+async def publish_to_user(user_id: uuid.UUID, message: WebSocketMessage) -> None:
+    """Publish a notification message to a user's Redis channel."""
+    redis = await _get_redis()
+    payload = message.model_dump_json()
+    await redis.publish(_channel_name(user_id), payload)
+
+
+async def subscribe_and_forward(websocket: object, user_id: uuid.UUID) -> None:
+    """Subscribe to a user's Redis channel and forward messages to WebSocket.
+
+    ``websocket`` must be a ``fastapi.WebSocket`` instance — typed as ``object``
+    to avoid importing FastAPI at module level.
+    """
+    from fastapi import WebSocket as _WS
+
+    ws: _WS = websocket  # type: ignore[assignment]
+    redis = await _get_redis()
+    pubsub = redis.pubsub()
+    await pubsub.subscribe(_channel_name(user_id))
+
+    try:
+        async for raw_message in pubsub.listen():
+            if raw_message["type"] != "message":
+                continue
+            await ws.send_text(raw_message["data"])
+    finally:
+        await pubsub.unsubscribe(_channel_name(user_id))
+        await pubsub.aclose()
+
+
+# ---------------------------------------------------------------------------
+# NotificationService
+# ---------------------------------------------------------------------------
+
+
+class NotificationService:
+    def __init__(self, session: AsyncSession) -> None:
+        self._repo = NotificationRepository(session)
+
+    async def create_task_notification(
+        self, *, user_id: uuid.UUID, job: Job, event: TaskWebhookEvent
+    ) -> None:
+        """Create a notification for a task status change and push via WebSocket."""
+        notification_type: NotificationTypeEnum | None = None
+        if event.status == "RUNNING":
+            notification_type = "task_progress"
+        elif event.status == "DONE":
+            notification_type = "task_complete"
+        elif event.status == "FAILED":
+            notification_type = "task_failed"
+
+        job_type_label = JOB_TYPE_LABELS.get(job.job_type, job.job_type)
+        now = utcnow()
+
+        # Only persist notifications on status changes (not progress-only updates)
+        notification_id: uuid.UUID | None = None
+        if notification_type is not None:
+            title = STATUS_TITLES.get(event.status or "", job_type_label)
+            notification = await self._repo.create(
+                NotificationCreate(
+                    user_id=user_id,
+                    job_id=job.id,
+                    project_id=job.project_id,
+                    notification_type=notification_type,
+                    title=title,
+                    message=event.error_message or event.current_message,
+                    payload={
+                        "job_type": job.job_type,
+                        "progress_pct": event.progress_pct,
+                        "status": event.status,
+                    },
+                )
+            )
+            notification_id = notification.id
+
+        # Always push WebSocket message (including progress-only updates)
+        ws_event = "task_update"
+        ws_message = WebSocketMessage(
+            event=ws_event,
+            notification_id=notification_id,
+            job_id=job.id,
+            project_id=job.project_id,
+            job_type=job.job_type,
+            status=event.status or job.status,
+            progress_pct=event.progress_pct or job.project_pct,
+            message=event.error_message or event.current_message or job.current_message,
+            title=job_type_label,
+            created_at=now,
+        )
+
+        try:
+            await publish_to_user(user_id, ws_message)
+        except Exception:
+            logger.exception("Failed to publish WebSocket notification for user %s", user_id)