Watch
1
0
Fork
You've already forked arc
0
forked from hesabix/arc
arc/hesabixAPI/app/services/support/support_realtime.py

130 lines
3.9 KiB
Python

from __future__ import annotations
import asyncio
import logging
from typing import Any, Dict, Iterable, List, Optional, Set
from fastapi import WebSocket
from sqlalchemy.orm import Session
from adapters.db.repositories.user_repo import UserRepository
from app.services.realtime import RealtimeManager
logger = logging.getLogger(__name__)
class SupportRealtimeManager(RealtimeManager):
"""WebSocket connections for /ws/support/tickets with ticket subscriptions."""
def __init__(self) -> None:
super().__init__()
self._ticket_watchers: Dict[int, Set[WebSocket]] = {}
async def subscribe_ticket(self, ticket_id: int, websocket: WebSocket) -> None:
self._ticket_watchers.setdefault(ticket_id, set()).add(websocket)
async def unsubscribe_ticket(self, ticket_id: int, websocket: WebSocket) -> None:
socks = self._ticket_watchers.get(ticket_id)
if not socks:
return
socks.discard(websocket)
if not socks:
self._ticket_watchers.pop(ticket_id, None)
async def disconnect(self, user_id: int, websocket: WebSocket) -> None:
for tid, socks in list(self._ticket_watchers.items()):
if websocket in socks:
socks.discard(websocket)
if not socks:
self._ticket_watchers.pop(tid, None)
await super().disconnect(user_id, websocket)
async def deliver_support_event(
self,
user_ids: Iterable[int],
ticket_id: Optional[int],
event: Dict[str, Any],
) -> None:
for uid in set(user_ids):
await self.send_to_user(uid, event)
if ticket_id is not None:
await self.send_to_ticket_watchers(ticket_id, event)
async def send_to_ticket_watchers(self, ticket_id: int, message: dict) -> None:
socks = list(self._ticket_watchers.get(ticket_id, set()))
for ws in socks:
try:
await ws.send_json(message)
except Exception:
pass
support_realtime_manager = SupportRealtimeManager()
def _support_operator_user_ids(db: Session) -> List[int]:
repo = UserRepository(db)
return [u.id for u in repo.get_support_operators()]
def _emit_async(coro) -> None:
try:
loop = asyncio.get_running_loop()
loop.create_task(coro)
except RuntimeError:
try:
asyncio.run(coro)
except Exception as exc:
logger.debug("support realtime emit failed: %s", exc)
async def _broadcast_event(
db: Session,
*,
event_type: str,
ticket_id: int,
payload: Optional[Dict[str, Any]] = None,
ticket_owner_id: Optional[int] = None,
assigned_operator_id: Optional[int] = None,
notify_all_operators: bool = False,
) -> None:
from app.services.support.support_realtime_fanout import broadcast_support_cross_worker
event: Dict[str, Any] = {
"type": "support",
"event": event_type,
"ticket_id": ticket_id,
"payload": payload or {},
}
recipients: List[int] = []
if ticket_owner_id:
recipients.append(ticket_owner_id)
if assigned_operator_id:
recipients.append(assigned_operator_id)
if notify_all_operators:
recipients.extend(_support_operator_user_ids(db))
await broadcast_support_cross_worker(recipients, ticket_id, event)
def emit_support_event(
db: Session,
*,
event_type: str,
ticket_id: int,
payload: Optional[Dict[str, Any]] = None,
ticket_owner_id: Optional[int] = None,
assigned_operator_id: Optional[int] = None,
notify_all_operators: bool = False,
) -> None:
_emit_async(
_broadcast_event(
db,
event_type=event_type,
ticket_id=ticket_id,
payload=payload,
ticket_owner_id=ticket_owner_id,
assigned_operator_id=assigned_operator_id,
notify_all_operators=notify_all_operators,
)
)