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()