Spaces:
Runtime error
Runtime error
Merge pull request #8 from MateFerreyra/jps/impl-eventos
Browse filesImplementacion cola de eventos para informacion entrante de otros modulos
- .env.example +18 -0
- app/config.py +28 -0
- app/integrations/core_events.py +33 -0
- app/integrations/facturacion.py +9 -27
- app/integrations/hce.py +17 -2
- app/integrations/monitoreo.py +14 -2
- app/integrations/rabbit_consumer.py +134 -0
- app/main.py +14 -0
- app/services/solicitud_service.py +6 -13
- documentation/M6_DISEÑO.md +71 -1
- documentation/M6_EVENTOS_RABBITMQ.md +209 -0
- documentation/M6_INTEGRACION_M1_HCE.md +202 -0
- documentation/M6_INTEGRACION_M2_TURNOS.md +135 -0
- documentation/M6_INTEGRACION_M9_MONITOREO.md +170 -0
- requirements.txt +1 -0
- tests/test_core_events.py +145 -0
- tests/test_rabbit_consumer.py +180 -0
- tests/test_webhooks.py +46 -0
.env.example
CHANGED
|
@@ -43,3 +43,21 @@ M2_TURNOS_URL=http://modulo2:8002
|
|
| 43 |
M7_FACTURACION_URL=http://modulo7:8007
|
| 44 |
M9_MONITOREO_URL=http://modulo9:8009
|
| 45 |
M10_CORE_URL=http://modulo10:8010
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 43 |
M7_FACTURACION_URL=http://modulo7:8007
|
| 44 |
M9_MONITOREO_URL=http://modulo9:8009
|
| 45 |
M10_CORE_URL=http://modulo10:8010
|
| 46 |
+
|
| 47 |
+
# ─── Bus de eventos del Core (M10) ─────────────────────────────────────────
|
| 48 |
+
# RABBITMQ_CONSUMER_ENABLED=true levanta el consumer de internacion.requests
|
| 49 |
+
# (cola + 5 event types ya dados de alta en el Core, ver M6_DISEÑO.md §7).
|
| 50 |
+
# Las credenciales del broker son CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD.
|
| 51 |
+
RABBITMQ_CONSUMER_ENABLED=false
|
| 52 |
+
RABBITMQ_HOST=localhost
|
| 53 |
+
RABBITMQ_PORT=5672
|
| 54 |
+
RABBITMQ_VHOST=/
|
| 55 |
+
INTERNACION_REQUESTS_QUEUE=internacion.requests
|
| 56 |
+
|
| 57 |
+
# event_type_id de las notificaciones salientes de M6. Cada uno lo crea y
|
| 58 |
+
# comparte el módulo receptor (M1/M9/M7). Dejar comentado hasta tener el ID
|
| 59 |
+
# real: pydantic-settings no trata "KEY=" vacío como None, tira ValidationError.
|
| 60 |
+
# HCE_SOLICITUD_RESUELTA_EVENT_TYPE_ID=
|
| 61 |
+
# MONITOREO_ALTA_EVENT_TYPE_ID=
|
| 62 |
+
# MONITOREO_BAJA_EVENT_TYPE_ID=
|
| 63 |
+
# FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
|
app/config.py
CHANGED
|
@@ -52,5 +52,33 @@ class Settings(BaseSettings):
|
|
| 52 |
# Si True, no llama a módulos externos (útil para desarrollo local sin stack completo)
|
| 53 |
mock_external_services: bool = True
|
| 54 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 55 |
|
| 56 |
settings = Settings()
|
|
|
|
| 52 |
# Si True, no llama a módulos externos (útil para desarrollo local sin stack completo)
|
| 53 |
mock_external_services: bool = True
|
| 54 |
|
| 55 |
+
# ─── Bus de eventos del Core (M10): entrante ────────────────────────────
|
| 56 |
+
# M6 consume su propia cola de requests (`app/integrations/rabbit_consumer.py`),
|
| 57 |
+
# creada una vez en el Core (`POST /rabbit/queues`) — ver `M6_DISEÑO.md` §7.
|
| 58 |
+
# Las credenciales son las mismas que la cuenta de servicio ya usa contra el
|
| 59 |
+
# Core (`core_service_email`/`core_service_password`): ese email ya está
|
| 60 |
+
# provisionado como usuario de RabbitMQ. Host/puerto/vhost del broker
|
| 61 |
+
# compartido quedan pendientes de conseguir con el equipo de Core.
|
| 62 |
+
rabbitmq_host: str = "localhost"
|
| 63 |
+
rabbitmq_port: int = 5672
|
| 64 |
+
rabbitmq_vhost: str = "/"
|
| 65 |
+
internacion_requests_queue: str = "internacion.requests"
|
| 66 |
+
|
| 67 |
+
# Apaga el consumer por default: sin esto, dev/tests intentarían conectar contra
|
| 68 |
+
# `rabbitmq_host` (default "localhost") en cada arranque de la app, sin necesidad.
|
| 69 |
+
# Activar cuando se tenga el host/puerto/vhost real del broker compartido.
|
| 70 |
+
rabbitmq_consumer_enabled: bool = False
|
| 71 |
+
|
| 72 |
+
# ─── Bus de eventos del Core (M10): saliente ────────────────────────────
|
| 73 |
+
# `event_type_id` de las notificaciones que M6 publica hacia M1/M9/M7
|
| 74 |
+
# (`app/integrations/core_events.py::publish_event`). Cada uno lo crea y
|
| 75 |
+
# posee el módulo receptor, no M6 — quedan en `None` hasta que compartan el
|
| 76 |
+
# ID real. Mientras sea `None`, `publish_event` no dispara ningún request;
|
| 77 |
+
# la notificación sigue saliendo solo por el webhook REST directo actual.
|
| 78 |
+
hce_solicitud_resuelta_event_type_id: int | None = None
|
| 79 |
+
monitoreo_alta_event_type_id: int | None = None
|
| 80 |
+
monitoreo_baja_event_type_id: int | None = None
|
| 81 |
+
facturacion_cama_lista_event_type_id: int | None = None
|
| 82 |
+
|
| 83 |
|
| 84 |
settings = Settings()
|
app/integrations/core_events.py
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Publicación de eventos salientes al bus del Core (M10): `POST /events/log`.
|
| 3 |
+
|
| 4 |
+
Cada notificación saliente de M6 (SOLICITUD_RESUELTA a M1, ALTA_MONITOREO/
|
| 5 |
+
BAJA_MONITOREO a M9, CAMA_LISTA a M7) apunta a un `event_type_id` que crea y
|
| 6 |
+
posee el módulo receptor, no M6 (ver `M6_DISEÑO.md` §7). Hasta que cada equipo
|
| 7 |
+
comparta su ID real, la settings correspondiente queda en `None` y
|
| 8 |
+
`publish_event` es un no-op explícito — no bloquea el flujo de negocio ni
|
| 9 |
+
genera tráfico contra el Core. El día que llegue el ID real, alcanza con
|
| 10 |
+
cargarlo en config: el código no cambia.
|
| 11 |
+
"""
|
| 12 |
+
import json
|
| 13 |
+
import logging
|
| 14 |
+
|
| 15 |
+
from app.config import settings
|
| 16 |
+
from app.integrations._base import _post
|
| 17 |
+
|
| 18 |
+
logger = logging.getLogger(__name__)
|
| 19 |
+
|
| 20 |
+
|
| 21 |
+
def publish_event(event_type_id: int | None, payload: dict) -> bool:
|
| 22 |
+
if event_type_id is None:
|
| 23 |
+
logger.info(
|
| 24 |
+
"Evento no publicado (event_type_id todavía no configurado): %s", payload
|
| 25 |
+
)
|
| 26 |
+
return True
|
| 27 |
+
|
| 28 |
+
body = {
|
| 29 |
+
"event_type_id": event_type_id,
|
| 30 |
+
"publisher_module": "internacion",
|
| 31 |
+
"payload": json.dumps(payload),
|
| 32 |
+
}
|
| 33 |
+
return _post(f"{settings.m10_core_url}/events/log", body) is not None
|
app/integrations/facturacion.py
CHANGED
|
@@ -8,6 +8,7 @@ M7 directamente de M1/HCE. M6 no actúa de intermediario de esa información.
|
|
| 8 |
from datetime import date, datetime, timezone
|
| 9 |
|
| 10 |
from app.config import settings
|
|
|
|
| 11 |
from app.integrations._base import _post
|
| 12 |
|
| 13 |
|
|
@@ -18,6 +19,11 @@ def notify_cama_lista(cama_id: int, paciente_id: int) -> bool:
|
|
| 18 |
`idEventoExterno` es la clave de idempotencia que usa M7: la derivamos de forma estable
|
| 19 |
(cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
|
| 20 |
alta duplicada en facturación.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 21 |
"""
|
| 22 |
if settings.mock_external_services:
|
| 23 |
return True
|
|
@@ -29,32 +35,8 @@ def notify_cama_lista(cama_id: int, paciente_id: int) -> bool:
|
|
| 29 |
"paciente_id": paciente_id,
|
| 30 |
"timestamp_evento": datetime.now(timezone.utc).isoformat(),
|
| 31 |
}
|
| 32 |
-
|
| 33 |
f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload
|
| 34 |
) is not None
|
| 35 |
-
|
| 36 |
-
|
| 37 |
-
def notify_cierre_cama(cama_id: int, paciente_id: int) -> bool:
|
| 38 |
-
"""
|
| 39 |
-
Avisa a M7 que debe cerrar la facturación de la cama tras un alta médica.
|
| 40 |
-
|
| 41 |
-
Se invoca ANTES del cambio de estado de la cama: el alta depende de que M7 confirme
|
| 42 |
-
el cierre. `idEventoExterno` es la clave de idempotencia (cama + paciente + fecha).
|
| 43 |
-
"""
|
| 44 |
-
if settings.mock_external_services:
|
| 45 |
-
print(
|
| 46 |
-
f"[SIMULACION] Request a M7 Facturación → cierre de cama "
|
| 47 |
-
f"{cama_id} (paciente {paciente_id})"
|
| 48 |
-
)
|
| 49 |
-
return True
|
| 50 |
-
id_evento_externo = f"M6-CIERRE-CAMA-{cama_id}-{paciente_id}-{date.today().isoformat()}"
|
| 51 |
-
payload = {
|
| 52 |
-
"evento": "CIERRE_CAMA",
|
| 53 |
-
"idEventoExterno": id_evento_externo,
|
| 54 |
-
"cama_id": cama_id,
|
| 55 |
-
"paciente_id": paciente_id,
|
| 56 |
-
"timestamp_evento": datetime.now(timezone.utc).isoformat(),
|
| 57 |
-
}
|
| 58 |
-
return _post(
|
| 59 |
-
f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cierre-cama", payload
|
| 60 |
-
) is not None
|
|
|
|
| 8 |
from datetime import date, datetime, timezone
|
| 9 |
|
| 10 |
from app.config import settings
|
| 11 |
+
from app.integrations import core_events
|
| 12 |
from app.integrations._base import _post
|
| 13 |
|
| 14 |
|
|
|
|
| 19 |
`idEventoExterno` es la clave de idempotencia que usa M7: la derivamos de forma estable
|
| 20 |
(cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
|
| 21 |
alta duplicada en facturación.
|
| 22 |
+
|
| 23 |
+
Además del webhook REST directo (sin cambios), publica el mismo evento al bus del Core
|
| 24 |
+
(CAMA_LISTA) vía `core_events.publish_event`. Es un no-op mientras
|
| 25 |
+
`facturacion_cama_lista_event_type_id` no esté configurado — M7 todavía no compartió
|
| 26 |
+
su `event_type_id` real (ver `M6_DISEÑO.md` §7).
|
| 27 |
"""
|
| 28 |
if settings.mock_external_services:
|
| 29 |
return True
|
|
|
|
| 35 |
"paciente_id": paciente_id,
|
| 36 |
"timestamp_evento": datetime.now(timezone.utc).isoformat(),
|
| 37 |
}
|
| 38 |
+
ok_rest = _post(
|
| 39 |
f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload
|
| 40 |
) is not None
|
| 41 |
+
core_events.publish_event(settings.facturacion_cama_lista_event_type_id, payload)
|
| 42 |
+
return ok_rest
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
app/integrations/hce.py
CHANGED
|
@@ -3,6 +3,7 @@ M1 HCE — contraindicaciones y movimientos de pacientes.
|
|
| 3 |
"""
|
| 4 |
from datetime import datetime, timezone
|
| 5 |
from app.config import settings
|
|
|
|
| 6 |
from app.integrations._base import _get, _post
|
| 7 |
|
| 8 |
|
|
@@ -42,7 +43,14 @@ def notify_resultado_solicitud(
|
|
| 42 |
resultado: str,
|
| 43 |
motivo: str | None = None,
|
| 44 |
) -> bool:
|
| 45 |
-
"""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 46 |
if settings.mock_external_services:
|
| 47 |
return True
|
| 48 |
payload = {
|
|
@@ -50,9 +58,16 @@ def notify_resultado_solicitud(
|
|
| 50 |
"motivo": motivo,
|
| 51 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 52 |
}
|
| 53 |
-
|
| 54 |
f"{settings.m1_hce_url}/api/v1/hce/solicitudes/{solicitud_hce_id}/resultado", payload
|
| 55 |
) is not None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 56 |
|
| 57 |
|
| 58 |
def notify_movimiento(
|
|
|
|
| 3 |
"""
|
| 4 |
from datetime import datetime, timezone
|
| 5 |
from app.config import settings
|
| 6 |
+
from app.integrations import core_events
|
| 7 |
from app.integrations._base import _get, _post
|
| 8 |
|
| 9 |
|
|
|
|
| 43 |
resultado: str,
|
| 44 |
motivo: str | None = None,
|
| 45 |
) -> bool:
|
| 46 |
+
"""
|
| 47 |
+
Notifica a M1 el resultado (APROBADA / RECHAZADA) de una solicitud. Retorna True si OK.
|
| 48 |
+
|
| 49 |
+
Además del webhook REST directo (sin cambios), publica el mismo evento al bus del Core
|
| 50 |
+
(SOLICITUD_RESUELTA) vía `core_events.publish_event`. Es un no-op mientras
|
| 51 |
+
`hce_solicitud_resuelta_event_type_id` no esté configurado — M1 todavía no compartió
|
| 52 |
+
su `event_type_id` real (ver `M6_DISEÑO.md` §7).
|
| 53 |
+
"""
|
| 54 |
if settings.mock_external_services:
|
| 55 |
return True
|
| 56 |
payload = {
|
|
|
|
| 58 |
"motivo": motivo,
|
| 59 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 60 |
}
|
| 61 |
+
ok_rest = _post(
|
| 62 |
f"{settings.m1_hce_url}/api/v1/hce/solicitudes/{solicitud_hce_id}/resultado", payload
|
| 63 |
) is not None
|
| 64 |
+
# El body REST no lleva solicitud_hce_id (va en el path); el evento del bus sí lo
|
| 65 |
+
# necesita, porque no hay URL que lo transporte implícitamente.
|
| 66 |
+
core_events.publish_event(
|
| 67 |
+
settings.hce_solicitud_resuelta_event_type_id,
|
| 68 |
+
{**payload, "solicitud_hce_id": solicitud_hce_id},
|
| 69 |
+
)
|
| 70 |
+
return ok_rest
|
| 71 |
|
| 72 |
|
| 73 |
def notify_movimiento(
|
app/integrations/monitoreo.py
CHANGED
|
@@ -3,10 +3,17 @@ M9 Monitoreo — altas y bajas de pacientes en monitoreo.
|
|
| 3 |
"""
|
| 4 |
from datetime import datetime, timezone
|
| 5 |
from app.config import settings
|
|
|
|
| 6 |
from app.integrations._base import _post
|
| 7 |
|
| 8 |
|
| 9 |
def notify_alta(paciente_id: int) -> bool:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 10 |
if settings.mock_external_services:
|
| 11 |
return True
|
| 12 |
payload = {
|
|
@@ -14,12 +21,15 @@ def notify_alta(paciente_id: int) -> bool:
|
|
| 14 |
"paciente_id": paciente_id,
|
| 15 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 16 |
}
|
| 17 |
-
|
| 18 |
f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/alta-monitoreo", payload
|
| 19 |
) is not None
|
|
|
|
|
|
|
| 20 |
|
| 21 |
|
| 22 |
def notify_baja(paciente_id: int) -> bool:
|
|
|
|
| 23 |
if settings.mock_external_services:
|
| 24 |
print(f"[SIMULACION] Request a M9 Monitoreo → baja de paciente {paciente_id}")
|
| 25 |
return True
|
|
@@ -28,6 +38,8 @@ def notify_baja(paciente_id: int) -> bool:
|
|
| 28 |
"paciente_id": paciente_id,
|
| 29 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 30 |
}
|
| 31 |
-
|
| 32 |
f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/baja-monitoreo", payload
|
| 33 |
) is not None
|
|
|
|
|
|
|
|
|
| 3 |
"""
|
| 4 |
from datetime import datetime, timezone
|
| 5 |
from app.config import settings
|
| 6 |
+
from app.integrations import core_events
|
| 7 |
from app.integrations._base import _post
|
| 8 |
|
| 9 |
|
| 10 |
def notify_alta(paciente_id: int) -> bool:
|
| 11 |
+
"""
|
| 12 |
+
Además del webhook REST directo (sin cambios), publica el mismo evento al bus del
|
| 13 |
+
Core (ALTA_MONITOREO) vía `core_events.publish_event`. Es un no-op mientras
|
| 14 |
+
`monitoreo_alta_event_type_id` no esté configurado — M9 todavía no compartió su
|
| 15 |
+
`event_type_id` real (ver `M6_DISEÑO.md` §7).
|
| 16 |
+
"""
|
| 17 |
if settings.mock_external_services:
|
| 18 |
return True
|
| 19 |
payload = {
|
|
|
|
| 21 |
"paciente_id": paciente_id,
|
| 22 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 23 |
}
|
| 24 |
+
ok_rest = _post(
|
| 25 |
f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/alta-monitoreo", payload
|
| 26 |
) is not None
|
| 27 |
+
core_events.publish_event(settings.monitoreo_alta_event_type_id, payload)
|
| 28 |
+
return ok_rest
|
| 29 |
|
| 30 |
|
| 31 |
def notify_baja(paciente_id: int) -> bool:
|
| 32 |
+
"""Mismo esquema que `notify_alta`, para BAJA_MONITOREO."""
|
| 33 |
if settings.mock_external_services:
|
| 34 |
print(f"[SIMULACION] Request a M9 Monitoreo → baja de paciente {paciente_id}")
|
| 35 |
return True
|
|
|
|
| 38 |
"paciente_id": paciente_id,
|
| 39 |
"timestamp": datetime.now(timezone.utc).isoformat(),
|
| 40 |
}
|
| 41 |
+
ok_rest = _post(
|
| 42 |
f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/baja-monitoreo", payload
|
| 43 |
) is not None
|
| 44 |
+
core_events.publish_event(settings.monitoreo_baja_event_type_id, payload)
|
| 45 |
+
return ok_rest
|
app/integrations/rabbit_consumer.py
ADDED
|
@@ -0,0 +1,134 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Consumer de `internacion.requests`: recibe por el bus del Core (M10) los mismos eventos
|
| 3 |
+
que hoy llegan como webhooks REST directos de M1/M9/M2 (`app/routers/webhooks.py`).
|
| 4 |
+
|
| 5 |
+
La cola y los 5 event types (`internacion.solicitud.creada`,
|
| 6 |
+
`internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`,
|
| 7 |
+
`internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`) ya están dados de
|
| 8 |
+
alta y bindeados en el Core — ver `M6_DISEÑO.md` §7. Este módulo solo consume: cada
|
| 9 |
+
mensaje se despacha a la misma función de servicio que usa el router REST equivalente, sin
|
| 10 |
+
lógica de negocio nueva. Cirugía urgente queda fuera (excluida de esta migración, ver
|
| 11 |
+
`M6_DISEÑO.md` §7): sigue siendo solo REST.
|
| 12 |
+
|
| 13 |
+
Los endpoints REST entrantes siguen activos sin cambios durante la transición — cada
|
| 14 |
+
equipo (M1/M9/M2) migra su emisor a su propio ritmo.
|
| 15 |
+
"""
|
| 16 |
+
import asyncio
|
| 17 |
+
import json
|
| 18 |
+
import logging
|
| 19 |
+
|
| 20 |
+
import aio_pika
|
| 21 |
+
from supabase import Client
|
| 22 |
+
|
| 23 |
+
from app.config import settings
|
| 24 |
+
from app.dependencies import get_db
|
| 25 |
+
from app.schemas.reserva import CancelacionQuirofanoRequest
|
| 26 |
+
from app.schemas.solicitud import (
|
| 27 |
+
AlertaEmergenciaRequest,
|
| 28 |
+
AlertaResueltaRequest,
|
| 29 |
+
AltaMedicaWebhook,
|
| 30 |
+
SolicitudHceWebhook,
|
| 31 |
+
)
|
| 32 |
+
from app.services import solicitud_service
|
| 33 |
+
|
| 34 |
+
logger = logging.getLogger(__name__)
|
| 35 |
+
|
| 36 |
+
|
| 37 |
+
def _handle_solicitud(db: Client, payload: dict) -> None:
|
| 38 |
+
data = SolicitudHceWebhook.model_validate(payload)
|
| 39 |
+
solicitud_service.recibir_solicitud(db, data)
|
| 40 |
+
|
| 41 |
+
|
| 42 |
+
def _handle_alta_medica(db: Client, payload: dict) -> None:
|
| 43 |
+
data = AltaMedicaWebhook.model_validate(payload)
|
| 44 |
+
solicitud_service.procesar_alta_medica(db, data.paciente_id)
|
| 45 |
+
|
| 46 |
+
|
| 47 |
+
def _handle_alerta_emergencia(db: Client, payload: dict) -> None:
|
| 48 |
+
data = AlertaEmergenciaRequest.model_validate(payload)
|
| 49 |
+
solicitud_service.procesar_alerta_emergencia(db, data.paciente_id)
|
| 50 |
+
|
| 51 |
+
|
| 52 |
+
def _handle_alerta_resuelta(db: Client, payload: dict) -> None:
|
| 53 |
+
data = AlertaResueltaRequest.model_validate(payload)
|
| 54 |
+
solicitud_service.procesar_alerta_resuelta(db, data.paciente_id)
|
| 55 |
+
|
| 56 |
+
|
| 57 |
+
def _handle_turno_cancelado(db: Client, payload: dict) -> None:
|
| 58 |
+
# turno_id viaja en el payload del evento (en el webhook REST equivalente viene en el
|
| 59 |
+
# path: POST /turnos/{turno_id}/cancelacion). CancelacionQuirofanoRequest ignora los
|
| 60 |
+
# campos extra, así que se puede validar el resto del payload tal cual.
|
| 61 |
+
turno_id = payload["turno_id"]
|
| 62 |
+
data = CancelacionQuirofanoRequest.model_validate(payload)
|
| 63 |
+
solicitud_service.cancelar_reserva_por_turno(db, turno_id, data.motivo)
|
| 64 |
+
|
| 65 |
+
|
| 66 |
+
_HANDLERS = {
|
| 67 |
+
"internacion.solicitud.creada": _handle_solicitud,
|
| 68 |
+
"internacion.alta-medica.registrada": _handle_alta_medica,
|
| 69 |
+
"internacion.alerta-emergencia.detectada": _handle_alerta_emergencia,
|
| 70 |
+
"internacion.alerta-resuelta.notificada": _handle_alerta_resuelta,
|
| 71 |
+
"internacion.turno.cancelado": _handle_turno_cancelado,
|
| 72 |
+
}
|
| 73 |
+
|
| 74 |
+
|
| 75 |
+
def dispatch(event_type_name: str, payload: dict) -> None:
|
| 76 |
+
"""
|
| 77 |
+
Despacha un mensaje ya parseado a la función de servicio correspondiente.
|
| 78 |
+
Lanza `KeyError` si `event_type_name` no está mapeado, o lo que levante el servicio de
|
| 79 |
+
negocio (`ValueError`, `HTTPException`, etc.) — `_on_message` decide ack/reject según
|
| 80 |
+
el resultado.
|
| 81 |
+
"""
|
| 82 |
+
handler = _HANDLERS.get(event_type_name)
|
| 83 |
+
if handler is None:
|
| 84 |
+
raise KeyError(f"event_type_name no reconocido: {event_type_name!r}")
|
| 85 |
+
db = get_db()
|
| 86 |
+
handler(db, payload)
|
| 87 |
+
|
| 88 |
+
|
| 89 |
+
async def _on_message(message: aio_pika.abc.AbstractIncomingMessage) -> None:
|
| 90 |
+
try:
|
| 91 |
+
envelope = json.loads(message.body)
|
| 92 |
+
event_type_name = envelope["event_type_name"]
|
| 93 |
+
payload = json.loads(envelope["payload"])
|
| 94 |
+
except (json.JSONDecodeError, KeyError, TypeError) as e:
|
| 95 |
+
logger.error(
|
| 96 |
+
"Mensaje malformado en %s, se descarta: %s", settings.internacion_requests_queue, e
|
| 97 |
+
)
|
| 98 |
+
await message.reject(requeue=False)
|
| 99 |
+
return
|
| 100 |
+
|
| 101 |
+
try:
|
| 102 |
+
dispatch(event_type_name, payload)
|
| 103 |
+
except Exception:
|
| 104 |
+
logger.exception(
|
| 105 |
+
"Error procesando %s (log_id=%s) de %s",
|
| 106 |
+
event_type_name, envelope.get("log_id"), settings.internacion_requests_queue,
|
| 107 |
+
)
|
| 108 |
+
await message.reject(requeue=False)
|
| 109 |
+
return
|
| 110 |
+
|
| 111 |
+
await message.ack()
|
| 112 |
+
|
| 113 |
+
|
| 114 |
+
async def run_consumer() -> None:
|
| 115 |
+
"""
|
| 116 |
+
Conecta a RabbitMQ y consume `internacion.requests` indefinidamente. Pensado para
|
| 117 |
+
correr como task de asyncio en el lifespan de FastAPI (`app/main.py`), gateado por
|
| 118 |
+
`settings.rabbitmq_consumer_enabled`.
|
| 119 |
+
"""
|
| 120 |
+
connection = await aio_pika.connect_robust(
|
| 121 |
+
host=settings.rabbitmq_host,
|
| 122 |
+
port=settings.rabbitmq_port,
|
| 123 |
+
login=settings.core_service_email,
|
| 124 |
+
password=settings.core_service_password,
|
| 125 |
+
virtualhost=settings.rabbitmq_vhost,
|
| 126 |
+
)
|
| 127 |
+
async with connection:
|
| 128 |
+
channel = await connection.channel()
|
| 129 |
+
await channel.set_qos(prefetch_count=10)
|
| 130 |
+
# passive=True: la cola ya existe (creada vía POST /rabbit/queues del Core, con
|
| 131 |
+
# su propia DLQ) — no la redeclaramos con propiedades propias.
|
| 132 |
+
queue = await channel.declare_queue(settings.internacion_requests_queue, passive=True)
|
| 133 |
+
await queue.consume(_on_message)
|
| 134 |
+
await asyncio.Future()
|
app/main.py
CHANGED
|
@@ -3,6 +3,8 @@ Health Grid - Módulo 6: Internación y Gestión de Camas
|
|
| 3 |
API REST: http://localhost:8006/api/v1
|
| 4 |
"""
|
| 5 |
|
|
|
|
|
|
|
| 6 |
import logging
|
| 7 |
from contextlib import asynccontextmanager
|
| 8 |
from fastapi import FastAPI, Request, status
|
|
@@ -11,6 +13,7 @@ from fastapi.responses import JSONResponse
|
|
| 11 |
|
| 12 |
from app.config import settings
|
| 13 |
from app.dependencies import create_access_token
|
|
|
|
| 14 |
|
| 15 |
from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
|
| 16 |
from app.routers.webhooks import router_turnos
|
|
@@ -29,8 +32,19 @@ logging.basicConfig(
|
|
| 29 |
@asynccontextmanager
|
| 30 |
async def lifespan(app: FastAPI):
|
| 31 |
logger.info("Conectado a Supabase — listo para operar")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 32 |
yield
|
| 33 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 34 |
|
| 35 |
# ─── App ───────────────────────────────────────────────────────────────────
|
| 36 |
|
|
|
|
| 3 |
API REST: http://localhost:8006/api/v1
|
| 4 |
"""
|
| 5 |
|
| 6 |
+
import asyncio
|
| 7 |
+
import contextlib
|
| 8 |
import logging
|
| 9 |
from contextlib import asynccontextmanager
|
| 10 |
from fastapi import FastAPI, Request, status
|
|
|
|
| 13 |
|
| 14 |
from app.config import settings
|
| 15 |
from app.dependencies import create_access_token
|
| 16 |
+
from app.integrations import rabbit_consumer
|
| 17 |
|
| 18 |
from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
|
| 19 |
from app.routers.webhooks import router_turnos
|
|
|
|
| 32 |
@asynccontextmanager
|
| 33 |
async def lifespan(app: FastAPI):
|
| 34 |
logger.info("Conectado a Supabase — listo para operar")
|
| 35 |
+
|
| 36 |
+
consumer_task = None
|
| 37 |
+
if settings.rabbitmq_consumer_enabled:
|
| 38 |
+
logger.info("Iniciando consumer de %s", settings.internacion_requests_queue)
|
| 39 |
+
consumer_task = asyncio.create_task(rabbit_consumer.run_consumer())
|
| 40 |
+
|
| 41 |
yield
|
| 42 |
|
| 43 |
+
if consumer_task is not None:
|
| 44 |
+
consumer_task.cancel()
|
| 45 |
+
with contextlib.suppress(asyncio.CancelledError):
|
| 46 |
+
await consumer_task
|
| 47 |
+
|
| 48 |
|
| 49 |
# ─── App ───────────────────────────────────────────────────────────────────
|
| 50 |
|
app/services/solicitud_service.py
CHANGED
|
@@ -15,7 +15,7 @@ from app.crud import solicitud as solicitud_crud
|
|
| 15 |
from app.crud import cama as cama_crud
|
| 16 |
from app.crud import reserva as reserva_crud
|
| 17 |
from app.crud import auditoria as auditoria_crud
|
| 18 |
-
from app.integrations import hce, monitoreo, core
|
| 19 |
from app.schemas.enums import (
|
| 20 |
EntidadAuditoriaEnum,
|
| 21 |
TipoEventoAuditoriaEnum,
|
|
@@ -323,18 +323,11 @@ def procesar_alta_medica(db: Client, paciente_id: int) -> Cama:
|
|
| 323 |
status_code=404,
|
| 324 |
detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama asignada al paciente"},
|
| 325 |
)
|
| 326 |
-
#
|
| 327 |
-
# el
|
| 328 |
-
|
| 329 |
-
|
| 330 |
-
|
| 331 |
-
detail={"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo cerrar la cama en Facturación (M7)"},
|
| 332 |
-
)
|
| 333 |
-
if not monitoreo.notify_baja(paciente_id):
|
| 334 |
-
raise HTTPException(
|
| 335 |
-
status_code=502,
|
| 336 |
-
detail={"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo dar de baja el monitoreo (M9)"},
|
| 337 |
-
)
|
| 338 |
|
| 339 |
estado_previo = cama.estado
|
| 340 |
cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
|
|
|
|
| 15 |
from app.crud import cama as cama_crud
|
| 16 |
from app.crud import reserva as reserva_crud
|
| 17 |
from app.crud import auditoria as auditoria_crud
|
| 18 |
+
from app.integrations import hce, monitoreo, core
|
| 19 |
from app.schemas.enums import (
|
| 20 |
EntidadAuditoriaEnum,
|
| 21 |
TipoEventoAuditoriaEnum,
|
|
|
|
| 323 |
status_code=404,
|
| 324 |
detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama asignada al paciente"},
|
| 325 |
)
|
| 326 |
+
# Notificación asincrónica (fire-and-forget, M6_DISEÑO.md §2): M6 informa a M9 que
|
| 327 |
+
# el paciente sale de monitoreo, pero que M9 esté caído no debe revertir el alta.
|
| 328 |
+
# La notificación real a M7 (CAMA_LISTA) ocurre más adelante, al completar la
|
| 329 |
+
# limpieza (cama_service.py), también fire-and-forget.
|
| 330 |
+
monitoreo.notify_baja(paciente_id)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 331 |
|
| 332 |
estado_previo = cama.estado
|
| 333 |
cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
|
documentation/M6_DISEÑO.md
CHANGED
|
@@ -248,7 +248,6 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
|
|
| 248 |
|
| 249 |
| Módulo | Endpoint | Cuándo |
|
| 250 |
|--------|----------|--------|
|
| 251 |
-
| M10 Core | `POST /auth/validate-token` | En cada request (middleware JWT) |
|
| 252 |
| M10 Core | `GET /usuarios/{pacienteId}` | Al aprobar una internación (datos del paciente) |
|
| 253 |
| M1 HCE | `GET /hce/pacientes/{pacienteId}/contraindicaciones` | Al aprobar una internación |
|
| 254 |
| M1 HCE | `GET /hce/pacientes/{pacienteId}` | Al mostrar el detalle del paciente internado en una cama |
|
|
@@ -261,6 +260,64 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
|
|
| 261 |
|
| 262 |
Todos los endpoints `[EXT]` (los que expone otro módulo) se mockean localmente para la 2da entrega. El mock vive en la capa de clientes HTTP: la misma interfaz que en producción, pero devolviendo respuestas canned. Esto permite que la 3ra entrega solo cambie la URL base del cliente, sin tocar la lógica de servicios.
|
| 263 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 264 |
---
|
| 265 |
|
| 266 |
## 8. Contrato de API (recursos propios)
|
|
@@ -434,3 +491,16 @@ No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT d
|
|
| 434 |
26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
|
| 435 |
27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
|
| 436 |
28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 248 |
|
| 249 |
| Módulo | Endpoint | Cuándo |
|
| 250 |
|--------|----------|--------|
|
|
|
|
| 251 |
| M10 Core | `GET /usuarios/{pacienteId}` | Al aprobar una internación (datos del paciente) |
|
| 252 |
| M1 HCE | `GET /hce/pacientes/{pacienteId}/contraindicaciones` | Al aprobar una internación |
|
| 253 |
| M1 HCE | `GET /hce/pacientes/{pacienteId}` | Al mostrar el detalle del paciente internado en una cama |
|
|
|
|
| 260 |
|
| 261 |
Todos los endpoints `[EXT]` (los que expone otro módulo) se mockean localmente para la 2da entrega. El mock vive en la capa de clientes HTTP: la misma interfaz que en producción, pero devolviendo respuestas canned. Esto permite que la 3ra entrega solo cambie la URL base del cliente, sin tocar la lógica de servicios.
|
| 262 |
|
| 263 |
+
### 7.5 Bus de eventos del Core (M10): migración en curso
|
| 264 |
+
|
| 265 |
+
Los webhooks REST de §7.1 tienen dos problemas: (1) exigen `get_current_user` (JWT de
|
| 266 |
+
usuario) pero M1/M9/M2 no tienen un usuario humano detrás de un webhook — no hay forma
|
| 267 |
+
legítima de que llamen hoy sin credenciales que no deberían tener; (2) son integraciones
|
| 268 |
+
point-to-point ad hoc, cuando el Core ya expone un bus de eventos pensado para esto
|
| 269 |
+
(`documentation/integrations/M10_integration.md`, "Tutorial: Comunicación entre
|
| 270 |
+
microservicios"): *"RabbitMQ para escuchar; Core para configurar y publicar."* Migrar a
|
| 271 |
+
la cola resuelve el problema de auth (se consume con credenciales RabbitMQ propias, no un
|
| 272 |
+
JWT de usuario) y suma at-least-once delivery + DLQ que hoy no existen.
|
| 273 |
+
|
| 274 |
+
**Lado entrante — ya migrado, en paralelo con REST.** Cola propia `internacion.requests`
|
| 275 |
+
(+ `internacion.requests.dlq`) y 5 event types bindeados, dados de alta en el Core real:
|
| 276 |
+
|
| 277 |
+
| Evento | Id | Reemplaza (REST) | Emisor | Payload |
|
| 278 |
+
|---|---|---|---|---|
|
| 279 |
+
| `internacion.solicitud.creada` | 14 | `POST /webhooks/hce/solicitud` | M1 | `SolicitudHceWebhook` |
|
| 280 |
+
| `internacion.alta-medica.registrada` | 15 | `POST /webhooks/hce/alta-medica` | M1 | `AltaMedicaWebhook` |
|
| 281 |
+
| `internacion.alerta-emergencia.detectada` | 16 | `POST /webhooks/monitoreo/alerta-emergencia` | M9 | `AlertaEmergenciaRequest` |
|
| 282 |
+
| `internacion.alerta-resuelta.notificada` | 17 | `POST /webhooks/monitoreo/alerta-resuelta` | M9 | `AlertaResueltaRequest` |
|
| 283 |
+
| `internacion.turno.cancelado` | 18 | `POST /turnos/{turnoId}/cancelacion` | M2 | `CancelacionQuirofanoRequest` + `turno_id` (viaja en el payload; en el REST equivalente viene del path) |
|
| 284 |
+
|
| 285 |
+
Los 5 son notificaciones fire-and-forget (sin `correlation_id`/`response_event_id`), y
|
| 286 |
+
reusan tal cual los schemas Pydantic del webhook REST equivalente. El consumer
|
| 287 |
+
(`app/integrations/rabbit_consumer.py`) despacha por `event_type_name` a la misma función
|
| 288 |
+
de servicio que ya usa el router REST (`solicitud_service.recibir_solicitud`,
|
| 289 |
+
`procesar_alta_medica`, `procesar_alerta_emergencia`, `procesar_alerta_resuelta`,
|
| 290 |
+
`cancelar_reserva_por_turno`) — cero lógica de negocio nueva, incluida la deduplicación
|
| 291 |
+
por id de origen (§6). Gateado por `settings.rabbitmq_consumer_enabled` (default `False`:
|
| 292 |
+
falta el host/puerto/vhost real del broker compartido — las credenciales sí son las
|
| 293 |
+
mismas `core_service_email`/`core_service_password` de siempre).
|
| 294 |
+
|
| 295 |
+
**Los endpoints REST de §7.1 se mantienen activos sin cambios** durante la transición —
|
| 296 |
+
cada equipo (M1/M9/M2) migra su emisor a su propio ritmo; se retiran recién cuando los
|
| 297 |
+
tres confirmen que publican por la cola.
|
| 298 |
+
|
| 299 |
+
**Cirugía urgente queda excluida** de esta migración: `POST /webhooks/hce/cirugia-urgente`
|
| 300 |
+
devuelve sincrónicamente qué quirófano/reserva se asignó y qué reservas se desplazaron —
|
| 301 |
+
no hay hoy un canal async equivalente. Migrarla requiere antes acordar con M1 un evento de
|
| 302 |
+
respuesta (`correlation_id` + `response_event_id`). Sigue siendo solo REST.
|
| 303 |
+
|
| 304 |
+
**Lado saliente — código listo, apagado hasta tener los `event_type_id` reales.** Las 4
|
| 305 |
+
notificaciones de §7.2 (`SOLICITUD_RESUELTA`, `ALTA_MONITOREO`, `BAJA_MONITOREO`,
|
| 306 |
+
`CAMA_LISTA`) siguen el mismo bus, pero el evento y la cola los crea y posee **el
|
| 307 |
+
receptor** (M1/M9/M7), no M6 — por la misma regla del tutorial que aplica al revés en
|
| 308 |
+
§7.1. M6 todavía no tiene esos `event_type_id` porque los equipos no respondieron.
|
| 309 |
+
|
| 310 |
+
En vez de crear infraestructura mock en el Core (tráfico real sin nadie consumiéndolo),
|
| 311 |
+
`app/integrations/core_events.py::publish_event(event_type_id, payload)` es un no-op
|
| 312 |
+
explícito mientras `event_type_id is None` (settings `hce_solicitud_resuelta_event_type_id`,
|
| 313 |
+
`monitoreo_alta_event_type_id`, `monitoreo_baja_event_type_id`,
|
| 314 |
+
`facturacion_cama_lista_event_type_id`, todas `None` por default). Las 4 funciones
|
| 315 |
+
`notify_*` (`hce.notify_resultado_solicitud`, `monitoreo.notify_alta`/`notify_baja`,
|
| 316 |
+
`facturacion.notify_cama_lista`) hacen **dual-write**: siguen llamando al webhook REST
|
| 317 |
+
directo exactamente como hoy (sin cambios observables) y además llaman a `publish_event`,
|
| 318 |
+
que hoy no dispara nada. El día que cada equipo comparta su ID, se carga en config — sin
|
| 319 |
+
tocar código — y empieza a salir por las dos vías hasta coordinar cuándo retirar la REST.
|
| 320 |
+
|
| 321 |
---
|
| 322 |
|
| 323 |
## 8. Contrato de API (recursos propios)
|
|
|
|
| 491 |
26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
|
| 492 |
27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
|
| 493 |
28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
|
| 494 |
+
|
| 495 |
+
### 14.6 Migración de webhooks entrantes al bus de eventos del Core (2026-07)
|
| 496 |
+
|
| 497 |
+
29. **Cola `internacion.requests` + 5 event types dados de alta en el Core real** (ids 14–18: `internacion.solicitud.creada`, `internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`, `internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`), bindeados a esa cola. Reemplazan, en paralelo con REST durante la transición, a los webhooks entrantes de §7.1 (excepto cirugía urgente, excluida — ver §7.5).
|
| 498 |
+
30. **Nuevo consumer `app/integrations/rabbit_consumer.py`** (`aio-pika`, gateado por `settings.rabbitmq_consumer_enabled`, default `False` hasta tener host/puerto/vhost real del broker). Despacha por `event_type_name` a las mismas funciones de servicio que ya usa el router REST — sin lógica de negocio nueva.
|
| 499 |
+
31. **Nuevo publisher `app/integrations/core_events.py::publish_event`** para las 4 notificaciones salientes de §7.2. No-op explícito mientras el `event_type_id` correspondiente sea `None` (default hasta que M1/M9/M7 compartan el suyo — cada uno crea y posee su propio evento, no M6). Las 4 funciones `notify_*` (`hce.notify_resultado_solicitud`, `monitoreo.notify_alta`/`notify_baja`, `facturacion.notify_cama_lista`) quedan en dual-write: REST sin cambios + `publish_event` adicional.
|
| 500 |
+
32. **Sin infraestructura mock creada en el Core para el lado saliente.** Se descartó explícitamente crear event types/colas placeholder en el Core compartido para simular a M1/M9/M7 — hubiera generado tráfico real sin receptor. El código queda listo y probado; activar la publicación real es cambiar 4 valores de config, sin tocar código.
|
| 501 |
+
|
| 502 |
+
### 14.7 Eliminación de código zombie en la integración con M7/M9 (2026-07)
|
| 503 |
+
|
| 504 |
+
33. **Eliminado `facturacion.notify_cierre_cama`.** Apuntaba a `POST /api/v1/webhooks/internacion/cierre-cama`, un endpoint que nunca estuvo en la tabla de webhooks salientes (§7.2) ni pasó por la revisión contra el backend real de M7 que sí tuvo `notify_cama_lista` (changelog #14). Estaba activamente cableada en `procesar_alta_medica` y era **bloqueante**: `if not facturacion.notify_cierre_cama(...): raise 502` — con `mock_external_services=False` en producción, cualquier alta médica real hubiera fallado con `502` contra un endpoint que M7 nunca implementó. Sin test para el camino real (pasaba siempre por el atajo de `mock_external_services=True`).
|
| 505 |
+
34. **Corregido el gating bloqueante de `monitoreo.notify_baja` en `procesar_alta_medica`.** Era el único de los 5 call sites de `notify_alta`/`notify_baja` en todo el código que trataba la llamada como bloqueante (`if not ...: raise 502`); los otros 4 (`cama_service.py` ingreso/traslado, `solicitud_service.py` aprobar internación/traslado) ya la tratan fire-and-forget. Alineado con el resto del código y con el principio de §2 ("que el receptor esté caído no debe revertir el alta del paciente"): ahora es `monitoreo.notify_baja(paciente_id)` sin gate.
|
| 506 |
+
35. **El alta médica ya no depende de M7 ni M9 para completarse.** La notificación real a M7 (`CAMA_LISTA`) sigue ocurriendo, fire-and-forget, más adelante en el flujo (al completar la limpieza, `cama_service.py`). Blindado con tests: `test_alta_medica_ok_aunque_monitoreo_falle` y `test_alta_medica_no_llama_a_facturacion` (`tests/test_webhooks.py`).
|
documentation/M6_EVENTOS_RABBITMQ.md
ADDED
|
@@ -0,0 +1,209 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Bus de eventos del Core (M10): cola y eventos de M6
|
| 2 |
+
|
| 3 |
+
**Health Grid · Módulo 6 (Internación y Gestión de Camas)**
|
| 4 |
+
|
| 5 |
+
> Referencia completa de la infraestructura de RabbitMQ/eventos que M6 tiene dada de alta en el Core y de cómo se conecta con el código. Para el contrato genérico del bus (cómo crear colas/eventos/bindings, formato del envelope) ver [`integrations/M10_integration.md`](integrations/M10_integration.md). Para el porqué de la migración y su alcance, ver [`M6_DISEÑO.md`](M6_DISEÑO.md) §7.5.
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. Resumen
|
| 10 |
+
|
| 11 |
+
M6 recibe notificaciones de M1 (HCE), M9 (Monitoreo) y M2 (Turnos) por dos vías en paralelo durante la transición:
|
| 12 |
+
|
| 13 |
+
- **REST directo** (`app/routers/webhooks.py`) — el mecanismo original, sigue activo sin cambios.
|
| 14 |
+
- **Bus de eventos del Core** (RabbitMQ, configurado y creado vía la API del Core) — el mecanismo nuevo, hacia el que se está migrando.
|
| 15 |
+
|
| 16 |
+
Del lado saliente (M6 → M1/M9/M7), el código de publicación al bus ya está escrito y conectado, pero **apagado**: no hay tráfico real hasta que cada equipo receptor comparta su `event_type_id`.
|
| 17 |
+
|
| 18 |
+
Cirugía urgente (`POST /webhooks/hce/cirugia-urgente`) queda fuera de esta migración — sigue siendo solo REST (ver §5).
|
| 19 |
+
|
| 20 |
+
---
|
| 21 |
+
|
| 22 |
+
## 2. Infraestructura creada en el Core (real, ya ejecutada)
|
| 23 |
+
|
| 24 |
+
### 2.1 Cola
|
| 25 |
+
|
| 26 |
+
| Cola | Tipo | DLQ |
|
| 27 |
+
|---|---|---|
|
| 28 |
+
| `internacion.requests` | `requests` | `internacion.requests.dlq` |
|
| 29 |
+
|
| 30 |
+
Creada con:
|
| 31 |
+
|
| 32 |
+
```http
|
| 33 |
+
POST /rabbit/queues
|
| 34 |
+
Authorization: Bearer <token cuenta de servicio>
|
| 35 |
+
Content-Type: application/json
|
| 36 |
+
|
| 37 |
+
{ "queue_name": "internacion", "queue_type": "requests" }
|
| 38 |
+
```
|
| 39 |
+
|
| 40 |
+
M6 es un único consumer sobre esta cola; distingue el tipo de mensaje por `event_type_name` del envelope (ver §4), igual que antes distinguía por el path del webhook REST.
|
| 41 |
+
|
| 42 |
+
### 2.2 Event types entrantes (M1/M9/M2 → M6)
|
| 43 |
+
|
| 44 |
+
Los 5 eventos que otros módulos usan para mandarle "requests" a M6, todos bindeados a `internacion.requests`:
|
| 45 |
+
|
| 46 |
+
| `event_type_id` | `name` | Emisor | Reemplaza (REST) | Payload (schema Pydantic) |
|
| 47 |
+
|---|---|---|---|---|
|
| 48 |
+
| **14** | `internacion.solicitud.creada` | M1 HCE | `POST /webhooks/hce/solicitud` | `SolicitudHceWebhook` |
|
| 49 |
+
| **15** | `internacion.alta-medica.registrada` | M1 HCE | `POST /webhooks/hce/alta-medica` | `AltaMedicaWebhook` |
|
| 50 |
+
| **16** | `internacion.alerta-emergencia.detectada` | M9 Monitoreo | `POST /webhooks/monitoreo/alerta-emergencia` | `AlertaEmergenciaRequest` |
|
| 51 |
+
| **17** | `internacion.alerta-resuelta.notificada` | M9 Monitoreo | `POST /webhooks/monitoreo/alerta-resuelta` | `AlertaResueltaRequest` |
|
| 52 |
+
| **18** | `internacion.turno.cancelado` | M2 Turnos | `POST /turnos/{turnoId}/cancelacion` | `CancelacionQuirofanoRequest` + `turno_id` |
|
| 53 |
+
|
| 54 |
+
Todos `source_module: "internacion"`. Ninguno lleva `correlation_id`/`response_event_id`: son notificaciones fire-and-forget, no esperan respuesta.
|
| 55 |
+
|
| 56 |
+
**Nota sobre `internacion.turno.cancelado` (id 18):** en el REST equivalente, `turno_id` viaja en el path (`/turnos/{turnoId}/cancelacion`). Como el bus no tiene "path", el payload del evento **debe incluir** `turno_id` explícitamente junto al resto de los campos de `CancelacionQuirofanoRequest` (`motivo`, `tipo_cancelacion`, `timestamp`).
|
| 57 |
+
|
| 58 |
+
Creados con (uno por fila):
|
| 59 |
+
|
| 60 |
+
```http
|
| 61 |
+
POST /events/types
|
| 62 |
+
Authorization: Bearer <token cuenta de servicio>
|
| 63 |
+
Content-Type: application/json
|
| 64 |
+
|
| 65 |
+
{ "name": "internacion.solicitud.creada", "description": "...", "source_module": "internacion" }
|
| 66 |
+
```
|
| 67 |
+
|
| 68 |
+
### 2.3 Bindings
|
| 69 |
+
|
| 70 |
+
Los 5 event types de arriba están bindeados a `internacion.requests`:
|
| 71 |
+
|
| 72 |
+
```http
|
| 73 |
+
POST /rabbit/bindings
|
| 74 |
+
Authorization: Bearer <token cuenta de servicio>
|
| 75 |
+
Content-Type: application/json
|
| 76 |
+
|
| 77 |
+
{ "event_id": 14, "queue_name": "internacion.requests" }
|
| 78 |
+
```
|
| 79 |
+
|
| 80 |
+
(repetido para los ids 15, 16, 17 y 18)
|
| 81 |
+
|
| 82 |
+
### 2.4 Lo que NO se creó
|
| 83 |
+
|
| 84 |
+
No hay ninguna cola ni event type mock/placeholder para el lado saliente (§5). Se decidió explícitamente no generar infraestructura ni tráfico contra el Core compartido para simular a M1/M9/M7 — ver `M6_DISEÑO.md` §14.6, punto 32.
|
| 85 |
+
|
| 86 |
+
---
|
| 87 |
+
|
| 88 |
+
## 3. Credenciales y conexión
|
| 89 |
+
|
| 90 |
+
- **API REST del Core** (alta de colas/eventos/bindings, `POST /events/log`): cuenta de servicio de M6, `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD` (`.env`). Es la misma cuenta que M6 ya usa para las llamadas salientes a M1/M2/M7/M10 (`app/integrations/core_auth.py::get_service_token`).
|
| 91 |
+
- **Broker RabbitMQ** (consumo directo de la cola): **las mismas credenciales** — el email de la cuenta de servicio ya está provisionado como usuario de RabbitMQ (confirmado: `POST /rabbit/queues` y `POST /rabbit/bindings` exigen que el usuario autenticado exista como usuario de RabbitMQ, y ambas llamadas funcionaron).
|
| 92 |
+
- **Host/puerto/vhost del broker:** pendiente de conseguir con el equipo de Core — hoy son placeholders (`localhost:5672`, vhost `/`). Sin este dato, el consumer no puede conectar de verdad (ver §6).
|
| 93 |
+
|
| 94 |
+
---
|
| 95 |
+
|
| 96 |
+
## 4. Formato de los mensajes
|
| 97 |
+
|
| 98 |
+
El mensaje que llega por RabbitMQ tiene un envelope externo (lo arma el Core), y adentro un `payload` que viaja **como string JSON**:
|
| 99 |
+
|
| 100 |
+
```json
|
| 101 |
+
{
|
| 102 |
+
"event_type_id": 15,
|
| 103 |
+
"event_type_name": "internacion.alta-medica.registrada",
|
| 104 |
+
"source_module": "internacion",
|
| 105 |
+
"publisher_module": "hce",
|
| 106 |
+
"log_id": 89,
|
| 107 |
+
"payload": "{\"paciente_id\": 999, \"medico_firmante_id\": 1, \"tipo_alta\": \"ALTA_MEDICA\", \"timestamp\": \"2026-07-09T12:00:00Z\"}",
|
| 108 |
+
"published_at": "2026-07-10T01:24:06Z"
|
| 109 |
+
}
|
| 110 |
+
```
|
| 111 |
+
|
| 112 |
+
El consumer de M6 (§6) parsea primero el envelope, después el `payload` interno, y recién ahí valida contra el schema Pydantic correspondiente.
|
| 113 |
+
|
| 114 |
+
---
|
| 115 |
+
|
| 116 |
+
## 5. Qué queda fuera de esta migración
|
| 117 |
+
|
| 118 |
+
**Cirugía urgente** (`POST /webhooks/hce/cirugia-urgente`) no tiene evento en el bus. El webhook REST devuelve sincrónicamente qué quirófano/reserva se asignó y qué reservas se desplazaron; no existe hoy un canal de respuesta asíncrono equivalente. Migrarla requeriría acordar con M1 un evento de respuesta (`correlation_id` + `response_event_id`, como el patrón `billing`/`appointments` de `M10_integration.md`). Sigue siendo solo REST.
|
| 119 |
+
|
| 120 |
+
**Los 5 endpoints REST de `app/routers/webhooks.py` (equivalentes a los eventos de §2.2) se mantienen activos sin cambios** mientras dura la transición. No hay fecha de corte: se retiran cuando M1, M9 y M2 confirmen que ya publican por la cola.
|
| 121 |
+
|
| 122 |
+
---
|
| 123 |
+
|
| 124 |
+
## 6. Lado entrante: el consumer (`app/integrations/rabbit_consumer.py`)
|
| 125 |
+
|
| 126 |
+
Cliente async sobre `aio-pika`. Por cada mensaje de `internacion.requests`:
|
| 127 |
+
|
| 128 |
+
1. Parsea el envelope externo y extrae `event_type_name` y `payload` (como string).
|
| 129 |
+
2. Parsea `payload` con `json.loads`.
|
| 130 |
+
3. Despacha por `event_type_name` (`dispatch()`) a la **misma función de servicio** que usa el router REST — sin lógica de negocio nueva:
|
| 131 |
+
|
| 132 |
+
| `event_type_name` | Función de servicio |
|
| 133 |
+
|---|---|
|
| 134 |
+
| `internacion.solicitud.creada` | `solicitud_service.recibir_solicitud` |
|
| 135 |
+
| `internacion.alta-medica.registrada` | `solicitud_service.procesar_alta_medica` |
|
| 136 |
+
| `internacion.alerta-emergencia.detectada` | `solicitud_service.procesar_alerta_emergencia` |
|
| 137 |
+
| `internacion.alerta-resuelta.notificada` | `solicitud_service.procesar_alerta_resuelta` |
|
| 138 |
+
| `internacion.turno.cancelado` | `solicitud_service.cancelar_reserva_por_turno` |
|
| 139 |
+
|
| 140 |
+
4. Si el procesamiento fue exitoso, hace `ack`. Si el JSON es malformado, el `event_type_name` no está mapeado, o el servicio de negocio lanza una excepción, hace `reject(requeue=False)` — el mensaje cae a `internacion.requests.dlq` en vez de reintentarse en loop.
|
| 141 |
+
|
| 142 |
+
La deduplicación por id de origen (`solicitud_hce_id`, etc., exigida en `M6_DISEÑO.md` §6) sigue viviendo dentro de esas mismas funciones de servicio — no se reimplementó nada.
|
| 143 |
+
|
| 144 |
+
**Wiring:** `app/main.py` arranca `rabbit_consumer.run_consumer()` como task de `asyncio` en el `lifespan`, solo si `settings.rabbitmq_consumer_enabled` es `True` (default `False` — ver §3, falta el broker real). Al apagar la app, la task se cancela prolijamente.
|
| 145 |
+
|
| 146 |
+
**Verificado en vivo (2026-07):** se publicó un evento real contra el id 15 (`POST /events/log`) y se confirmó que `dispatch()` lo procesa de punta a punta: parseo → validación Pydantic → `procesar_alta_medica` → la cama pasa a `EN_LIMPIEZA` → `ack`. Esto prueba la lógica de consumo; falta conectar contra el broker real para que corra en producción.
|
| 147 |
+
|
| 148 |
+
---
|
| 149 |
+
|
| 150 |
+
## 7. Lado saliente: el publisher (`app/integrations/core_events.py`)
|
| 151 |
+
|
| 152 |
+
`publish_event(event_type_id: int | None, payload: dict) -> bool`:
|
| 153 |
+
|
| 154 |
+
- Si `event_type_id is None` → **no-op**: loguea a nivel `info` y devuelve `True`, sin ningún request HTTP.
|
| 155 |
+
- Si hay un id configurado → `POST /events/log` real contra el Core (`{"event_type_id", "publisher_module": "internacion", "payload": json.dumps(payload)}`).
|
| 156 |
+
|
| 157 |
+
Los 4 puntos de notificación saliente de M6 (`M6_DISEÑO.md` §7.2) hacen **dual-write**: siguen llamando al webhook REST directo exactamente como antes, y además llaman a `publish_event`:
|
| 158 |
+
|
| 159 |
+
| Función | Notificación | Receptor | Config del `event_type_id` |
|
| 160 |
+
|---|---|---|---|
|
| 161 |
+
| `hce.notify_resultado_solicitud` | `SOLICITUD_RESUELTA` | M1 HCE | `hce_solicitud_resuelta_event_type_id` |
|
| 162 |
+
| `monitoreo.notify_alta` | `ALTA_MONITOREO` | M9 Monitoreo | `monitoreo_alta_event_type_id` |
|
| 163 |
+
| `monitoreo.notify_baja` | `BAJA_MONITOREO` | M9 Monitoreo | `monitoreo_baja_event_type_id` |
|
| 164 |
+
| `facturacion.notify_cama_lista` | `CAMA_LISTA` | M7 Facturación | `facturacion_cama_lista_event_type_id` |
|
| 165 |
+
|
| 166 |
+
Las 4 settings de la tercera columna arrancan en `None` (default) — **el evento y la cola de cada uno los crea y comparte el módulo receptor**, no M6 (misma regla que aplica al revés en §2.2). Hoy ninguno de los tres equipos compartió su id.
|
| 167 |
+
|
| 168 |
+
**Cómo activar cuando llegue el id real:** cargar el valor en `.env` (o `.env.example` según el entorno) — cero cambios de código. A partir de ahí, la notificación sale por las dos vías (REST + bus) hasta que se coordine con ese equipo cuándo retirar la llamada REST directa.
|
| 169 |
+
|
| 170 |
+
---
|
| 171 |
+
|
| 172 |
+
## 8. Configuración (`app/config.py` / `.env`)
|
| 173 |
+
|
| 174 |
+
```bash
|
| 175 |
+
# Consumer entrante
|
| 176 |
+
RABBITMQ_CONSUMER_ENABLED=false # true cuando se tenga el broker real
|
| 177 |
+
RABBITMQ_HOST=localhost # placeholder — pendiente el dato real del broker compartido
|
| 178 |
+
RABBITMQ_PORT=5672
|
| 179 |
+
RABBITMQ_VHOST=/
|
| 180 |
+
INTERNACION_REQUESTS_QUEUE=internacion.requests
|
| 181 |
+
|
| 182 |
+
# Publisher saliente — dejar comentado hasta tener el id real (pydantic-settings
|
| 183 |
+
# no trata "KEY=" vacío como None, tira ValidationError si se descomenta sin valor)
|
| 184 |
+
# HCE_SOLICITUD_RESUELTA_EVENT_TYPE_ID=
|
| 185 |
+
# MONITOREO_ALTA_EVENT_TYPE_ID=
|
| 186 |
+
# MONITOREO_BAJA_EVENT_TYPE_ID=
|
| 187 |
+
# FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
|
| 188 |
+
```
|
| 189 |
+
|
| 190 |
+
Las credenciales del broker (`login`/`password` en `aio_pika.connect_robust`) son `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`, ya definidas para el resto de la integración con el Core — no hay settings de usuario/password nuevas para RabbitMQ.
|
| 191 |
+
|
| 192 |
+
---
|
| 193 |
+
|
| 194 |
+
## 9. Pendientes
|
| 195 |
+
|
| 196 |
+
- **Host/puerto/vhost reales del broker RabbitMQ compartido** — sin esto, `RABBITMQ_CONSUMER_ENABLED=true` no puede conectar. Único bloqueante para que el consumer corra contra el broker de verdad.
|
| 197 |
+
- **`event_type_id` de M1** (`SOLICITUD_RESUELTA`) — compartir con M6 el id de un evento que M1 debe crear y bindear a su propia cola.
|
| 198 |
+
- **`event_type_id` de M9** (`ALTA_MONITOREO`, `BAJA_MONITOREO`) — ídem, dos eventos que M9 debe crear.
|
| 199 |
+
- **`event_type_id` de M7** (`CAMA_LISTA`) — ídem, un evento que M7 debe crear.
|
| 200 |
+
- **Coordinar con M1/M9/M2 la migración de sus emisores** hacia los 5 eventos entrantes de §2.2, y una fecha de retiro de los webhooks REST equivalentes una vez confirmada.
|
| 201 |
+
- **Cirugía urgente** (§5): decisión pendiente de si migrar a un patrón request/response por eventos, condicionada a acordar el evento de respuesta con M1.
|
| 202 |
+
|
| 203 |
+
---
|
| 204 |
+
|
| 205 |
+
## 10. Tests
|
| 206 |
+
|
| 207 |
+
- `tests/test_rabbit_consumer.py` — despacho por `event_type_name`, manejo de payload malformado, ack/reject.
|
| 208 |
+
- `tests/test_core_events.py` — `publish_event` no-op sin id / publica con id; los 4 `notify_*` siguen haciendo el mismo request REST de siempre y además llaman a `publish_event` (hoy inerte).
|
| 209 |
+
- `tests/test_webhooks.py` — la vía REST entrante, sin cambios.
|
documentation/M6_INTEGRACION_M1_HCE.md
ADDED
|
@@ -0,0 +1,202 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Guía de integración: publicar eventos a Internación (M6) desde HCE (M1)
|
| 2 |
+
|
| 3 |
+
**Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 1**
|
| 4 |
+
|
| 5 |
+
> Esta guía es para el equipo de **HCE (M1)**: explica cómo publicar los eventos que le corresponden a M1 en el bus del Core (M10) para que M6 los procese. La cola y los eventos **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. Qué le corresponde a M1
|
| 10 |
+
|
| 11 |
+
M1 tiene **dos** eventos hacia M6:
|
| 12 |
+
|
| 13 |
+
| `event_type_id` | `name` | Cuándo se dispara |
|
| 14 |
+
|---|---|---|
|
| 15 |
+
| **14** | `internacion.solicitud.creada` | Un médico solicita internar o trasladar un paciente |
|
| 16 |
+
| **15** | `internacion.alta-medica.registrada` | Un médico da el alta de un paciente internado |
|
| 17 |
+
|
| 18 |
+
Estos eventos reemplazan, en paralelo durante la transición, a los webhooks REST que M1 llama hoy: `POST /api/v1/webhooks/hce/solicitud` y `POST /api/v1/webhooks/hce/alta-medica`. **Esos endpoints REST siguen activos** — no hace falta migrar de un día para el otro; M1 puede seguir usándolos mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
|
| 19 |
+
|
| 20 |
+
M6 ya tiene la cola `internacion.requests` creada y ambos eventos dados de alta y bindeados a esa cola. **M1 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
|
| 21 |
+
|
| 22 |
+
### ⚠️ Cirugía urgente: queda fuera, sigue siendo solo REST
|
| 23 |
+
|
| 24 |
+
M1 tiene un tercer webhook hacia M6, `POST /api/v1/webhooks/hce/cirugia-urgente`, que **no tiene evento equivalente en el bus** y no lo va a tener por ahora. Ese endpoint responde sincrónicamente qué quirófano y reserva se asignaron (y qué reservas se desplazaron), algo que un mensaje fire-and-forget no puede resolver sin un canal de respuesta aparte. Migrarlo requeriría acordar con M6 un evento de respuesta (`correlation_id` + `response_event_id`, patrón `billing`/`appointments` de `M10_integration.md`), lo cual no está planificado todavía. **Seguí usando el REST directo para cirugía urgente.**
|
| 25 |
+
|
| 26 |
+
---
|
| 27 |
+
|
| 28 |
+
## 2. Prerrequisito: tu propia cuenta de servicio en el Core
|
| 29 |
+
|
| 30 |
+
M1 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
|
| 31 |
+
|
| 32 |
+
```http
|
| 33 |
+
POST /auth/login
|
| 34 |
+
Content-Type: application/json
|
| 35 |
+
|
| 36 |
+
{ "email": "<cuenta-servicio-m1@...>", "password": "<...>" }
|
| 37 |
+
```
|
| 38 |
+
|
| 39 |
+
Respuesta `200`:
|
| 40 |
+
|
| 41 |
+
```json
|
| 42 |
+
{ "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 8, "email": "...", ... } }
|
| 43 |
+
```
|
| 44 |
+
|
| 45 |
+
Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire.
|
| 46 |
+
|
| 47 |
+
---
|
| 48 |
+
|
| 49 |
+
## 3. Cómo publicar cada evento
|
| 50 |
+
|
| 51 |
+
### 3.1 Solicitud creada (`event_type_id: 14`)
|
| 52 |
+
|
| 53 |
+
Ejemplo de **internación**:
|
| 54 |
+
|
| 55 |
+
```http
|
| 56 |
+
POST /events/log
|
| 57 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 58 |
+
Content-Type: application/json
|
| 59 |
+
|
| 60 |
+
{
|
| 61 |
+
"event_type_id": 14,
|
| 62 |
+
"publisher_module": "hce",
|
| 63 |
+
"payload": "{\"tipo\":\"INTERNACION\",\"solicitud_hce_id\":\"HCE-SOL-00123\",\"paciente_id\":123,\"medico_solicitante_id\":10,\"origen\":\"GUARDIA\",\"diagnostico_ingreso\":\"Neumonía\",\"prioridad\":\"ALTA\",\"hospital_id\":\"HOSP-1\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
|
| 64 |
+
}
|
| 65 |
+
```
|
| 66 |
+
|
| 67 |
+
Ejemplo de **traslado**:
|
| 68 |
+
|
| 69 |
+
```http
|
| 70 |
+
POST /events/log
|
| 71 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 72 |
+
Content-Type: application/json
|
| 73 |
+
|
| 74 |
+
{
|
| 75 |
+
"event_type_id": 14,
|
| 76 |
+
"publisher_module": "hce",
|
| 77 |
+
"payload": "{\"tipo\":\"TRASLADO\",\"solicitud_hce_id\":\"HCE-SOL-00124\",\"paciente_id\":123,\"medico_solicitante_id\":10,\"cama_origen_id\":204,\"cama_destino_solicitada_id\":315,\"motivo_traslado\":\"Requiere UTI\",\"hospital_id\":\"HOSP-1\",\"timestamp\":\"2026-07-10T15:00:00Z\"}"
|
| 78 |
+
}
|
| 79 |
+
```
|
| 80 |
+
|
| 81 |
+
### 3.2 Alta médica registrada (`event_type_id: 15`)
|
| 82 |
+
|
| 83 |
+
```http
|
| 84 |
+
POST /events/log
|
| 85 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 86 |
+
Content-Type: application/json
|
| 87 |
+
|
| 88 |
+
{
|
| 89 |
+
"event_type_id": 15,
|
| 90 |
+
"publisher_module": "hce",
|
| 91 |
+
"payload": "{\"paciente_id\":123,\"medico_firmante_id\":10,\"tipo_alta\":\"ALTA_MEDICA\",\"timestamp\":\"2026-07-10T16:00:00Z\"}"
|
| 92 |
+
}
|
| 93 |
+
```
|
| 94 |
+
|
| 95 |
+
Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
|
| 96 |
+
|
| 97 |
+
Respuesta `201` en ambos casos:
|
| 98 |
+
|
| 99 |
+
```json
|
| 100 |
+
{
|
| 101 |
+
"id": 89,
|
| 102 |
+
"event_type_id": 15,
|
| 103 |
+
"publisher_module": "hce",
|
| 104 |
+
"payload": "...",
|
| 105 |
+
"status": "pending",
|
| 106 |
+
...
|
| 107 |
+
}
|
| 108 |
+
```
|
| 109 |
+
|
| 110 |
+
Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy son los webhooks REST.
|
| 111 |
+
|
| 112 |
+
---
|
| 113 |
+
|
| 114 |
+
## 4. Contrato de payload
|
| 115 |
+
|
| 116 |
+
### 4.1 `internacion.solicitud.creada` (id 14)
|
| 117 |
+
|
| 118 |
+
| Campo | Tipo | Obligatorio | Descripción |
|
| 119 |
+
|---|---|---|---|
|
| 120 |
+
| `tipo` | `INTERNACION` \| `TRASLADO` | **sí** | Determina qué otros campos importan (ver abajo). |
|
| 121 |
+
| `solicitud_hce_id` | string | **sí** | Id de la solicitud en M1. Es la clave de idempotencia — ver §5. |
|
| 122 |
+
| `paciente_id` | integer | **sí** | Id del paciente en el Core. |
|
| 123 |
+
| `medico_solicitante_id` | integer | **sí** | Id del médico que solicita. |
|
| 124 |
+
| `hospital_id` | string | no | Sede del hospital. |
|
| 125 |
+
| `observaciones` | string | no | Texto libre. |
|
| 126 |
+
| `timestamp` | string (ISO 8601, UTC) | **sí** | Momento de la solicitud. |
|
| 127 |
+
|
| 128 |
+
Campos específicos de `tipo=INTERNACION`:
|
| 129 |
+
|
| 130 |
+
| Campo | Tipo | Descripción |
|
| 131 |
+
|---|---|---|
|
| 132 |
+
| `cama_solicitada_id` | integer, opcional | Si el médico ya sugiere una cama puntual. |
|
| 133 |
+
| `origen` | `GUARDIA` \| `CIRUGIA_PROGRAMADA` | Origen del ingreso. Si es `CIRUGIA_PROGRAMADA`, M6 valida el turno contra M2 antes de aprobar — enviar también `turno_id`. |
|
| 134 |
+
| `turno_id` | integer, opcional | Requerido si `origen=CIRUGIA_PROGRAMADA`. |
|
| 135 |
+
| `diagnostico_ingreso` | string, opcional | |
|
| 136 |
+
| `obra_social_id` / `numero_afiliado` | string, opcional | |
|
| 137 |
+
| `prioridad` | `MUY_BAJA`\|`BAJA`\|`MEDIA`\|`ALTA`\|`MUY_ALTA`\|`URGENTE` | |
|
| 138 |
+
|
| 139 |
+
Campos específicos de `tipo=TRASLADO`:
|
| 140 |
+
|
| 141 |
+
| Campo | Tipo | Descripción |
|
| 142 |
+
|---|---|---|
|
| 143 |
+
| `cama_origen_id` | integer | Cama actual del paciente. |
|
| 144 |
+
| `cama_destino_solicitada_id` | integer, opcional | Cama sugerida como destino, si aplica. |
|
| 145 |
+
| `motivo_traslado` | string, opcional | |
|
| 146 |
+
|
| 147 |
+
El schema no rechaza combinaciones cruzadas (por ejemplo, mandar campos de `TRASLADO` con `tipo=INTERNACION` no da error) — enviar solo los campos relevantes al `tipo` real, los demás quedan en `null`.
|
| 148 |
+
|
| 149 |
+
### 4.2 `internacion.alta-medica.registrada` (id 15)
|
| 150 |
+
|
| 151 |
+
| Campo | Tipo | Obligatorio | Descripción |
|
| 152 |
+
|---|---|---|---|
|
| 153 |
+
| `paciente_id` | integer | **sí** | Paciente que recibe el alta. Tiene que tener una cama `OCUPADA` o `CODIGO_ROJO` asignada en M6. |
|
| 154 |
+
| `medico_firmante_id` | integer | **sí** | Médico que firma el alta. |
|
| 155 |
+
| `tipo_alta` | `ALTA_MEDICA`\|`ALTA_VOLUNTARIA`\|`TRASLADO_EXTERNO`\|`DEFUNCION` | **sí** | |
|
| 156 |
+
| `timestamp` | string (ISO 8601, UTC) | **sí** | Momento del alta. |
|
| 157 |
+
|
| 158 |
+
---
|
| 159 |
+
|
| 160 |
+
## 5. Qué hace M6 al recibir cada evento
|
| 161 |
+
|
| 162 |
+
**Solicitud creada (14):**
|
| 163 |
+
1. Busca si ya existe una solicitud con ese `solicitud_hce_id`. Si existe, **no crea una nueva** — devuelve/usa la existente (idempotente: reintentar el mismo `solicitud_hce_id` es seguro, no duplica solicitudes).
|
| 164 |
+
2. Si no existe, crea la solicitud en estado `PENDIENTE`. Queda visible para un administrativo, que la resuelve (`APROBAR`/`APROBAR_CON_CAMBIO`/`RECHAZAR`) desde el frontend de M6 — este evento no dispara ninguna asignación de cama por sí solo.
|
| 165 |
+
3. Al resolverse (fuera de este flujo, por acción del administrativo), M6 le notifica el resultado a M1 vía `SOLICITUD_RESUELTA` — ese es un evento **saliente** de M6 hacia M1 (dual-write REST + bus, hoy con el lado bus todavía apagado porque M1 no compartió su `event_type_id` — ver `M6_EVENTOS_RABBITMQ.md` §7 si tu equipo quiere habilitar también ese canal).
|
| 166 |
+
|
| 167 |
+
**Alta médica (15):**
|
| 168 |
+
1. Busca la cama `OCUPADA`/`CODIGO_ROJO` del paciente. Si no tiene cama asignada, el mensaje se descarta (equivalente al `404` que hoy devuelve el REST) — no hay retry automático de M6 hacia M1.
|
| 169 |
+
2. La cama pasa a `EN_LIMPIEZA` y M6 notifica la baja a Monitoreo (M9), fire-and-forget.
|
| 170 |
+
3. Cuando el personal de limpieza marca la cama como `DISPONIBLE`, M6 dispara la notificación a Facturación (M7) — no depende de M1 en ese punto.
|
| 171 |
+
|
| 172 |
+
---
|
| 173 |
+
|
| 174 |
+
## 6. Errores comunes
|
| 175 |
+
|
| 176 |
+
| Síntoma | Causa probable |
|
| 177 |
+
|---|---|
|
| 178 |
+
| `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
|
| 179 |
+
| `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
|
| 180 |
+
| Se publican dos solicitudes para el mismo caso | No debería pasar — si ambas tienen el mismo `solicitud_hce_id`, M6 es idempotente. Si usaste ids distintos para el mismo evento real, revisar cómo generás `solicitud_hce_id` de tu lado |
|
| 181 |
+
| El alta médica se publica (`201`) pero M6 nunca actúa | Verificar que el paciente tenga una cama `OCUPADA`/`CODIGO_ROJO` real en M6 — si la solicitud de internación original nunca se aprobó (o se resolvió por otra vía), no hay cama que dar de alta |
|
| 182 |
+
| Necesito la cirugía urgente por el bus | No está disponible — seguir usando `POST /api/v1/webhooks/hce/cirugia-urgente` (ver §1) |
|
| 183 |
+
|
| 184 |
+
---
|
| 185 |
+
|
| 186 |
+
## 7. Checklist de integración
|
| 187 |
+
|
| 188 |
+
- [ ] Cuenta de servicio de M1 en el Core, con permiso `events:log:publish`.
|
| 189 |
+
- [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
|
| 190 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 14` al crear una solicitud de internación o traslado, con `solicitud_hce_id` estable y único por solicitud.
|
| 191 |
+
- [ ] Enviar solo los campos relevantes al `tipo` (`INTERNACION` vs `TRASLADO`) en el payload de la solicitud.
|
| 192 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 15` al registrar un alta médica.
|
| 193 |
+
- [ ] Seguir usando el REST directo para cirugía urgente — no migra a este bus.
|
| 194 |
+
- [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también a los REST directos (`/webhooks/hce/solicitud`, `/webhooks/hce/alta-medica`) — mientras tanto, no hay problema en llamar a ambos.
|
| 195 |
+
|
| 196 |
+
---
|
| 197 |
+
|
| 198 |
+
## 8. Referencias
|
| 199 |
+
|
| 200 |
+
- [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo los de M1).
|
| 201 |
+
- [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
|
| 202 |
+
- [`M6_DISEÑO.md`](M6_DISEÑO.md) §5.1/§5.2/§5.3 — flujos de negocio de internación, traslado y alta médica; §7.5 — contexto de la migración de webhooks REST a eventos.
|
documentation/M6_INTEGRACION_M2_TURNOS.md
ADDED
|
@@ -0,0 +1,135 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Guía de integración: publicar eventos a Internación (M6) desde Turnos (M2)
|
| 2 |
+
|
| 3 |
+
**Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 2**
|
| 4 |
+
|
| 5 |
+
> Esta guía es para el equipo de **Turnos (M2)**: explica cómo publicar el evento que le corresponde a M2 en el bus del Core (M10) para que M6 lo procese. La cola y el evento **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. Qué le corresponde a M2
|
| 10 |
+
|
| 11 |
+
M2 solo tiene **un** evento hacia M6:
|
| 12 |
+
|
| 13 |
+
| `event_type_id` | `name` | Cuándo se dispara |
|
| 14 |
+
|---|---|---|
|
| 15 |
+
| **18** | `internacion.turno.cancelado` | Se cancela o reprograma un turno quirúrgico que M6 tiene reservado |
|
| 16 |
+
|
| 17 |
+
Este evento reemplaza, en paralelo durante la transición, al webhook REST que M2 llama hoy: `POST /api/v1/turnos/{turnoId}/cancelacion`. **Ese endpoint REST sigue activo** — no hace falta migrar de un día para el otro; M2 puede seguir usándolo mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
|
| 18 |
+
|
| 19 |
+
M6 ya tiene la cola `internacion.requests` creada, el evento `internacion.turno.cancelado` (id 18) dado de alta y bindeado a esa cola. **M2 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
|
| 20 |
+
|
| 21 |
+
---
|
| 22 |
+
|
| 23 |
+
## 2. Prerrequisito: tu propia cuenta de servicio en el Core
|
| 24 |
+
|
| 25 |
+
M2 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
|
| 26 |
+
|
| 27 |
+
```http
|
| 28 |
+
POST /auth/login
|
| 29 |
+
Content-Type: application/json
|
| 30 |
+
|
| 31 |
+
{ "email": "<cuenta-servicio-m2@...>", "password": "<...>" }
|
| 32 |
+
```
|
| 33 |
+
|
| 34 |
+
Respuesta `200`:
|
| 35 |
+
|
| 36 |
+
```json
|
| 37 |
+
{ "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 12, "email": "...", ... } }
|
| 38 |
+
```
|
| 39 |
+
|
| 40 |
+
Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire (mismo patrón que ya usás para tus otras integraciones contra M10).
|
| 41 |
+
|
| 42 |
+
---
|
| 43 |
+
|
| 44 |
+
## 3. Cómo publicar el evento
|
| 45 |
+
|
| 46 |
+
```http
|
| 47 |
+
POST /events/log
|
| 48 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 49 |
+
Content-Type: application/json
|
| 50 |
+
|
| 51 |
+
{
|
| 52 |
+
"event_type_id": 18,
|
| 53 |
+
"publisher_module": "turnos",
|
| 54 |
+
"payload": "{\"turno_id\":5501,\"motivo\":\"Paciente cancela el turno\",\"tipo_cancelacion\":\"CANCELACION_PACIENTE\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
|
| 55 |
+
}
|
| 56 |
+
```
|
| 57 |
+
|
| 58 |
+
Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
|
| 59 |
+
|
| 60 |
+
Respuesta `201`:
|
| 61 |
+
|
| 62 |
+
```json
|
| 63 |
+
{
|
| 64 |
+
"id": 90,
|
| 65 |
+
"event_type_id": 18,
|
| 66 |
+
"publisher_module": "turnos",
|
| 67 |
+
"payload": "...",
|
| 68 |
+
"status": "pending",
|
| 69 |
+
...
|
| 70 |
+
}
|
| 71 |
+
```
|
| 72 |
+
|
| 73 |
+
Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy es el webhook REST.
|
| 74 |
+
|
| 75 |
+
---
|
| 76 |
+
|
| 77 |
+
## 4. Contrato del payload (`internacion.turno.cancelado`)
|
| 78 |
+
|
| 79 |
+
| Campo | Tipo | Obligatorio | Descripción |
|
| 80 |
+
|---|---|---|---|
|
| 81 |
+
| `turno_id` | integer | **sí** | Id del turno cancelado en M2. **Importante:** en el webhook REST este valor viaja en la URL (`/turnos/{turnoId}/cancelacion`); acá no hay "URL", así que **tiene que ir en el payload** — es el campo que M6 usa para encontrar la reserva de quirófano asociada. |
|
| 82 |
+
| `motivo` | string | sí | Motivo de la cancelación. Texto libre. |
|
| 83 |
+
| `tipo_cancelacion` | string | no | Opcional, texto libre (ej. `CANCELACION_PACIENTE`, `REPROGRAMACION`). |
|
| 84 |
+
| `timestamp` | string (ISO 8601, UTC) | sí | Momento de la cancelación en M2. |
|
| 85 |
+
|
| 86 |
+
Ejemplo completo (el JSON interno, antes de serializarlo a string para el campo `payload`):
|
| 87 |
+
|
| 88 |
+
```json
|
| 89 |
+
{
|
| 90 |
+
"turno_id": 5501,
|
| 91 |
+
"motivo": "Paciente cancela el turno",
|
| 92 |
+
"tipo_cancelacion": "CANCELACION_PACIENTE",
|
| 93 |
+
"timestamp": "2026-07-10T14:00:00Z"
|
| 94 |
+
}
|
| 95 |
+
```
|
| 96 |
+
|
| 97 |
+
---
|
| 98 |
+
|
| 99 |
+
## 5. Qué hace M6 al recibir el evento
|
| 100 |
+
|
| 101 |
+
1. Busca la reserva de quirófano **programada** (`origen=PROGRAMADA`) asociada a `turno_id`. Si no existe, el mensaje se descarta (va a la DLQ) — no hay respuesta de error hacia M2, es la misma limitación que ya tiene el webhook REST hoy (`404` sin retry automático de M6 hacia M2).
|
| 102 |
+
2. Si la reserva ya está `CANCELADA`, **no hace nada** (idempotente) — reintentar el mismo evento (por ejemplo, ante un timeout de tu lado) es seguro.
|
| 103 |
+
3. Si la reserva está `EN_CURSO` o `COMPLETADA`, no se puede cancelar — el mensaje se descarta (equivalente al `409` que hoy devuelve el REST).
|
| 104 |
+
4. Si todo está bien, la reserva pasa a `CANCELADA` y se libera el quirófano.
|
| 105 |
+
|
| 106 |
+
**Idempotencia de tu lado:** no hace falta ningún id de correlación adicional — `turno_id` ya es la clave. Reintentar el mismo `turno_id` con el mismo `motivo` es seguro, no duplica nada.
|
| 107 |
+
|
| 108 |
+
---
|
| 109 |
+
|
| 110 |
+
## 6. Errores comunes
|
| 111 |
+
|
| 112 |
+
| Síntoma | Causa probable |
|
| 113 |
+
|---|---|
|
| 114 |
+
| `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
|
| 115 |
+
| `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
|
| 116 |
+
| El evento se publica (`201`) pero M6 nunca actúa | Revisar que `turno_id` corresponda a una reserva `PROGRAMADA` real en M6; si el turno nunca tuvo reserva de quirófano asociada, no hay nada que cancelar del lado de M6 |
|
| 117 |
+
| Necesito saber si M6 proceso bien el evento | Hoy no hay canal de respuesta — es fire-and-forget. Si tu flujo necesita confirmación, seguir usando el REST directo mientras tanto |
|
| 118 |
+
|
| 119 |
+
---
|
| 120 |
+
|
| 121 |
+
## 7. Checklist de integración
|
| 122 |
+
|
| 123 |
+
- [ ] Cuenta de servicio de M2 en el Core, con permiso `events:log:publish`.
|
| 124 |
+
- [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
|
| 125 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 18` cuando se cancele/reprograme un turno quirúrgico.
|
| 126 |
+
- [ ] `payload` (string JSON) con `turno_id`, `motivo`, `tipo_cancelacion` (opcional) y `timestamp`.
|
| 127 |
+
- [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también al REST directo (`POST /api/v1/turnos/{turnoId}/cancelacion`) — mientras tanto, no hay problema en llamar a ambos.
|
| 128 |
+
|
| 129 |
+
---
|
| 130 |
+
|
| 131 |
+
## 8. Referencias
|
| 132 |
+
|
| 133 |
+
- [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo el de M2).
|
| 134 |
+
- [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
|
| 135 |
+
- [`M6_DISEÑO.md`](M6_DISEÑO.md) §7.5 — contexto de la migración de webhooks REST a eventos.
|
documentation/M6_INTEGRACION_M9_MONITOREO.md
ADDED
|
@@ -0,0 +1,170 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Guía de integración: publicar eventos a Internación (M6) desde Monitoreo (M9)
|
| 2 |
+
|
| 3 |
+
**Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 9**
|
| 4 |
+
|
| 5 |
+
> Esta guía es para el equipo de **Monitoreo (M9)**: explica cómo publicar los eventos que le corresponden a M9 en el bus del Core (M10) para que M6 los procese. La cola y los eventos **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. Qué le corresponde a M9
|
| 10 |
+
|
| 11 |
+
M9 tiene **dos** eventos hacia M6, ambos relacionados al código rojo:
|
| 12 |
+
|
| 13 |
+
| `event_type_id` | `name` | Cuándo se dispara |
|
| 14 |
+
|---|---|---|
|
| 15 |
+
| **16** | `internacion.alerta-emergencia.detectada` | Un sensor/regla de monitoreo detecta una emergencia en un paciente internado |
|
| 16 |
+
| **17** | `internacion.alerta-resuelta.notificada` | La emergencia se estabiliza |
|
| 17 |
+
|
| 18 |
+
Estos eventos reemplazan, en paralelo durante la transición, a los webhooks REST que M9 llama hoy: `POST /api/v1/webhooks/monitoreo/alerta-emergencia` y `POST /api/v1/webhooks/monitoreo/alerta-resuelta`. **Esos endpoints REST siguen activos** — no hace falta migrar de un día para el otro; M9 puede seguir usándolos mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
|
| 19 |
+
|
| 20 |
+
M6 ya tiene la cola `internacion.requests` creada y ambos eventos dados de alta y bindeados a esa cola. **M9 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
|
| 21 |
+
|
| 22 |
+
---
|
| 23 |
+
|
| 24 |
+
## 2. Prerrequisito: tu propia cuenta de servicio en el Core
|
| 25 |
+
|
| 26 |
+
M9 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
|
| 27 |
+
|
| 28 |
+
```http
|
| 29 |
+
POST /auth/login
|
| 30 |
+
Content-Type: application/json
|
| 31 |
+
|
| 32 |
+
{ "email": "<cuenta-servicio-m9@...>", "password": "<...>" }
|
| 33 |
+
```
|
| 34 |
+
|
| 35 |
+
Respuesta `200`:
|
| 36 |
+
|
| 37 |
+
```json
|
| 38 |
+
{ "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 15, "email": "...", ... } }
|
| 39 |
+
```
|
| 40 |
+
|
| 41 |
+
Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire.
|
| 42 |
+
|
| 43 |
+
---
|
| 44 |
+
|
| 45 |
+
## 3. Cómo publicar cada evento
|
| 46 |
+
|
| 47 |
+
### 3.1 Alerta de emergencia detectada (`event_type_id: 16`)
|
| 48 |
+
|
| 49 |
+
```http
|
| 50 |
+
POST /events/log
|
| 51 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 52 |
+
Content-Type: application/json
|
| 53 |
+
|
| 54 |
+
{
|
| 55 |
+
"event_type_id": 16,
|
| 56 |
+
"publisher_module": "monitoreo",
|
| 57 |
+
"payload": "{\"paciente_id\":123,\"observaciones\":\"Frecuencia cardíaca sostenida > 120 por 2 minutos\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
|
| 58 |
+
}
|
| 59 |
+
```
|
| 60 |
+
|
| 61 |
+
### 3.2 Alerta resuelta (`event_type_id: 17`)
|
| 62 |
+
|
| 63 |
+
```http
|
| 64 |
+
POST /events/log
|
| 65 |
+
Authorization: Bearer <token de tu cuenta de servicio>
|
| 66 |
+
Content-Type: application/json
|
| 67 |
+
|
| 68 |
+
{
|
| 69 |
+
"event_type_id": 17,
|
| 70 |
+
"publisher_module": "monitoreo",
|
| 71 |
+
"payload": "{\"paciente_id\":123,\"motivo_resolucion\":\"Paciente estabilizado\",\"timestamp\":\"2026-07-10T14:05:00Z\"}"
|
| 72 |
+
}
|
| 73 |
+
```
|
| 74 |
+
|
| 75 |
+
Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
|
| 76 |
+
|
| 77 |
+
Respuesta `201` en ambos casos:
|
| 78 |
+
|
| 79 |
+
```json
|
| 80 |
+
{
|
| 81 |
+
"id": 91,
|
| 82 |
+
"event_type_id": 16,
|
| 83 |
+
"publisher_module": "monitoreo",
|
| 84 |
+
"payload": "...",
|
| 85 |
+
"status": "pending",
|
| 86 |
+
...
|
| 87 |
+
}
|
| 88 |
+
```
|
| 89 |
+
|
| 90 |
+
Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy son los webhooks REST.
|
| 91 |
+
|
| 92 |
+
---
|
| 93 |
+
|
| 94 |
+
## 4. Contrato de payload
|
| 95 |
+
|
| 96 |
+
### 4.1 `internacion.alerta-emergencia.detectada` (id 16)
|
| 97 |
+
|
| 98 |
+
| Campo | Tipo | Obligatorio | Descripción |
|
| 99 |
+
|---|---|---|---|
|
| 100 |
+
| `paciente_id` | integer | **sí** | Id del paciente en el Core. M6 lo usa para localizar la cama actual del paciente. |
|
| 101 |
+
| `observaciones` | string | no | Texto libre, contexto de la alerta (opcional). |
|
| 102 |
+
| `timestamp` | string (ISO 8601, UTC) | sí | Momento de detección de la emergencia. |
|
| 103 |
+
|
| 104 |
+
```json
|
| 105 |
+
{
|
| 106 |
+
"paciente_id": 123,
|
| 107 |
+
"observaciones": "Frecuencia cardíaca sostenida > 120 por 2 minutos",
|
| 108 |
+
"timestamp": "2026-07-10T14:00:00Z"
|
| 109 |
+
}
|
| 110 |
+
```
|
| 111 |
+
|
| 112 |
+
### 4.2 `internacion.alerta-resuelta.notificada` (id 17)
|
| 113 |
+
|
| 114 |
+
| Campo | Tipo | Obligatorio | Descripción |
|
| 115 |
+
|---|---|---|---|
|
| 116 |
+
| `paciente_id` | integer | **sí** | Mismo paciente de la alerta de emergencia. |
|
| 117 |
+
| `motivo_resolucion` | string | no | Texto libre (opcional). |
|
| 118 |
+
| `timestamp` | string (ISO 8601, UTC) | sí | Momento de resolución. |
|
| 119 |
+
|
| 120 |
+
```json
|
| 121 |
+
{
|
| 122 |
+
"paciente_id": 123,
|
| 123 |
+
"motivo_resolucion": "Paciente estabilizado",
|
| 124 |
+
"timestamp": "2026-07-10T14:05:00Z"
|
| 125 |
+
}
|
| 126 |
+
```
|
| 127 |
+
|
| 128 |
+
---
|
| 129 |
+
|
| 130 |
+
## 5. Qué hace M6 al recibir cada evento
|
| 131 |
+
|
| 132 |
+
**Alerta de emergencia (16):**
|
| 133 |
+
1. Busca la cama `OCUPADA` del paciente (`paciente_id`). Si no tiene cama asignada, el mensaje se descarta (equivalente al `404` que hoy devuelve el REST) — no hay retry automático de M6 hacia M9.
|
| 134 |
+
2. La marca en estado `CODIGO_ROJO` y registra el evento en la historia clínica del paciente (M1).
|
| 135 |
+
|
| 136 |
+
**Alerta resuelta (17):**
|
| 137 |
+
1. Busca la cama en `CODIGO_ROJO` del paciente. Si no encuentra ninguna (por ejemplo, la alerta ya se resolvió antes), el mensaje se descarta — no hay error visible del lado de M9.
|
| 138 |
+
2. La cama vuelve a `OCUPADA`.
|
| 139 |
+
|
| 140 |
+
**Orden de los eventos:** publicar primero `alerta-emergencia.detectada` y, cuando corresponda, `alerta-resuelta.notificada` para el mismo `paciente_id`. Si `alerta-resuelta` llega sin que exista una cama en `CODIGO_ROJO` (por ejemplo, por un reordenamiento de mensajes en el bus), M6 no encuentra qué resolver y descarta el mensaje — no hay reconciliación automática. Publicar en orden evita este caso.
|
| 141 |
+
|
| 142 |
+
---
|
| 143 |
+
|
| 144 |
+
## 6. Errores comunes
|
| 145 |
+
|
| 146 |
+
| Síntoma | Causa probable |
|
| 147 |
+
|---|---|
|
| 148 |
+
| `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
|
| 149 |
+
| `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
|
| 150 |
+
| El evento se publica (`201`) pero M6 nunca actúa | Para `alerta-emergencia`: verificar que el paciente tenga una cama `OCUPADA` real en M6. Para `alerta-resuelta`: verificar que exista una cama en `CODIGO_ROJO` para ese paciente (puede que la alerta de emergencia no haya llegado, o haya llegado después) |
|
| 151 |
+
| Necesito saber si M6 procesó bien el evento | Hoy no hay canal de respuesta — es fire-and-forget. Si tu flujo necesita confirmación, seguir usando el REST directo mientras tanto |
|
| 152 |
+
|
| 153 |
+
---
|
| 154 |
+
|
| 155 |
+
## 7. Checklist de integración
|
| 156 |
+
|
| 157 |
+
- [ ] Cuenta de servicio de M9 en el Core, con permiso `events:log:publish`.
|
| 158 |
+
- [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
|
| 159 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 16` al detectar una emergencia.
|
| 160 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 17` al resolverse la emergencia, para el mismo `paciente_id`.
|
| 161 |
+
- [ ] Publicar los eventos en orden (emergencia antes que resuelta) para el mismo paciente.
|
| 162 |
+
- [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también a los REST directos (`/webhooks/monitoreo/alerta-emergencia`, `/webhooks/monitoreo/alerta-resuelta`) — mientras tanto, no hay problema en llamar a ambos.
|
| 163 |
+
|
| 164 |
+
---
|
| 165 |
+
|
| 166 |
+
## 8. Referencias
|
| 167 |
+
|
| 168 |
+
- [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo los de M9).
|
| 169 |
+
- [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
|
| 170 |
+
- [`M6_DISEÑO.md`](M6_DISEÑO.md) §5.7 — flujo de negocio de código rojo; §7.5 — contexto de la migración de webhooks REST a eventos.
|
requirements.txt
CHANGED
|
@@ -9,3 +9,4 @@ python-jose[cryptography]==3.3.0
|
|
| 9 |
httpx==0.27.2
|
| 10 |
sqlalchemy==2.0.36
|
| 11 |
psycopg2-binary==2.9.10
|
|
|
|
|
|
| 9 |
httpx==0.27.2
|
| 10 |
sqlalchemy==2.0.36
|
| 11 |
psycopg2-binary==2.9.10
|
| 12 |
+
aio-pika==9.5.8
|
tests/test_core_events.py
ADDED
|
@@ -0,0 +1,145 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Tests de la publicación saliente al bus del Core (`app/integrations/core_events.py`) y
|
| 3 |
+
de que los 4 puntos de notificación (`hce.notify_resultado_solicitud`,
|
| 4 |
+
`monitoreo.notify_alta`/`notify_baja`, `facturacion.notify_cama_lista`) sigan haciendo el
|
| 5 |
+
mismo request REST que hoy, sin cambios observables, mientras el `event_type_id`
|
| 6 |
+
correspondiente esté en `None` (default actual — ver `M6_DISEÑO.md` §7).
|
| 7 |
+
"""
|
| 8 |
+
from app.config import settings
|
| 9 |
+
from app.integrations import core_events, facturacion, hce, monitoreo
|
| 10 |
+
|
| 11 |
+
|
| 12 |
+
# ─── publish_event: no-op mientras no haya event_type_id ──────────────────
|
| 13 |
+
|
| 14 |
+
|
| 15 |
+
def test_publish_event_sin_id_no_hace_ningun_request(monkeypatch):
|
| 16 |
+
called = []
|
| 17 |
+
monkeypatch.setattr("app.integrations.core_events._post", lambda *a, **k: called.append((a, k)))
|
| 18 |
+
|
| 19 |
+
result = core_events.publish_event(None, {"foo": "bar"})
|
| 20 |
+
|
| 21 |
+
assert result is True
|
| 22 |
+
assert called == []
|
| 23 |
+
|
| 24 |
+
|
| 25 |
+
def test_publish_event_con_id_publica_al_core(monkeypatch):
|
| 26 |
+
calls = []
|
| 27 |
+
|
| 28 |
+
def _fake_post(url, body):
|
| 29 |
+
calls.append((url, body))
|
| 30 |
+
return {"id": 999}
|
| 31 |
+
|
| 32 |
+
monkeypatch.setattr(core_events, "_post", _fake_post)
|
| 33 |
+
|
| 34 |
+
result = core_events.publish_event(14, {"foo": "bar"})
|
| 35 |
+
|
| 36 |
+
assert result is True
|
| 37 |
+
assert len(calls) == 1
|
| 38 |
+
url, body = calls[0]
|
| 39 |
+
assert url == f"{settings.m10_core_url}/events/log"
|
| 40 |
+
assert body["event_type_id"] == 14
|
| 41 |
+
assert body["publisher_module"] == "internacion"
|
| 42 |
+
assert body["payload"] == '{"foo": "bar"}'
|
| 43 |
+
|
| 44 |
+
|
| 45 |
+
def test_publish_event_con_id_pero_post_falla_devuelve_false(monkeypatch):
|
| 46 |
+
monkeypatch.setattr(core_events, "_post", lambda *a, **k: None)
|
| 47 |
+
|
| 48 |
+
assert core_events.publish_event(14, {"foo": "bar"}) is False
|
| 49 |
+
|
| 50 |
+
|
| 51 |
+
# ─── notify_* : REST sin cambios + publish_event adicional (hoy no-op) ─────
|
| 52 |
+
|
| 53 |
+
|
| 54 |
+
def test_notify_resultado_solicitud_sigue_llamando_rest_igual_que_antes(monkeypatch):
|
| 55 |
+
monkeypatch.setattr(settings, "mock_external_services", False)
|
| 56 |
+
monkeypatch.setattr(settings, "hce_solicitud_resuelta_event_type_id", None)
|
| 57 |
+
rest_calls = []
|
| 58 |
+
publish_calls = []
|
| 59 |
+
monkeypatch.setattr(
|
| 60 |
+
"app.integrations.hce._post",
|
| 61 |
+
lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
|
| 62 |
+
)
|
| 63 |
+
monkeypatch.setattr(
|
| 64 |
+
"app.integrations.core_events.publish_event",
|
| 65 |
+
lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
|
| 66 |
+
)
|
| 67 |
+
|
| 68 |
+
ok = hce.notify_resultado_solicitud("HCE-SOL-1", "APROBADA", motivo=None)
|
| 69 |
+
|
| 70 |
+
assert ok is True
|
| 71 |
+
assert len(rest_calls) == 1
|
| 72 |
+
url, rest_payload = rest_calls[0]
|
| 73 |
+
assert url == f"{settings.m1_hce_url}/api/v1/hce/solicitudes/HCE-SOL-1/resultado"
|
| 74 |
+
assert "solicitud_hce_id" not in rest_payload # el body REST no cambia
|
| 75 |
+
assert len(publish_calls) == 1
|
| 76 |
+
event_type_id, event_payload = publish_calls[0]
|
| 77 |
+
assert event_type_id is None # no configurado todavía
|
| 78 |
+
assert event_payload["solicitud_hce_id"] == "HCE-SOL-1"
|
| 79 |
+
|
| 80 |
+
|
| 81 |
+
def test_notify_alta_sigue_llamando_rest_igual_que_antes(monkeypatch):
|
| 82 |
+
monkeypatch.setattr(settings, "mock_external_services", False)
|
| 83 |
+
monkeypatch.setattr(settings, "monitoreo_alta_event_type_id", None)
|
| 84 |
+
rest_calls = []
|
| 85 |
+
publish_calls = []
|
| 86 |
+
monkeypatch.setattr(
|
| 87 |
+
"app.integrations.monitoreo._post",
|
| 88 |
+
lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
|
| 89 |
+
)
|
| 90 |
+
monkeypatch.setattr(
|
| 91 |
+
"app.integrations.core_events.publish_event",
|
| 92 |
+
lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
|
| 93 |
+
)
|
| 94 |
+
|
| 95 |
+
ok = monitoreo.notify_alta(7)
|
| 96 |
+
|
| 97 |
+
assert ok is True
|
| 98 |
+
assert len(rest_calls) == 1
|
| 99 |
+
assert len(publish_calls) == 1
|
| 100 |
+
assert publish_calls[0][0] is None
|
| 101 |
+
|
| 102 |
+
|
| 103 |
+
def test_notify_baja_sigue_llamando_rest_igual_que_antes(monkeypatch):
|
| 104 |
+
monkeypatch.setattr(settings, "mock_external_services", False)
|
| 105 |
+
monkeypatch.setattr(settings, "monitoreo_baja_event_type_id", None)
|
| 106 |
+
rest_calls = []
|
| 107 |
+
publish_calls = []
|
| 108 |
+
monkeypatch.setattr(
|
| 109 |
+
"app.integrations.monitoreo._post",
|
| 110 |
+
lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
|
| 111 |
+
)
|
| 112 |
+
monkeypatch.setattr(
|
| 113 |
+
"app.integrations.core_events.publish_event",
|
| 114 |
+
lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
|
| 115 |
+
)
|
| 116 |
+
|
| 117 |
+
ok = monitoreo.notify_baja(7)
|
| 118 |
+
|
| 119 |
+
assert ok is True
|
| 120 |
+
assert len(rest_calls) == 1
|
| 121 |
+
assert len(publish_calls) == 1
|
| 122 |
+
assert publish_calls[0][0] is None
|
| 123 |
+
|
| 124 |
+
|
| 125 |
+
def test_notify_cama_lista_sigue_llamando_rest_igual_que_antes(monkeypatch):
|
| 126 |
+
monkeypatch.setattr(settings, "mock_external_services", False)
|
| 127 |
+
monkeypatch.setattr(settings, "facturacion_cama_lista_event_type_id", None)
|
| 128 |
+
rest_calls = []
|
| 129 |
+
publish_calls = []
|
| 130 |
+
monkeypatch.setattr(
|
| 131 |
+
"app.integrations.facturacion._post",
|
| 132 |
+
lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
|
| 133 |
+
)
|
| 134 |
+
monkeypatch.setattr(
|
| 135 |
+
"app.integrations.core_events.publish_event",
|
| 136 |
+
lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
|
| 137 |
+
)
|
| 138 |
+
|
| 139 |
+
ok = facturacion.notify_cama_lista(cama_id=315, paciente_id=7)
|
| 140 |
+
|
| 141 |
+
assert ok is True
|
| 142 |
+
assert len(rest_calls) == 1
|
| 143 |
+
assert len(publish_calls) == 1
|
| 144 |
+
assert publish_calls[0][0] is None
|
| 145 |
+
assert publish_calls[0][1]["cama_id"] == 315
|
tests/test_rabbit_consumer.py
ADDED
|
@@ -0,0 +1,180 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Tests del consumer de `internacion.requests` (`app/integrations/rabbit_consumer.py`).
|
| 3 |
+
|
| 4 |
+
No abren conexión real a RabbitMQ: `dispatch()` se prueba monkeypatcheando las
|
| 5 |
+
funciones de servicio (misma lógica de negocio que ya cubre `tests/test_webhooks.py`
|
| 6 |
+
para la vía REST); `_on_message` se prueba con un mensaje fake (sin `aio_pika` real),
|
| 7 |
+
corriendo la coroutine con `asyncio.run` — no hace falta pytest-asyncio para esto.
|
| 8 |
+
"""
|
| 9 |
+
import asyncio
|
| 10 |
+
import json
|
| 11 |
+
from datetime import datetime, timezone
|
| 12 |
+
|
| 13 |
+
import pytest
|
| 14 |
+
|
| 15 |
+
from app.integrations import rabbit_consumer
|
| 16 |
+
from app.services import solicitud_service
|
| 17 |
+
|
| 18 |
+
_NOW_ISO = datetime.now(timezone.utc).isoformat()
|
| 19 |
+
|
| 20 |
+
|
| 21 |
+
class _FakeMessage:
|
| 22 |
+
def __init__(self, body: bytes):
|
| 23 |
+
self.body = body
|
| 24 |
+
self.acked = False
|
| 25 |
+
self.rejected_requeue = None
|
| 26 |
+
|
| 27 |
+
async def ack(self):
|
| 28 |
+
self.acked = True
|
| 29 |
+
|
| 30 |
+
async def reject(self, requeue=False):
|
| 31 |
+
self.rejected_requeue = requeue
|
| 32 |
+
|
| 33 |
+
|
| 34 |
+
def _envelope(event_type_name: str, payload: dict, log_id: int = 1) -> bytes:
|
| 35 |
+
return json.dumps(
|
| 36 |
+
{
|
| 37 |
+
"event_type_id": 1,
|
| 38 |
+
"event_type_name": event_type_name,
|
| 39 |
+
"source_module": "test",
|
| 40 |
+
"publisher_module": "test",
|
| 41 |
+
"log_id": log_id,
|
| 42 |
+
"payload": json.dumps(payload),
|
| 43 |
+
"published_at": _NOW_ISO,
|
| 44 |
+
}
|
| 45 |
+
).encode()
|
| 46 |
+
|
| 47 |
+
|
| 48 |
+
# ─── dispatch(): despacho por event_type_name ──────────────────────────────
|
| 49 |
+
|
| 50 |
+
|
| 51 |
+
def test_dispatch_solicitud_creada(monkeypatch):
|
| 52 |
+
calls = []
|
| 53 |
+
monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
|
| 54 |
+
monkeypatch.setattr(
|
| 55 |
+
solicitud_service, "recibir_solicitud", lambda db, data: calls.append((db, data))
|
| 56 |
+
)
|
| 57 |
+
payload = {
|
| 58 |
+
"tipo": "INTERNACION",
|
| 59 |
+
"solicitud_hce_id": "HCE-SOL-1",
|
| 60 |
+
"paciente_id": 7,
|
| 61 |
+
"medico_solicitante_id": 10,
|
| 62 |
+
"timestamp": _NOW_ISO,
|
| 63 |
+
}
|
| 64 |
+
rabbit_consumer.dispatch("internacion.solicitud.creada", payload)
|
| 65 |
+
assert len(calls) == 1
|
| 66 |
+
db, data = calls[0]
|
| 67 |
+
assert db == "FAKE_DB"
|
| 68 |
+
assert data.solicitud_hce_id == "HCE-SOL-1"
|
| 69 |
+
|
| 70 |
+
|
| 71 |
+
def test_dispatch_alta_medica(monkeypatch):
|
| 72 |
+
calls = []
|
| 73 |
+
monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
|
| 74 |
+
monkeypatch.setattr(
|
| 75 |
+
solicitud_service, "procesar_alta_medica", lambda db, paciente_id: calls.append(paciente_id)
|
| 76 |
+
)
|
| 77 |
+
payload = {
|
| 78 |
+
"paciente_id": 7,
|
| 79 |
+
"medico_firmante_id": 10,
|
| 80 |
+
"tipo_alta": "ALTA_MEDICA",
|
| 81 |
+
"timestamp": _NOW_ISO,
|
| 82 |
+
}
|
| 83 |
+
rabbit_consumer.dispatch("internacion.alta-medica.registrada", payload)
|
| 84 |
+
assert calls == [7]
|
| 85 |
+
|
| 86 |
+
|
| 87 |
+
def test_dispatch_alerta_emergencia(monkeypatch):
|
| 88 |
+
calls = []
|
| 89 |
+
monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
|
| 90 |
+
monkeypatch.setattr(
|
| 91 |
+
solicitud_service, "procesar_alerta_emergencia", lambda db, paciente_id: calls.append(paciente_id)
|
| 92 |
+
)
|
| 93 |
+
payload = {"paciente_id": 7, "timestamp": _NOW_ISO}
|
| 94 |
+
rabbit_consumer.dispatch("internacion.alerta-emergencia.detectada", payload)
|
| 95 |
+
assert calls == [7]
|
| 96 |
+
|
| 97 |
+
|
| 98 |
+
def test_dispatch_alerta_resuelta(monkeypatch):
|
| 99 |
+
calls = []
|
| 100 |
+
monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
|
| 101 |
+
monkeypatch.setattr(
|
| 102 |
+
solicitud_service, "procesar_alerta_resuelta", lambda db, paciente_id: calls.append(paciente_id)
|
| 103 |
+
)
|
| 104 |
+
payload = {"paciente_id": 7, "timestamp": _NOW_ISO}
|
| 105 |
+
rabbit_consumer.dispatch("internacion.alerta-resuelta.notificada", payload)
|
| 106 |
+
assert calls == [7]
|
| 107 |
+
|
| 108 |
+
|
| 109 |
+
def test_dispatch_turno_cancelado(monkeypatch):
|
| 110 |
+
calls = []
|
| 111 |
+
monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
|
| 112 |
+
monkeypatch.setattr(
|
| 113 |
+
solicitud_service,
|
| 114 |
+
"cancelar_reserva_por_turno",
|
| 115 |
+
lambda db, turno_id, motivo: calls.append((turno_id, motivo)),
|
| 116 |
+
)
|
| 117 |
+
# turno_id viaja en el payload del evento (en el REST equivalente viene del path).
|
| 118 |
+
payload = {"turno_id": 5501, "motivo": "paciente cancela", "timestamp": _NOW_ISO}
|
| 119 |
+
rabbit_consumer.dispatch("internacion.turno.cancelado", payload)
|
| 120 |
+
assert calls == [(5501, "paciente cancela")]
|
| 121 |
+
|
| 122 |
+
|
| 123 |
+
def test_dispatch_event_type_name_no_reconocido():
|
| 124 |
+
with pytest.raises(KeyError):
|
| 125 |
+
rabbit_consumer.dispatch("algo.que.no.existe", {})
|
| 126 |
+
|
| 127 |
+
|
| 128 |
+
# ─── _on_message(): ack/reject según el resultado del dispatch ────────────
|
| 129 |
+
|
| 130 |
+
|
| 131 |
+
def test_on_message_ack_tras_procesar_ok(monkeypatch):
|
| 132 |
+
calls = []
|
| 133 |
+
monkeypatch.setattr(rabbit_consumer, "dispatch", lambda name, payload: calls.append((name, payload)))
|
| 134 |
+
msg = _FakeMessage(_envelope("internacion.alta-medica.registrada", {"paciente_id": 7}))
|
| 135 |
+
|
| 136 |
+
asyncio.run(rabbit_consumer._on_message(msg))
|
| 137 |
+
|
| 138 |
+
assert msg.acked
|
| 139 |
+
assert msg.rejected_requeue is None
|
| 140 |
+
assert calls == [("internacion.alta-medica.registrada", {"paciente_id": 7})]
|
| 141 |
+
|
| 142 |
+
|
| 143 |
+
def test_on_message_json_malformado_reject_sin_requeue():
|
| 144 |
+
msg = _FakeMessage(b"esto no es json")
|
| 145 |
+
|
| 146 |
+
asyncio.run(rabbit_consumer._on_message(msg))
|
| 147 |
+
|
| 148 |
+
assert not msg.acked
|
| 149 |
+
assert msg.rejected_requeue is False
|
| 150 |
+
|
| 151 |
+
|
| 152 |
+
def test_on_message_envelope_sin_event_type_name_reject():
|
| 153 |
+
msg = _FakeMessage(json.dumps({"payload": "{}"}).encode())
|
| 154 |
+
|
| 155 |
+
asyncio.run(rabbit_consumer._on_message(msg))
|
| 156 |
+
|
| 157 |
+
assert not msg.acked
|
| 158 |
+
assert msg.rejected_requeue is False
|
| 159 |
+
|
| 160 |
+
|
| 161 |
+
def test_on_message_dispatch_lanza_excepcion_reject_sin_crashear(monkeypatch):
|
| 162 |
+
def _raise(name, payload):
|
| 163 |
+
raise RuntimeError("fallo de negocio")
|
| 164 |
+
|
| 165 |
+
monkeypatch.setattr(rabbit_consumer, "dispatch", _raise)
|
| 166 |
+
msg = _FakeMessage(_envelope("internacion.alta-medica.registrada", {"paciente_id": 7}))
|
| 167 |
+
|
| 168 |
+
asyncio.run(rabbit_consumer._on_message(msg)) # no debe propagar la excepción
|
| 169 |
+
|
| 170 |
+
assert not msg.acked
|
| 171 |
+
assert msg.rejected_requeue is False
|
| 172 |
+
|
| 173 |
+
|
| 174 |
+
def test_on_message_event_type_name_no_mapeado_reject(monkeypatch):
|
| 175 |
+
msg = _FakeMessage(_envelope("algo.no.mapeado", {}))
|
| 176 |
+
|
| 177 |
+
asyncio.run(rabbit_consumer._on_message(msg))
|
| 178 |
+
|
| 179 |
+
assert not msg.acked
|
| 180 |
+
assert msg.rejected_requeue is False
|
tests/test_webhooks.py
CHANGED
|
@@ -34,6 +34,52 @@ def test_alta_medica_ok(client: TestClient, admin_headers, monkeypatch):
|
|
| 34 |
assert "cama_id" in data
|
| 35 |
|
| 36 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 37 |
def test_alta_medica_404(client: TestClient, admin_headers, monkeypatch):
|
| 38 |
monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: None)
|
| 39 |
payload = {
|
|
|
|
| 34 |
assert "cama_id" in data
|
| 35 |
|
| 36 |
|
| 37 |
+
def test_alta_medica_ok_aunque_monitoreo_falle(client: TestClient, admin_headers, monkeypatch):
|
| 38 |
+
"""
|
| 39 |
+
notify_baja (M9) es fire-and-forget (M6_DISEÑO.md §2): que M9 esté caído no debe
|
| 40 |
+
revertir el alta. Antes de la limpieza de código zombie, esto bloqueaba con 502.
|
| 41 |
+
"""
|
| 42 |
+
cama = make_cama(estado="OCUPADA", paciente_id=7)
|
| 43 |
+
monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: cama)
|
| 44 |
+
monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
|
| 45 |
+
monkeypatch.setattr("app.integrations.monitoreo.notify_baja", lambda *a, **k: False)
|
| 46 |
+
payload = {
|
| 47 |
+
"paciente_id": 7,
|
| 48 |
+
"medico_firmante_id": 10,
|
| 49 |
+
"tipo_alta": "ALTA_MEDICA",
|
| 50 |
+
"timestamp": _NOW_ISO,
|
| 51 |
+
}
|
| 52 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/alta-medica", json=payload, headers=admin_headers)
|
| 53 |
+
assert resp.status_code == 200
|
| 54 |
+
assert resp.json()["estado_cama"] == "EN_LIMPIEZA"
|
| 55 |
+
|
| 56 |
+
|
| 57 |
+
def test_alta_medica_no_llama_a_facturacion(client: TestClient, admin_headers, monkeypatch):
|
| 58 |
+
"""
|
| 59 |
+
El alta médica ya no depende de M7 (notify_cierre_cama se eliminó por ser código
|
| 60 |
+
zombie: endpoint sin spec real, que bloqueaba el alta con 502 si fallaba). Blindaje
|
| 61 |
+
contra reintroducir esa dependencia: cualquier llamada a facturacion.* debe fallar el
|
| 62 |
+
test.
|
| 63 |
+
"""
|
| 64 |
+
cama = make_cama(estado="OCUPADA", paciente_id=7)
|
| 65 |
+
monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: cama)
|
| 66 |
+
monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
|
| 67 |
+
monkeypatch.setattr("app.integrations.monitoreo.notify_baja", lambda *a, **k: True)
|
| 68 |
+
|
| 69 |
+
def _fail(*a, **k):
|
| 70 |
+
raise AssertionError("procesar_alta_medica no debe llamar a facturacion.*")
|
| 71 |
+
|
| 72 |
+
monkeypatch.setattr("app.integrations.facturacion.notify_cama_lista", _fail)
|
| 73 |
+
payload = {
|
| 74 |
+
"paciente_id": 7,
|
| 75 |
+
"medico_firmante_id": 10,
|
| 76 |
+
"tipo_alta": "ALTA_MEDICA",
|
| 77 |
+
"timestamp": _NOW_ISO,
|
| 78 |
+
}
|
| 79 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/alta-medica", json=payload, headers=admin_headers)
|
| 80 |
+
assert resp.status_code == 200
|
| 81 |
+
|
| 82 |
+
|
| 83 |
def test_alta_medica_404(client: TestClient, admin_headers, monkeypatch):
|
| 84 |
monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: None)
|
| 85 |
payload = {
|