""" Consumer de `internacion.requests`: recibe por el bus del Core (M10) los mismos eventos que hoy llegan como webhooks REST directos de M1/M9/M2 (`app/routers/webhooks.py`). La cola y los 5 event types (`internacion.solicitud.creada`, `internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`, `internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`) ya están dados de alta y bindeados en el Core — ver `M6_DISEÑO.md` §7. Este módulo solo consume: cada mensaje se despacha a la misma función de servicio que usa el router REST equivalente, sin lógica de negocio nueva. Cirugía urgente queda fuera (excluida de esta migración, ver `M6_DISEÑO.md` §7): sigue siendo solo REST. Los endpoints REST entrantes siguen activos sin cambios durante la transición — cada equipo (M1/M9/M2) migra su emisor a su propio ritmo. """ import asyncio import json import logging import aio_pika from supabase import Client from app.config import settings from app.dependencies import get_db from app.schemas.reserva import CancelacionQuirofanoRequest from app.schemas.solicitud import ( AlertaEmergenciaRequest, AlertaResueltaRequest, AltaMedicaWebhook, SolicitudHceWebhook, ) from app.services import solicitud_service logger = logging.getLogger(__name__) def _handle_solicitud(db: Client, payload: dict) -> None: data = SolicitudHceWebhook.model_validate(payload) solicitud_service.recibir_solicitud(db, data) def _handle_alta_medica(db: Client, payload: dict) -> None: data = AltaMedicaWebhook.model_validate(payload) solicitud_service.procesar_alta_medica(db, data) def _handle_alerta_emergencia(db: Client, payload: dict) -> None: data = AlertaEmergenciaRequest.model_validate(payload) solicitud_service.procesar_alerta_emergencia(db, data.paciente_id) def _handle_alerta_resuelta(db: Client, payload: dict) -> None: data = AlertaResueltaRequest.model_validate(payload) solicitud_service.procesar_alerta_resuelta(db, data.paciente_id) def _handle_turno_cancelado(db: Client, payload: dict) -> None: # turno_id viaja en el payload del evento (en el webhook REST equivalente viene en el # path: POST /turnos/{turno_id}/cancelacion). CancelacionQuirofanoRequest ignora los # campos extra, así que se puede validar el resto del payload tal cual. turno_id = payload["turno_id"] data = CancelacionQuirofanoRequest.model_validate(payload) solicitud_service.cancelar_reserva_por_turno(db, turno_id, data.motivo) _HANDLERS = { "internacion.solicitud.creada": _handle_solicitud, "internacion.alta-medica.registrada": _handle_alta_medica, "internacion.alerta-emergencia.detectada": _handle_alerta_emergencia, "internacion.alerta-resuelta.notificada": _handle_alerta_resuelta, "internacion.turno.cancelado": _handle_turno_cancelado, } def dispatch(event_type_name: str, payload: dict) -> None: """ Despacha un mensaje ya parseado a la función de servicio correspondiente. Lanza `KeyError` si `event_type_name` no está mapeado, o lo que levante el servicio de negocio (`ValueError`, `HTTPException`, etc.) — `_on_message` decide ack/reject según el resultado. """ handler = _HANDLERS.get(event_type_name) if handler is None: raise KeyError(f"event_type_name no reconocido: {event_type_name!r}") db = get_db() handler(db, payload) async def _on_message(message: aio_pika.abc.AbstractIncomingMessage) -> None: try: envelope = json.loads(message.body) event_type_name = envelope["event_type_name"] payload = json.loads(envelope["payload"]) except (json.JSONDecodeError, KeyError, TypeError) as e: logger.error( "[M10→M6] Mensaje malformado en cola %s — se descarta sin procesar. Error: %s | body_preview=%r", settings.internacion_requests_queue, e, message.body[:200], ) await message.reject(requeue=False) return log_id = envelope.get("log_id") logger.info( "[M10→M6] Evento recibido: event_type=%r log_id=%s cola=%s", event_type_name, log_id, settings.internacion_requests_queue, ) try: dispatch(event_type_name, payload) except KeyError: logger.error( "[M10→M6] Evento desconocido: event_type=%r log_id=%s — se descarta (sin handler registrado)", event_type_name, log_id, ) await message.reject(requeue=False) return except Exception: logger.exception( "[M10→M6] Error procesando event_type=%r log_id=%s — se descarta (reject sin requeue)", event_type_name, log_id, ) await message.reject(requeue=False) return await message.ack() logger.info( "[M10→M6] Evento procesado OK: event_type=%r log_id=%s", event_type_name, log_id, ) async def run_consumer() -> None: """ Conecta a RabbitMQ y consume `internacion.requests` indefinidamente. Pensado para correr como task de asyncio en el lifespan de FastAPI (`app/main.py`), gateado por `settings.rabbitmq_consumer_enabled`. """ connection = await aio_pika.connect_robust( host=settings.rabbitmq_host, port=settings.rabbitmq_port, login=settings.core_service_email, password=settings.core_service_password, virtualhost=settings.rabbitmq_vhost, ) async with connection: channel = await connection.channel() await channel.set_qos(prefetch_count=10) # passive=True: la cola ya existe (creada vía POST /rabbit/queues del Core, con # su propia DLQ) — no la redeclaramos con propiedades propias. queue = await channel.declare_queue(settings.internacion_requests_queue, passive=True) await queue.consume(_on_message) await asyncio.Future()