juampisor commited on
Commit
4a2396c
·
1 Parent(s): 73c7f92

Fixes integracion M7

Browse files
app/integrations/facturacion.py CHANGED
@@ -19,84 +19,15 @@ from app.integrations._base import _post
19
  from app.models.cama import Cama
20
 
21
 
22
- def _tramo_desde_cama(cama: Cama) -> list[dict]:
23
- """Fallback: un único tramo con los datos de la cama final del episodio."""
24
- return [{
25
- "camaId": str(cama.id),
26
- "sector": cama.sector,
27
- "tipoCama": cama.tipo,
28
- "desde": cama.fecha_ingreso.isoformat() if cama.fecha_ingreso else None,
29
- "hasta": cama.alta_timestamp.isoformat() if cama.alta_timestamp else None,
30
- }]
31
-
32
-
33
- def _reconstruir_tramos(db: Client, paciente_id: int, cama: Cama) -> list[dict]:
34
  """
35
- Reconstruye los tramos de uso de cama del episodio desde la tabla de auditoría.
36
-
37
- Estrategia: cada evento CAMA_ASIGNADA abre un tramo; el siguiente CAMA_ASIGNADA lo
38
- cierra. El último tramo cierra en CAMA_ALTA (o alta_timestamp de la cama como
39
- fallback). Solo se consideran eventos a partir de fecha_ingreso del episodio para
40
- no mezclar con hospitalizaciones previas del mismo paciente.
41
-
42
- Ante cualquier fallo de DB o datos insuficientes cae a _tramo_desde_cama (un único
43
- tramo con la cama actual).
44
  """
45
- from app.crud import cama as cama_crud # import local para evitar ciclo
46
-
47
- try:
48
- fecha_desde = cama.fecha_ingreso.isoformat() if cama.fecha_ingreso else None
49
- q = (
50
- db.table("auditoria")
51
- .select("cama_id,evento,creado_en")
52
- .eq("paciente_id", paciente_id)
53
- .in_("evento", ["CAMA_ASIGNADA", "CAMA_ALTA"])
54
- .order("creado_en")
55
- )
56
- if fecha_desde:
57
- q = q.gte("creado_en", fecha_desde)
58
- resp = q.execute()
59
- eventos = resp.data or []
60
- except Exception:
61
- return _tramo_desde_cama(cama)
62
-
63
- asignaciones = [e for e in eventos if e["evento"] == "CAMA_ASIGNADA"]
64
- altas = [e for e in eventos if e["evento"] == "CAMA_ALTA"]
65
-
66
- if not asignaciones:
67
- return _tramo_desde_cama(cama)
68
-
69
- fin_ultimo = (
70
- altas[-1]["creado_en"] if altas
71
- else (cama.alta_timestamp.isoformat() if cama.alta_timestamp else None)
72
- )
73
-
74
- tramos_raw = []
75
- for i, asig in enumerate(asignaciones):
76
- hasta = asignaciones[i + 1]["creado_en"] if i + 1 < len(asignaciones) else fin_ultimo
77
- tramos_raw.append({"cama_id": asig["cama_id"], "desde": asig["creado_en"], "hasta": hasta})
78
-
79
- result = []
80
- for t in tramos_raw:
81
- cid = t["cama_id"]
82
- if cid == cama.id:
83
- sector, tipo = cama.sector, cama.tipo
84
- else:
85
- try:
86
- hist = cama_crud.get_by_id(db, cid)
87
- sector = hist.sector if hist else cama.sector
88
- tipo = hist.tipo if hist else cama.tipo
89
- except Exception:
90
- sector, tipo = cama.sector, cama.tipo
91
- result.append({
92
- "camaId": str(cid),
93
- "sector": sector,
94
- "tipoCama": tipo,
95
- "desde": t["desde"],
96
- "hasta": t["hasta"],
97
- })
98
-
99
- return result or _tramo_desde_cama(cama)
100
 
101
 
102
  def notify_cama_lista(cama: Cama, db: Client) -> bool:
@@ -104,6 +35,10 @@ def notify_cama_lista(cama: Cama, db: Client) -> bool:
104
  Avisa a M7 que una cama quedó lista tras un alta — cierra la internación del lado de
105
  facturación.
106
 
 
 
 
 
107
  `idEventoExterno` es la clave de idempotencia que usa M7: se deriva de forma estable
108
  (cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
109
  alta duplicada en facturación.
@@ -123,27 +58,26 @@ def notify_cama_lista(cama: Cama, db: Client) -> bool:
123
  "evento": "CAMA_LISTA",
124
  "idEventoExterno": id_evento_externo,
125
  "camaId": str(cama.id),
126
- "idPacienteExterno": paciente_id,
127
- "timestampEvento": datetime.now(timezone.utc).isoformat(),
128
  }
129
  ok_rest = _post(
130
  f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload_rest
131
  ) is not None
132
 
133
- camas_utilizadas = _reconstruir_tramos(db, paciente_id, cama)
134
-
 
135
  payload_evento = {
136
  "evento": "CIERRE_INTERNACION",
137
  "idEventoExterno": id_evento_externo,
138
- "camaId": str(cama.id),
139
  "idInternacionExterna": cama.solicitud_hce_id,
140
- "idEpisodioExterno": None, # bloqueante externo — ver docstring
141
- "idPacienteExterno": paciente_id,
142
- "fechaIngreso": cama.fecha_ingreso.isoformat() if cama.fecha_ingreso else None,
143
- "fechaAlta": cama.alta_timestamp.isoformat() if cama.alta_timestamp else None,
144
  "tipoAlta": cama.alta_tipo,
145
- "timestampEvento": datetime.now(timezone.utc).isoformat(),
146
- "camasUtilizadas": camas_utilizadas,
147
  }
148
  core_events.publish_event(
149
  settings.facturacion_cama_lista_event_type_id, payload_evento, publisher_module="modulo_6"
 
19
  from app.models.cama import Cama
20
 
21
 
22
+ def _iso_z(dt: datetime | None) -> str | None:
 
 
 
 
 
 
 
 
 
 
 
23
  """
24
+ ISO 8601 UTC con sufijo `Z`, como documenta M7 (`M7_integration.md`) y como se usa en
25
+ el resto del proyecto — `datetime.isoformat()` sobre un aware UTC produce `+00:00`, no
26
+ `Z`, y M7 puede no parsearlo igual (típico si su DTO usa `Instant`).
 
 
 
 
 
 
27
  """
28
+ if dt is None:
29
+ return None
30
+ return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
31
 
32
 
33
  def notify_cama_lista(cama: Cama, db: Client) -> bool:
 
35
  Avisa a M7 que una cama quedó lista tras un alta — cierra la internación del lado de
36
  facturación.
37
 
38
+ `db` no se usa dentro de la función (se dejó de reconstruir `camasUtilizadas` vía
39
+ auditoría, campo que no forma parte del contrato real de M7 — ver `M6_DISEÑO.md` §7.2);
40
+ se mantiene en la firma para no tocar el call site (`solicitud_service.procesar_alta_medica`).
41
+
42
  `idEventoExterno` es la clave de idempotencia que usa M7: se deriva de forma estable
43
  (cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
44
  alta duplicada en facturación.
 
58
  "evento": "CAMA_LISTA",
59
  "idEventoExterno": id_evento_externo,
60
  "camaId": str(cama.id),
61
+ "idPacienteExterno": str(paciente_id),
62
+ "timestampEvento": _iso_z(datetime.now(timezone.utc)),
63
  }
64
  ok_rest = _post(
65
  f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload_rest
66
  ) is not None
67
 
68
+ # Payload del evento del Core: exactamente el contrato que confirmó M7 por escrito
69
+ # (`M7_integration.md`) y que documenta `M6_DISEÑO.md` §7.2 — sin campos extra
70
+ # (`camaId`/`camasUtilizadas` no forman parte de ese contrato).
71
  payload_evento = {
72
  "evento": "CIERRE_INTERNACION",
73
  "idEventoExterno": id_evento_externo,
 
74
  "idInternacionExterna": cama.solicitud_hce_id,
75
+ "idEpisodioExterno": None, # bloqueante externo — ver docstring; string cuando se popule
76
+ "idPacienteExterno": str(paciente_id),
77
+ "fechaIngreso": _iso_z(cama.fecha_ingreso),
78
+ "fechaAlta": _iso_z(cama.alta_timestamp),
79
  "tipoAlta": cama.alta_tipo,
80
+ "timestampEvento": _iso_z(datetime.now(timezone.utc)),
 
81
  }
82
  core_events.publish_event(
83
  settings.facturacion_cama_lista_event_type_id, payload_evento, publisher_module="modulo_6"
documentation/M6_DISEÑO.md CHANGED
@@ -546,3 +546,25 @@ No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT d
546
  42. **`solicitud_service.procesar_alta_medica` cambia de firma**: recibe el `AltaMedicaWebhook` completo en vez de solo `paciente_id`, para poder persistir `tipo_alta`/`timestamp` en la cama. Actualizados los dos call sites (`app/routers/webhooks.py`, `app/integrations/rabbit_consumer.py`).
547
  43. **Bloqueante externo, documentado explícitamente: `idEpisodioExterno` viaja como `None`.** Ningún webhook de M1 provee ese dato hoy. Pendiente coordinar con M1 que lo agregue a `AltaMedicaWebhook` (ver `documentation/M6_INTEGRACION_M1_HCE.md`). Confirmado con M7 (vía su documentación) que el evento no se rechaza por esto — queda pendiente de completar de su lado.
548
  44. **Revierte parcialmente la decisión del changelog #14** ("M6 no es intermediario del episodio... no enviamos idEpisodioExterno"). Esa decisión asumía que el payload rico era una recomendación opcional de M7; ahora M7 confirmó por escrito que es el contrato real de la integración final, no una opción descartable.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
546
  42. **`solicitud_service.procesar_alta_medica` cambia de firma**: recibe el `AltaMedicaWebhook` completo en vez de solo `paciente_id`, para poder persistir `tipo_alta`/`timestamp` en la cama. Actualizados los dos call sites (`app/routers/webhooks.py`, `app/integrations/rabbit_consumer.py`).
547
  43. **Bloqueante externo, documentado explícitamente: `idEpisodioExterno` viaja como `None`.** Ningún webhook de M1 provee ese dato hoy. Pendiente coordinar con M1 que lo agregue a `AltaMedicaWebhook` (ver `documentation/M6_INTEGRACION_M1_HCE.md`). Confirmado con M7 (vía su documentación) que el evento no se rechaza por esto — queda pendiente de completar de su lado.
548
  44. **Revierte parcialmente la decisión del changelog #14** ("M6 no es intermediario del episodio... no enviamos idEpisodioExterno"). Esa decisión asumía que el payload rico era una recomendación opcional de M7; ahora M7 confirmó por escrito que es el contrato real de la integración final, no una opción descartable.
549
+
550
+ ### 14.10 Corrección del payload de `CIERRE_INTERNACION` contra el contrato real de M7 (2026-07)
551
+
552
+ Una prueba end-to-end contra el broker real de RabbitMQ mostró que el evento a M7 nunca se
553
+ publicaba (`facturacion_cama_lista_event_type_id` resolvía a `None` en el deploy pese a
554
+ `event_type_id=19` estar documentado como activo — variable no seteada realmente en HF, no un
555
+ bug de código). Auditando el payload contra `M7_integration.md` de punta a punta se
556
+ encontraron 3 desvíos reales del contrato, corregidos en `app/integrations/facturacion.py`:
557
+
558
+ 45. **Timestamps con sufijo `Z`, no `+00:00`.** `datetime.isoformat()` sobre un `datetime`
559
+ aware UTC produce `+00:00`; el contrato de M7 (y el resto del proyecto) usa `Z`. Nuevo
560
+ helper `_iso_z()` aplicado a `fechaIngreso`, `fechaAlta` y `timestampEvento` en ambos
561
+ payloads (evento y REST).
562
+ 46. **`idPacienteExterno` como `string`, no `int`.** El ejemplo de M7 lo muestra entre
563
+ comillas (`"10500"`); el código mandaba el `int` de `cama.paciente_id`. Corregido a
564
+ `str(paciente_id)`. Mismo criterio queda documentado para `idEpisodioExterno` cuando deje
565
+ de ser `None`.
566
+ 47. **Se sacan `camaId` y `camasUtilizadas` del payload del evento** (el REST fallback
567
+ conserva `camaId`, que nunca tuvo contrato escrito de M7). Ninguno de los dos es parte
568
+ del listado de campos que confirmó M7 ni del que documenta el changelog #39 de esta misma
569
+ sección — `camasUtilizadas` existía solo para alimentar una reconstrucción de tramos vía
570
+ `auditoria` (`_reconstruir_tramos`/`_tramo_desde_cama`, eliminadas) que M7 nunca pidió.
documentation/M6_EVENTOS_RABBITMQ.md CHANGED
@@ -175,6 +175,18 @@ el default `"internacion"` hasta que M1/M9 documenten el suyo). Su payload es di
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`)
 
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
+ **Corrección 2026-07 (auditoría contra el contrato real de M7):** una prueba end-to-end
179
+ contra el broker real mostró que el evento a M7 nunca salía (`facturacion_cama_lista_event_type_id`
180
+ resolvía a `None` en el deploy pese a estar documentado como activo — variable no seteada
181
+ realmente en HF, no un bug de código; verificar con `GET /api/v1/_debug/settings`). De paso
182
+ se auditó el payload contra `M7_integration.md` y se corrigieron 3 desvíos reales: los
183
+ timestamps iban con sufijo `+00:00` en vez de `Z` (formato que M7 documenta y puede exigir
184
+ si su DTO usa `Instant`), `idPacienteExterno` iba como `int` en vez del `string` que muestra
185
+ el contrato, y el payload incluía `camaId`/`camasUtilizadas` — dos campos que ni
186
+ `M7_integration.md` ni `M6_DISEÑO.md` §7.2 documentan como parte del evento acordado (se
187
+ sacaron, junto con la reconstrucción de tramos vía `auditoria` que solo existía para
188
+ alimentarlos).
189
+
190
  ---
191
 
192
  ## 8. Configuración (`app/config.py` / `.env`)
documentation/end_to_end_tests/flujo_internacion_completo.md CHANGED
@@ -1,97 +1,118 @@
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" \
@@ -106,51 +127,78 @@ curl -s -X POST "$M6_URL/camas" \
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" \
@@ -158,12 +206,13 @@ curl -s -X PATCH "$M6_URL/solicitudes/$SOLICITUD_ID" \
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"
@@ -171,36 +220,65 @@ curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN"
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
 
@@ -210,4 +288,23 @@ 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`.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # E2E — Internación completa por la cola real de RabbitMQ
2
 
3
+ Prueba de punta a punta usando el **bus de eventos real** del Core (M10), no los webhooks
4
+ REST directos: trae los datos de un paciente real desde M1, publica la solicitud de
5
+ internación y el alta médica como eventos en `internacion.requests`, y confirma que el
6
+ consumer de M6 (`app/integrations/rabbit_consumer.py`) los procesa igual que el webhook REST
7
+ equivalente — hasta que la cama llega a `EN_LIMPIEZA` y M6 notifica (real, no mockeado) a
8
+ Facturación (M7) y Monitoreo (M9).
9
 
10
+ Para el flujo equivalente por REST directo (más simple, sin depender del broker), ver el
11
+ historial de este archivo o `documentation/M6_demo_payloads.md`.
 
 
 
12
 
13
+ ## 0. Requisitos previos
 
 
14
 
15
+ Esta prueba corre contra el **deploy real** (`https://modulo-6-api.hf.space`), con:
16
+
17
+ - `RABBITMQ_CONSUMER_ENABLED=true`, `RABBITMQ_HOST=queue.healthgrid.cantero.ar`,
18
+ `RABBITMQ_PORT=5672`, `RABBITMQ_VHOST=/` — el consumer tiene que estar corriendo.
19
+ - `MOCK_EXTERNAL_SERVICES=false` — **loop completo**: la aprobación valida al paciente contra
20
+ el Core real (M10) y notifica a M1/M9 reales; el alta médica notifica a M7 (real, evento
21
+ `CIERRE_INTERNACION`, `event_type_id=19`) y a M9.
22
+ - `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD` válidos (cuenta de servicio de M6 en el Core —
23
+ se usa tanto para las llamadas salientes como, en el broker, como credencial RabbitMQ).
24
+ - `M10_CORE_URL`, `M1_HCE_URL`, `M7_FACTURACION_URL`, `M9_MONITOREO_URL` apuntando a los
25
+ servicios reales.
26
+
27
+ **Con `MOCK_EXTERNAL_SERVICES=false`, el `PACIENTE_ID` de prueba tiene que existir realmente
28
+ como usuario en el Core** — si no, el paso 3 (aprobar) falla con `502
29
+ SERVICIO_EXTERNO_NO_DISPONIBLE` (`core.validate_patient`). Usar un paciente ya dado de alta en
30
+ M10/M1, no un ID inventado.
31
+
32
+ ### 0.1 — Confirmar que el consumer está arriba
33
 
34
  ```bash
35
+ export M6_URL="https://modulo-6-api.hf.space/api/v1"
 
36
 
37
+ M6_TOKEN=$(curl -s "$M6_URL/auth/token?usuario=ADMINISTRATIVO&password=x" \
38
+ | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
39
+
40
+ curl -s "$M6_URL/_debug/settings" -H "Authorization: Bearer $M6_TOKEN" \
41
+ | python3 -m json.tool
42
  ```
43
 
44
+ Confirmar `rabbitmq_consumer_enabled: true`, `mock_external_services: false`, y que
45
+ `m10_core_url`/`m1_hce_url`/`m7_facturacion_url`/`m9_monitoreo_url` apuntan a los servicios
46
+ reales (no a los `localhost` por default). Si `/auth/token` da `404` (el Space corre en
47
+ `ENVIRONMENT=production`), conseguir el token de M6 vía SSO real en su lugar
48
+ (`documentation/M6_AUTH_SSO.md`).
49
 
50
+ También revisar los **logs del Space** (HF → Logs): debe aparecer
51
+ `Iniciando consumer de internacion.requests` sin un traceback de conexión inmediatamente
52
+ después. Si el broker rechaza credenciales o la cola no existe, el consumer muere ahí y nada
53
+ de lo que sigue va a funcionar.
54
 
55
+ ### 0.2 — Token de la cuenta de servicio de M6 en el Core (para publicar eventos)
56
+
57
+ Los eventos los publica quien los emite realmente (M1/M9) contra su propia cuenta — para
58
+ simularlo en esta prueba manual, se publica con la cuenta de servicio de M6 (mismas
59
+ credenciales que usa el backend).
60
 
61
  ```bash
62
+ export CORE_URL="https://api.healthcare.cantero.ar"
63
+
64
+ CORE_TOKEN=$(curl -s -X POST "$CORE_URL/auth/login" \
65
  -H "Content-Type: application/json" \
66
+ -d '{"email": "'"$CORE_SERVICE_EMAIL"'", "password": "'"$CORE_SERVICE_PASSWORD"'"}' \
67
+ | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])")
68
 
69
+ echo "CORE_TOKEN=$CORE_TOKEN"
70
  ```
71
 
72
+ ### 0.3 — Variables del flujo
73
 
74
  ```bash
75
+ export M1_URL="http://localhost:8001" # ajustar al M1 real / desplegado
76
+ export PACIENTE_ID=7 # tiene que existir en el Core (ver arriba)
77
+ export CAMA_ID=101
78
+ export HOSPITAL_ID="HOSP-001"
79
  ```
80
 
81
+ ---
 
 
 
 
 
82
 
83
+ ## 1. [M1] Obtener datos del paciente
84
 
85
+ Sin cambios respecto al flujo REST — esto sigue siendo una consulta directa a M1, no pasa por
86
+ la cola.
 
 
87
 
88
+ ### 1.1 — Token de desarrollo de M1
89
 
90
  ```bash
91
+ M1_TOKEN=$(curl -s -X POST "$M1_URL/api/v1/dev/login" \
92
+ -H "Content-Type: application/json" \
93
+ -d '{}' | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
94
+
95
+ echo "M1_TOKEN=$M1_TOKEN"
96
  ```
97
 
98
+ ### 1.2 — Datos básicos, ficha médica, antecedentes y alertas
99
 
100
  ```bash
101
+ curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID" -H "Authorization: Bearer $M1_TOKEN"
102
+ curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/ficha-medica" -H "Authorization: Bearer $M1_TOKEN"
103
+ curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/antecedentes" -H "Authorization: Bearer $M1_TOKEN"
104
+ curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/alertas" -H "Authorization: Bearer $M1_TOKEN"
105
  ```
106
 
 
 
 
 
107
  ---
108
 
109
+ ## 2. [Cola] Publicar el evento de solicitud de internación
 
 
 
 
 
 
110
 
111
+ `event_type_id=14` (`internacion.solicitud.creada`) → bindeado a `internacion.requests` → lo
112
+ consume `rabbit_consumer.dispatch` → `solicitud_service.recibir_solicitud` (la misma función
113
+ que usa `POST /webhooks/hce/solicitud`).
114
 
115
+ ### 2.1 — (Prerrequisito) crear la cama de destino si todavía no existe
116
 
117
  ```bash
118
  curl -s -X POST "$M6_URL/camas" \
 
127
  }'
128
  ```
129
 
130
+ Tiene que quedar en `estado: "DISPONIBLE"`.
131
+
132
+ ### 2.2 — Publicar el evento al Core
133
 
134
+ El `payload` interno viaja como **string JSON** (no como objeto anidado) — se arma con
135
+ `python3 -c` para que quede bien escapado dentro del body del `POST /events/log`.
136
 
137
  ```bash
138
+ PAYLOAD=$(python3 -c '
139
+ import json, sys
140
+ print(json.dumps({
 
141
  "tipo": "INTERNACION",
142
  "solicitud_hce_id": "HCE-SOL-001",
143
+ "paciente_id": int(sys.argv[1]),
144
  "medico_solicitante_id": 10,
145
+ "cama_solicitada_id": int(sys.argv[2]),
146
  "origen": "GUARDIA",
147
  "diagnostico_ingreso": "Neumonía adquirida en la comunidad",
148
  "obra_social_id": "OSDE-210",
149
  "numero_afiliado": "A-99887766",
150
  "prioridad": "ALTA",
151
+ "hospital_id": sys.argv[3],
152
  "observaciones": "Paciente requiere oxígeno suplementario",
153
+ "timestamp": sys.argv[4],
154
+ }))
155
+ ' "$PACIENTE_ID" "$CAMA_ID" "$HOSPITAL_ID" "$(date -u +%Y-%m-%dT%H:%M:%SZ)")
156
+
157
+ curl -s -X POST "$CORE_URL/events/log" \
158
+ -H "Authorization: Bearer $CORE_TOKEN" \
159
+ -H "Content-Type: application/json" \
160
+ -d '{
161
+ "event_type_id": 14,
162
+ "publisher_module": "hce",
163
+ "payload": '"$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$PAYLOAD")"'
164
  }'
165
  ```
166
 
167
+ La respuesta de `POST /events/log` solo confirma que el Core **recibió** el evento — no que
168
+ M6 ya lo procesó. El procesamiento es asíncrono.
169
 
170
+ ### 2.3 — Verificar que M6 la procesó (polling)
171
+
172
+ ```bash
173
+ for i in $(seq 1 10); do
174
+ RESP=$(curl -s "$M6_URL/solicitudes?estado=PENDIENTE&hospital_id=$HOSPITAL_ID" \
175
+ -H "Authorization: Bearer $M6_TOKEN")
176
+ echo "$RESP" | python3 -c "
177
+ import json, sys
178
+ data = json.load(sys.stdin)
179
+ match = [s for s in data['solicitudes'] if s['paciente_id'] == $PACIENTE_ID]
180
+ if match:
181
+ print('OK:', match[0]['id'], match[0]['estado'])
182
+ sys.exit(0)
183
+ sys.exit(1)
184
+ " && break
185
+ echo "todavía no llegó, reintentando en 2s ($i/10)..."
186
+ sleep 2
187
+ done
188
  ```
189
 
190
+ Si a los ~20s no apareció, ver la sección **Troubleshooting** más abajo antes de seguir.
191
 
192
  ```bash
193
+ export SOLICITUD_ID="SOL-00001" # el id que devolvió el polling de arriba
194
  ```
195
 
196
  ---
197
 
198
  ## 3. [M6] Aprobar la solicitud
199
 
200
+ **Esto no pasa por la cola** — es una acción de administración de M6, siempre REST.
201
+
202
  ```bash
203
  curl -s -X PATCH "$M6_URL/solicitudes/$SOLICITUD_ID" \
204
  -H "Authorization: Bearer $M6_TOKEN" \
 
206
  -d '{"accion": "APROBAR"}'
207
  ```
208
 
209
+ Con `MOCK_EXTERNAL_SERVICES=false`, esto dispara llamadas reales:
210
+ `core.validate_patient` (M10 — por eso `PACIENTE_ID` debe existir ahí),
211
+ `hce.get_contraindicaciones`/`notify_movimiento`/`notify_resultado_solicitud` (M1), y
212
+ `monitoreo.notify_alta` (M9). Un `502 SERVICIO_EXTERNO_NO_DISPONIBLE` acá indica que alguno de
213
+ esos servicios no respondió o el paciente no existe en el Core — no es un problema de la cola.
214
 
215
+ Respuesta esperada (`200`): `estado: "APROBADA"`, `cama_asignada_id` seteado.
216
 
217
  ```bash
218
  curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN"
 
220
 
221
  ---
222
 
223
+ ## 4. [Cola] Publicar el evento de alta médica
224
+
225
+ `event_type_id=15` (`internacion.alta-medica.registrada`) → `dispatch` →
226
+ `solicitud_service.procesar_alta_medica`.
227
 
228
  ```bash
229
+ PAYLOAD=$(python3 -c '
230
+ import json, sys
231
+ print(json.dumps({
232
+ "paciente_id": int(sys.argv[1]),
 
233
  "medico_firmante_id": 10,
234
  "tipo_alta": "ALTA_MEDICA",
235
+ "timestamp": sys.argv[2],
236
+ }))
237
+ ' "$PACIENTE_ID" "$(date -u +%Y-%m-%dT%H:%M:%SZ)")
238
+
239
+ curl -s -X POST "$CORE_URL/events/log" \
240
+ -H "Authorization: Bearer $CORE_TOKEN" \
241
+ -H "Content-Type: application/json" \
242
+ -d '{
243
+ "event_type_id": 15,
244
+ "publisher_module": "hce",
245
+ "payload": '"$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$PAYLOAD")"'
246
  }'
247
  ```
248
 
249
+ ### 4.1 — Verificar que la cama pasó a limpieza (polling)
250
 
251
+ ```bash
252
+ for i in $(seq 1 10); do
253
+ ESTADO=$(curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN" \
254
+ | python3 -c "import json,sys; print(json.load(sys.stdin)['estado'])")
255
+ echo "estado actual: $ESTADO"
256
+ [ "$ESTADO" = "EN_LIMPIEZA" ] && break
257
+ sleep 2
258
+ done
259
  ```
260
 
261
+ ### 4.2 — Confirmar la notificación saliente real a M7 (`CIERRE_INTERNACION`)
262
+
263
+ Con `MOCK_EXTERNAL_SERVICES=false`, `procesar_alta_medica` dispara `facturacion.notify_cama_lista`,
264
+ que publica el evento `CIERRE_INTERNACION` (`event_type_id=19`, `publisher_module="modulo_6"`)
265
+ al Core además de un `POST` REST directo a M7. Confirmarlo en los **logs de M6** (debería verse
266
+ la llamada saliente a `POST {M10_CORE_URL}/events/log` y a
267
+ `{M7_FACTURACION_URL}/api/v1/webhooks/internacion/cama-lista`) y, si hay acceso, del lado de M7
268
+ (`https://modulo7-backend.onrender.com`) que el cierre llegó — quedará `RECIBIDO_PENDIENTE_DATOS`
269
+ si `idEpisodioExterno` sigue en `None` (pendiente de M1, ver `M6_EVENTOS_RABBITMQ.md` §9).
270
+
271
+ > **Si en los logs aparece `Evento no publicado (event_type_id todavía no configurado)`
272
+ > para `CIERRE_INTERNACION`**, no es un problema del payload — es que
273
+ > `facturacion_cama_lista_event_type_id` resolvió a `None` en el proceso corriendo (pasó una
274
+ > vez: la variable HF nunca llegó a impactar, mismo patrón que otros casos de esta
275
+ > conversación). Confirmar primero con `GET /api/v1/_debug/settings` que ese campo sea `19`
276
+ > antes de sospechar del código.
277
+ >
278
+ > El `POST` REST directo a M7 puede devolver `401 Unauthorized` — es conocido y no bloquea
279
+ > el alta (es fire-and-forget): M7 no documenta ningún `Authorization` para ese endpoint de
280
+ > fallback/testing manual, y M6 igual manda el Bearer de la cuenta de servicio del Core. Sin
281
+ > resolver todavía del lado de M7; la vía oficial es el evento del bus, no este REST.
282
 
283
  ### Verificación final
284
 
 
288
  ```
289
 
290
  `GET /auditoria` debe mostrar la traza completa: `SOLICITUD_RECIBIDA` →
291
+ `SOLICITUD_APROBADA` → `CAMA_ASIGNADA` → `CAMA_ALTA` — igual que en el flujo por REST directo,
292
+ la vía de entrada (cola vs. webhook) no cambia el resultado de negocio.
293
+
294
+ ---
295
+
296
+ ## Troubleshooting
297
+
298
+ - **La solicitud/cama nunca aparece tras publicar el evento.** El mensaje puede haber caído a
299
+ la dead-letter queue `internacion.requests.dlq` (panel de RabbitMQ) — pasa cuando el JSON
300
+ está malformado, `event_type_name` no está mapeado, o la función de servicio lanzó una
301
+ excepción (p.ej. cama inexistente, `solicitud_hce_id` repetido con otro payload). Revisar los
302
+ logs de M6: cada rechazo loguea `Error procesando <event_type_name> (log_id=...)`.
303
+ - **`502` al aprobar la solicitud.** No es un problema de la cola — es que `MOCK_EXTERNAL_SERVICES=false`
304
+ y algún servicio externo (M10/M1/M9) no respondió, o `PACIENTE_ID` no existe en el Core.
305
+ - **Reintentar un evento no duplica nada.** La deduplicación es por `solicitud_hce_id`
306
+ (`recibir_solicitud`) — si hay que reintentar el paso 2 tras corregir algo, alcanza con
307
+ volver a publicar el mismo `POST /events/log`.
308
+ - **`/_debug/settings` muestra `rabbitmq_consumer_enabled: false` o URLs en `localhost`.**
309
+ Las variables de HF no llegaron al proceso — ver la sección de diagnóstico de variables/secrets
310
+ más arriba en esta conversación (mismo endpoint, mismo mecanismo).
tests/test_core_events.py CHANGED
@@ -147,9 +147,10 @@ def test_notify_cama_lista_sigue_llamando_rest_con_payload_minimo(monkeypatch):
147
  "evento": "CAMA_LISTA",
148
  "idEventoExterno": payload["idEventoExterno"],
149
  "camaId": "315",
150
- "idPacienteExterno": 7,
151
  "timestampEvento": payload["timestampEvento"],
152
  }
 
153
 
154
 
155
  def test_notify_cama_lista_publica_evento_rico_con_datos_del_episodio(monkeypatch):
@@ -183,12 +184,12 @@ def test_notify_cama_lista_publica_evento_rico_con_datos_del_episodio(monkeypatc
183
  assert event_type_id == 19
184
  assert publisher_module == "modulo_6"
185
  assert payload["evento"] == "CIERRE_INTERNACION"
186
- assert payload["camaId"] == "315"
 
187
  assert payload["idInternacionExterna"] == "HCE-SOL-00123"
188
  assert payload["idEpisodioExterno"] is None # bloqueante externo — M1 no lo provee aún
189
- assert payload["idPacienteExterno"] == 7
190
- assert payload["fechaIngreso"] == "2026-06-20T14:30:00+00:00"
191
- assert payload["fechaAlta"] == "2026-06-25T10:00:00+00:00"
192
  assert payload["tipoAlta"] == "ALTA_MEDICA"
193
- assert "timestampEvento" in payload and payload["timestampEvento"] # siempre presente
194
- assert isinstance(payload["camasUtilizadas"], list) and len(payload["camasUtilizadas"]) >= 1
 
147
  "evento": "CAMA_LISTA",
148
  "idEventoExterno": payload["idEventoExterno"],
149
  "camaId": "315",
150
+ "idPacienteExterno": "7",
151
  "timestampEvento": payload["timestampEvento"],
152
  }
153
+ assert payload["timestampEvento"].endswith("Z")
154
 
155
 
156
  def test_notify_cama_lista_publica_evento_rico_con_datos_del_episodio(monkeypatch):
 
184
  assert event_type_id == 19
185
  assert publisher_module == "modulo_6"
186
  assert payload["evento"] == "CIERRE_INTERNACION"
187
+ assert "camaId" not in payload # no es parte del contrato de M7 — ver M6_DISEÑO.md §7.2
188
+ assert "camasUtilizadas" not in payload
189
  assert payload["idInternacionExterna"] == "HCE-SOL-00123"
190
  assert payload["idEpisodioExterno"] is None # bloqueante externo — M1 no lo provee aún
191
+ assert payload["idPacienteExterno"] == "7" # string, como documenta el contrato de M7
192
+ assert payload["fechaIngreso"] == "2026-06-20T14:30:00Z"
193
+ assert payload["fechaAlta"] == "2026-06-25T10:00:00Z"
194
  assert payload["tipoAlta"] == "ALTA_MEDICA"
195
+ assert "timestampEvento" in payload and payload["timestampEvento"].endswith("Z")