File size: 5,898 Bytes
9f05894 8defa71 9f05894 5a6229e 9f05894 5a6229e 9f05894 5a6229e 9f05894 5a6229e 9f05894 5a6229e 9f05894 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | """
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()
|