HF debug endpoint
Browse files- .authtest.md.swp +0 -0
- app/main.py +28 -2
- documentation/M6_EVENTOS_RABBITMQ.md +219 -0
- documentation/M6_INTEGRACION_M1_HCE.md +221 -0
- documentation/M6_INTEGRACION_M2_TURNOS.md +135 -0
- documentation/M6_INTEGRACION_M9_MONITOREO.md +170 -0
- documentation/end_to_end_tests/flujo_internacion_completo.md +213 -0
- documentation/openapi_m1.json +0 -0
.authtest.md.swp
ADDED
|
Binary file (1.02 kB). View file
|
|
|
app/main.py
CHANGED
|
@@ -5,12 +5,12 @@ API REST: http://localhost:8006/api/v1
|
|
| 5 |
|
| 6 |
import logging
|
| 7 |
from contextlib import asynccontextmanager
|
| 8 |
-
from fastapi import FastAPI, Request, status
|
| 9 |
from fastapi.middleware.cors import CORSMiddleware
|
| 10 |
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
|
|
@@ -111,6 +111,32 @@ def health():
|
|
| 111 |
return {"status": "ok", "module": "M6 - Internación "}
|
| 112 |
|
| 113 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 114 |
# ─── Manejadores de errores globales ───────────────────────────────────────
|
| 115 |
|
| 116 |
|
|
|
|
| 5 |
|
| 6 |
import logging
|
| 7 |
from contextlib import asynccontextmanager
|
| 8 |
+
from fastapi import Depends, FastAPI, Request, status
|
| 9 |
from fastapi.middleware.cors import CORSMiddleware
|
| 10 |
from fastapi.responses import JSONResponse
|
| 11 |
|
| 12 |
from app.config import settings
|
| 13 |
+
from app.dependencies import create_access_token, require_roles
|
| 14 |
|
| 15 |
from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
|
| 16 |
from app.routers.webhooks import router_turnos
|
|
|
|
| 111 |
return {"status": "ok", "module": "M6 - Internación "}
|
| 112 |
|
| 113 |
|
| 114 |
+
# ─── Debug: ver qué valores resolvió pydantic-settings en este proceso ─────
|
| 115 |
+
|
| 116 |
+
_SECRET_FIELD_MARKERS = ("secret", "password", "key", "database_url")
|
| 117 |
+
|
| 118 |
+
|
| 119 |
+
@app.get(
|
| 120 |
+
f"{PREFIX}/_debug/settings",
|
| 121 |
+
tags=["Debug"],
|
| 122 |
+
summary="[DEBUG] Ver los valores reales que resolvió la app en este proceso",
|
| 123 |
+
)
|
| 124 |
+
def debug_settings(user: dict = Depends(require_roles("ADMINISTRATIVO"))):
|
| 125 |
+
"""
|
| 126 |
+
Para confirmar que una variable/secret cargada en HF Spaces realmente
|
| 127 |
+
llegó al proceso en ejecución (y no quedó vacía o desactualizada tras un
|
| 128 |
+
restart). Los campos sensibles (contraseñas, secrets, keys) no se
|
| 129 |
+
exponen en texto plano — solo si están seteados y su longitud.
|
| 130 |
+
"""
|
| 131 |
+
result = {}
|
| 132 |
+
for name, value in settings.model_dump().items():
|
| 133 |
+
if any(marker in name for marker in _SECRET_FIELD_MARKERS):
|
| 134 |
+
result[name] = f"***set (len={len(value)})***" if value else "*** EMPTY/MISSING ***"
|
| 135 |
+
else:
|
| 136 |
+
result[name] = value
|
| 137 |
+
return result
|
| 138 |
+
|
| 139 |
+
|
| 140 |
# ─── Manejadores de errores globales ───────────────────────────────────────
|
| 141 |
|
| 142 |
|
documentation/M6_EVENTOS_RABBITMQ.md
ADDED
|
@@ -0,0 +1,219 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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, publisher_module: str = "internacion") -> 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", "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, y además llaman a `publish_event`:
|
| 158 |
+
|
| 159 |
+
| Función | Notificación | Receptor | Config del `event_type_id` | Estado |
|
| 160 |
+
|---|---|---|---|---|
|
| 161 |
+
| `hce.notify_resultado_solicitud` | `SOLICITUD_RESUELTA` | M1 HCE | `hce_solicitud_resuelta_event_type_id` | Pendiente — M1 no compartió su id |
|
| 162 |
+
| `monitoreo.notify_alta` | `ALTA_MONITOREO` | M9 Monitoreo | `monitoreo_alta_event_type_id` | Pendiente — M9 no compartió su id |
|
| 163 |
+
| `monitoreo.notify_baja` | `BAJA_MONITOREO` | M9 Monitoreo | `monitoreo_baja_event_type_id` | Pendiente — M9 no compartió su id |
|
| 164 |
+
| `facturacion.notify_cama_lista` | `CIERRE_INTERNACION` (`facturacion.internacion.cama-lista.requested`) | M7 Facturación | `facturacion_cama_lista_event_type_id` | **Activo — `event_type_id=19`, confirmado por escrito** |
|
| 165 |
+
|
| 166 |
+
El evento/cola de cada notificación lo crea y comparte el módulo receptor, no M6 (misma
|
| 167 |
+
regla que aplica al revés en §2.2). **M7 ya lo hizo** (`documentation/integrations/M7_integration.md`)
|
| 168 |
+
— es el primer caso activado, con `publisher_module: "modulo_6"` (los otros 3 siguen con
|
| 169 |
+
el default `"internacion"` hasta que M1/M9 documenten el suyo). Su payload es distinto
|
| 170 |
+
(más rico) del REST — ver `app/integrations/facturacion.py::notify_cama_lista` y
|
| 171 |
+
`M6_DISEÑO.md` §7.2/§14.9 para el detalle completo, incluido el bloqueante de
|
| 172 |
+
`idEpisodioExterno`.
|
| 173 |
+
|
| 174 |
+
**Cómo activar cuando llegue el id real (M1/M9):** cargar el valor en `.env` — cero
|
| 175 |
+
cambios de código. A partir de ahí, la notificación sale por las dos vías (REST + bus)
|
| 176 |
+
hasta que se coordine con ese equipo cuándo retirar la llamada REST directa.
|
| 177 |
+
|
| 178 |
+
---
|
| 179 |
+
|
| 180 |
+
## 8. Configuración (`app/config.py` / `.env`)
|
| 181 |
+
|
| 182 |
+
```bash
|
| 183 |
+
# Consumer entrante
|
| 184 |
+
RABBITMQ_CONSUMER_ENABLED=false # true cuando se tenga el broker real
|
| 185 |
+
RABBITMQ_HOST=localhost # placeholder — pendiente el dato real del broker compartido
|
| 186 |
+
RABBITMQ_PORT=5672
|
| 187 |
+
RABBITMQ_VHOST=/
|
| 188 |
+
INTERNACION_REQUESTS_QUEUE=internacion.requests
|
| 189 |
+
|
| 190 |
+
# Publisher saliente — dejar comentado hasta tener el id real (pydantic-settings
|
| 191 |
+
# no trata "KEY=" vacío como None, tira ValidationError si se descomenta sin valor).
|
| 192 |
+
# M7 ya confirmó el suyo por escrito — activo:
|
| 193 |
+
# HCE_SOLICITUD_RESUELTA_EVENT_TYPE_ID=
|
| 194 |
+
# MONITOREO_ALTA_EVENT_TYPE_ID=
|
| 195 |
+
# MONITOREO_BAJA_EVENT_TYPE_ID=
|
| 196 |
+
FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=19
|
| 197 |
+
```
|
| 198 |
+
|
| 199 |
+
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.
|
| 200 |
+
|
| 201 |
+
---
|
| 202 |
+
|
| 203 |
+
## 9. Pendientes
|
| 204 |
+
|
| 205 |
+
- **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.
|
| 206 |
+
- **`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.
|
| 207 |
+
- **`event_type_id` de M9** (`ALTA_MONITOREO`, `BAJA_MONITOREO`) — ídem, dos eventos que M9 debe crear.
|
| 208 |
+
- ~~`event_type_id` de M7 (`CAMA_LISTA`)~~ — **resuelto**: M7 confirmó `event_type_id=19`, ya activo.
|
| 209 |
+
- **`episodio_id` de M1** — pendiente que M1 agregue este campo a `AltaMedicaWebhook` para poder completar `idEpisodioExterno` en el evento a M7 (hoy viaja `None`). Ver `M6_DISEÑO.md` §14.9 y `documentation/M6_INTEGRACION_M1_HCE.md`.
|
| 210 |
+
- **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.
|
| 211 |
+
- **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.
|
| 212 |
+
|
| 213 |
+
---
|
| 214 |
+
|
| 215 |
+
## 10. Tests
|
| 216 |
+
|
| 217 |
+
- `tests/test_rabbit_consumer.py` — despacho por `event_type_name`, manejo de payload malformado, ack/reject.
|
| 218 |
+
- `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).
|
| 219 |
+
- `tests/test_webhooks.py` — la vía REST entrante, sin cambios.
|
documentation/M6_INTEGRACION_M1_HCE.md
ADDED
|
@@ -0,0 +1,221 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
+
| `episodio_id` | string | **pedido nuevo, ver §4.3** | Id del episodio en M1 — hoy no se envía. |
|
| 158 |
+
|
| 159 |
+
### 4.3 ⚠️ Pedido nuevo a M1: agregar `episodio_id` a este webhook
|
| 160 |
+
|
| 161 |
+
M7 (Facturación) confirmó su integración real con M6 y pide, para poder facturar,
|
| 162 |
+
`idEpisodioExterno` — el id del episodio clínico en M1. M6 no lo genera ni lo tiene de
|
| 163 |
+
ninguna otra fuente: hoy lo reenvía como `null` a M7 porque **ningún webhook de M1 lo
|
| 164 |
+
provee**.
|
| 165 |
+
|
| 166 |
+
**Pedido:** agregar el campo `episodio_id` (string) a `internacion.alta-medica.registrada`
|
| 167 |
+
(y a su REST equivalente, `POST /webhooks/hce/alta-medica`, si también lo actualizan ahí)
|
| 168 |
+
con el id del episodio que M1 ya maneja internamente. Elegimos el evento de **alta**
|
| 169 |
+
porque es el que efectivamente cierra el episodio — a diferencia del de solicitud, donde
|
| 170 |
+
el episodio recién se está por abrir.
|
| 171 |
+
|
| 172 |
+
Mientras esto no esté disponible, el flujo sigue funcionando igual (M7 confirmó que no
|
| 173 |
+
rechaza el evento por faltar este dato — lo deja pendiente de completar de su lado), pero
|
| 174 |
+
la facturación automática de M7 queda incompleta hasta que se resuelva. Ver
|
| 175 |
+
`M6_DISEÑO.md` §14.9 para el detalle completo del lado de M6.
|
| 176 |
+
|
| 177 |
+
---
|
| 178 |
+
|
| 179 |
+
## 5. Qué hace M6 al recibir cada evento
|
| 180 |
+
|
| 181 |
+
**Solicitud creada (14):**
|
| 182 |
+
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).
|
| 183 |
+
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.
|
| 184 |
+
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).
|
| 185 |
+
|
| 186 |
+
**Alta médica (15):**
|
| 187 |
+
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.
|
| 188 |
+
2. La cama pasa a `EN_LIMPIEZA` y M6 notifica la baja a Monitoreo (M9), fire-and-forget.
|
| 189 |
+
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.
|
| 190 |
+
|
| 191 |
+
---
|
| 192 |
+
|
| 193 |
+
## 6. Errores comunes
|
| 194 |
+
|
| 195 |
+
| Síntoma | Causa probable |
|
| 196 |
+
|---|---|
|
| 197 |
+
| `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
|
| 198 |
+
| `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
|
| 199 |
+
| 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 |
|
| 200 |
+
| 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 |
|
| 201 |
+
| Necesito la cirugía urgente por el bus | No está disponible — seguir usando `POST /api/v1/webhooks/hce/cirugia-urgente` (ver §1) |
|
| 202 |
+
|
| 203 |
+
---
|
| 204 |
+
|
| 205 |
+
## 7. Checklist de integración
|
| 206 |
+
|
| 207 |
+
- [ ] Cuenta de servicio de M1 en el Core, con permiso `events:log:publish`.
|
| 208 |
+
- [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
|
| 209 |
+
- [ ] 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.
|
| 210 |
+
- [ ] Enviar solo los campos relevantes al `tipo` (`INTERNACION` vs `TRASLADO`) en el payload de la solicitud.
|
| 211 |
+
- [ ] Publicar `POST /events/log` con `event_type_id: 15` al registrar un alta médica.
|
| 212 |
+
- [ ] Seguir usando el REST directo para cirugía urgente — no migra a este bus.
|
| 213 |
+
- [ ] 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.
|
| 214 |
+
|
| 215 |
+
---
|
| 216 |
+
|
| 217 |
+
## 8. Referencias
|
| 218 |
+
|
| 219 |
+
- [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo los de M1).
|
| 220 |
+
- [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
|
| 221 |
+
- [`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.
|
documentation/end_to_end_tests/flujo_internacion_completo.md
ADDED
|
@@ -0,0 +1,213 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# E2E — Internación completa: HCE (M1) → solicitud → aprobación → alta → limpieza/facturación
|
| 2 |
+
|
| 3 |
+
Mock manual de punta a punta: trae los datos de un paciente real desde M1, dispara la
|
| 4 |
+
solicitud de internación sobre M6, la aprueba, y da de alta al paciente (cama pasa a
|
| 5 |
+
`EN_LIMPIEZA` y se notifica — mockeado — a Facturación/M7 y Monitoreo/M9).
|
| 6 |
+
|
| 7 |
+
> **Nota sobre "la cola de M6".** Hoy M6 no tiene un consumer de RabbitMQ corriendo:
|
| 8 |
+
> M1 llama directamente a los webhooks REST de M6 (`POST /webhooks/hce/...`), que son
|
| 9 |
+
> los que encolan la solicitud en estado `PENDIENTE` (la "cola" a la que se refiere
|
| 10 |
+
> `M6_DISEÑO.md`: `GET /solicitudes?estado=PENDIENTE`). Los pasos 2 y 4 de abajo son,
|
| 11 |
+
> en la práctica, esas llamadas REST — no una publicación a un exchange de RabbitMQ.
|
| 12 |
+
|
| 13 |
+
Requiere `MOCK_EXTERNAL_SERVICES=true` en M6 (default) para que las notificaciones
|
| 14 |
+
salientes a Core/M7/M9 no fallen por no tener esos servicios arriba, y
|
| 15 |
+
`ENVIRONMENT=development` para poder usar `GET /auth/token`.
|
| 16 |
+
|
| 17 |
+
## 0. Variables
|
| 18 |
+
|
| 19 |
+
```bash
|
| 20 |
+
export M1_URL="http://localhost:8001" # ajustar al M1 real / desplegado
|
| 21 |
+
export M6_URL="http://localhost:8000/api/v1"
|
| 22 |
+
|
| 23 |
+
export PACIENTE_ID=7
|
| 24 |
+
export CAMA_ID=101
|
| 25 |
+
export HOSPITAL_ID="HOSP-001"
|
| 26 |
+
```
|
| 27 |
+
|
| 28 |
+
---
|
| 29 |
+
|
| 30 |
+
## 1. [M1] Obtener datos del paciente
|
| 31 |
+
|
| 32 |
+
### 1.1 — Token de desarrollo de M1
|
| 33 |
+
|
| 34 |
+
```bash
|
| 35 |
+
M1_TOKEN=$(curl -s -X POST "$M1_URL/api/v1/dev/login" \
|
| 36 |
+
-H "Content-Type: application/json" \
|
| 37 |
+
-d '{}' | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
|
| 38 |
+
|
| 39 |
+
echo "M1_TOKEN=$M1_TOKEN"
|
| 40 |
+
```
|
| 41 |
+
|
| 42 |
+
### 1.2 — Asegurar que el paciente de prueba existe en la caché de HCE
|
| 43 |
+
|
| 44 |
+
```bash
|
| 45 |
+
curl -s -X POST "$M1_URL/api/v1/dev/paciente?id_paciente=$PACIENTE_ID" \
|
| 46 |
+
-H "Authorization: Bearer $M1_TOKEN"
|
| 47 |
+
```
|
| 48 |
+
|
| 49 |
+
### 1.3 — Datos básicos del paciente
|
| 50 |
+
|
| 51 |
+
```bash
|
| 52 |
+
curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID" \
|
| 53 |
+
-H "Authorization: Bearer $M1_TOKEN"
|
| 54 |
+
```
|
| 55 |
+
|
| 56 |
+
### 1.4 — Ficha médica (grupo sanguíneo, peso, altura, observaciones)
|
| 57 |
+
|
| 58 |
+
```bash
|
| 59 |
+
curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/ficha-medica" \
|
| 60 |
+
-H "Authorization: Bearer $M1_TOKEN"
|
| 61 |
+
```
|
| 62 |
+
|
| 63 |
+
### 1.5 — Antecedentes clínicos
|
| 64 |
+
|
| 65 |
+
```bash
|
| 66 |
+
curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/antecedentes" \
|
| 67 |
+
-H "Authorization: Bearer $M1_TOKEN"
|
| 68 |
+
```
|
| 69 |
+
|
| 70 |
+
### 1.6 — Alertas clínicas (posibles contraindicaciones a chequear contra la cama)
|
| 71 |
+
|
| 72 |
+
```bash
|
| 73 |
+
curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/alertas" \
|
| 74 |
+
-H "Authorization: Bearer $M1_TOKEN"
|
| 75 |
+
```
|
| 76 |
+
|
| 77 |
+
> Si 1.3–1.6 devuelven `404`/vacío, repetir 1.2 (el paciente de prueba no llegó a
|
| 78 |
+
> crearse en la caché local de M1) o crear ficha médica con
|
| 79 |
+
> `POST /api/v1/pacientes/{id}/ficha-medica` antes de continuar.
|
| 80 |
+
|
| 81 |
+
---
|
| 82 |
+
|
| 83 |
+
## 2. [M6] Publicar el evento de solicitud de internación
|
| 84 |
+
|
| 85 |
+
### 2.1 — Token de M6 (rol ADMINISTRATIVO — hace falta para el paso 3)
|
| 86 |
+
|
| 87 |
+
```bash
|
| 88 |
+
M6_TOKEN=$(curl -s "$M6_URL/auth/token?usuario=ADMINISTRATIVO&password=x" \
|
| 89 |
+
| python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
|
| 90 |
+
|
| 91 |
+
echo "M6_TOKEN=$M6_TOKEN"
|
| 92 |
+
```
|
| 93 |
+
|
| 94 |
+
### 2.2 — (Prerrequisito) crear la cama de destino si todavía no existe
|
| 95 |
+
|
| 96 |
+
```bash
|
| 97 |
+
curl -s -X POST "$M6_URL/camas" \
|
| 98 |
+
-H "Authorization: Bearer $M6_TOKEN" \
|
| 99 |
+
-H "Content-Type: application/json" \
|
| 100 |
+
-d '{
|
| 101 |
+
"numero": '"$CAMA_ID"',
|
| 102 |
+
"piso": 1,
|
| 103 |
+
"sector": "SALA_COMUN",
|
| 104 |
+
"tipo": "ESTANDAR",
|
| 105 |
+
"hospital_id": "'"$HOSPITAL_ID"'"
|
| 106 |
+
}'
|
| 107 |
+
```
|
| 108 |
+
|
| 109 |
+
Tiene que quedar en `estado: "DISPONIBLE"` — es el estado con el que se crea por default.
|
| 110 |
+
|
| 111 |
+
### 2.3 — Publicar el evento de solicitud (webhook entrante de M1)
|
| 112 |
+
|
| 113 |
+
```bash
|
| 114 |
+
curl -s -X POST "$M6_URL/webhooks/hce/solicitud" \
|
| 115 |
+
-H "Authorization: Bearer $M6_TOKEN" \
|
| 116 |
+
-H "Content-Type: application/json" \
|
| 117 |
+
-d '{
|
| 118 |
+
"tipo": "INTERNACION",
|
| 119 |
+
"solicitud_hce_id": "HCE-SOL-001",
|
| 120 |
+
"paciente_id": '"$PACIENTE_ID"',
|
| 121 |
+
"medico_solicitante_id": 10,
|
| 122 |
+
"cama_solicitada_id": '"$CAMA_ID"',
|
| 123 |
+
"origen": "GUARDIA",
|
| 124 |
+
"diagnostico_ingreso": "Neumonía adquirida en la comunidad",
|
| 125 |
+
"obra_social_id": "OSDE-210",
|
| 126 |
+
"numero_afiliado": "A-99887766",
|
| 127 |
+
"prioridad": "ALTA",
|
| 128 |
+
"hospital_id": "'"$HOSPITAL_ID"'",
|
| 129 |
+
"observaciones": "Paciente requiere oxígeno suplementario",
|
| 130 |
+
"timestamp": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"
|
| 131 |
+
}'
|
| 132 |
+
```
|
| 133 |
+
|
| 134 |
+
Respuesta esperada (`200`):
|
| 135 |
+
|
| 136 |
+
```json
|
| 137 |
+
{
|
| 138 |
+
"mensaje": "Solicitud recibida y pendiente de aprobación",
|
| 139 |
+
"solicitud_id": "SOL-00001",
|
| 140 |
+
"estado": "PENDIENTE"
|
| 141 |
+
}
|
| 142 |
+
```
|
| 143 |
+
|
| 144 |
+
Guardar el `solicitud_id` devuelto:
|
| 145 |
+
|
| 146 |
+
```bash
|
| 147 |
+
export SOLICITUD_ID="SOL-00001"
|
| 148 |
+
```
|
| 149 |
+
|
| 150 |
+
---
|
| 151 |
+
|
| 152 |
+
## 3. [M6] Aprobar la solicitud
|
| 153 |
+
|
| 154 |
+
```bash
|
| 155 |
+
curl -s -X PATCH "$M6_URL/solicitudes/$SOLICITUD_ID" \
|
| 156 |
+
-H "Authorization: Bearer $M6_TOKEN" \
|
| 157 |
+
-H "Content-Type: application/json" \
|
| 158 |
+
-d '{"accion": "APROBAR"}'
|
| 159 |
+
```
|
| 160 |
+
|
| 161 |
+
Respuesta esperada (`200`): `estado: "APROBADA"`, `cama_asignada_id: 101`. Internamente
|
| 162 |
+
esto valida al paciente contra Core (`core.validate_patient`, mockeado), chequea
|
| 163 |
+
contraindicaciones contra `cama.contraindicaciones_incompatibles`, ocupa la cama
|
| 164 |
+
(`estado → OCUPADA`, `paciente_id` seteado) y notifica — mockeado — a HCE y Monitoreo.
|
| 165 |
+
|
| 166 |
+
Verificar la cama ocupada:
|
| 167 |
+
|
| 168 |
+
```bash
|
| 169 |
+
curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN"
|
| 170 |
+
```
|
| 171 |
+
|
| 172 |
+
---
|
| 173 |
+
|
| 174 |
+
## 4. [M6] Publicar el evento de alta médica
|
| 175 |
+
|
| 176 |
+
```bash
|
| 177 |
+
curl -s -X POST "$M6_URL/webhooks/hce/alta-medica" \
|
| 178 |
+
-H "Authorization: Bearer $M6_TOKEN" \
|
| 179 |
+
-H "Content-Type: application/json" \
|
| 180 |
+
-d '{
|
| 181 |
+
"paciente_id": '"$PACIENTE_ID"',
|
| 182 |
+
"medico_firmante_id": 10,
|
| 183 |
+
"tipo_alta": "ALTA_MEDICA",
|
| 184 |
+
"timestamp": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"
|
| 185 |
+
}'
|
| 186 |
+
```
|
| 187 |
+
|
| 188 |
+
Respuesta esperada (`200`):
|
| 189 |
+
|
| 190 |
+
```json
|
| 191 |
+
{
|
| 192 |
+
"mensaje": "Alta médica procesada. Cama en limpieza.",
|
| 193 |
+
"cama_id": 101,
|
| 194 |
+
"estado_cama": "EN_LIMPIEZA"
|
| 195 |
+
}
|
| 196 |
+
```
|
| 197 |
+
|
| 198 |
+
Antes de mover la cama a `EN_LIMPIEZA`, M6 exige confirmación (mockeada si
|
| 199 |
+
`MOCK_EXTERNAL_SERVICES=true`) de:
|
| 200 |
+
- **Facturación (M7)** — `facturacion.notify_cierre_cama` (cierre de la internación).
|
| 201 |
+
- **Monitoreo (M9)** — `monitoreo.notify_baja` (baja del paciente monitoreado).
|
| 202 |
+
|
| 203 |
+
Si cualquiera de las dos falla (`502`), la cama no cambia de estado.
|
| 204 |
+
|
| 205 |
+
### Verificación final
|
| 206 |
+
|
| 207 |
+
```bash
|
| 208 |
+
curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN"
|
| 209 |
+
curl -s "$M6_URL/auditoria?cama_id=$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN"
|
| 210 |
+
```
|
| 211 |
+
|
| 212 |
+
`GET /auditoria` debe mostrar la traza completa: `SOLICITUD_RECIBIDA` →
|
| 213 |
+
`SOLICITUD_APROBADA` → `CAMA_ASIGNADA` → `CAMA_ALTA`.
|
documentation/openapi_m1.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|