juampisor commited on
Commit
a303d09
·
1 Parent(s): 15c2525

HF debug endpoint

Browse files
.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