File size: 13,487 Bytes
0e75654 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 | # Estado de Integración M6 ↔ M7 (Facturación)
> **Fecha de revisión:** 2026-07-12
> **Módulo origen:** M6 — Internación y Gestión de Camas
> **Módulo destino:** M7 — Facturación
> **Dirección del flujo:** unidireccional M6 → M7 (M7 no envía datos a M6)
---
## Método de integración
### Canal principal — Evento asincrónico vía Core/RabbitMQ (M10)
M6 publica un evento al bus del Core cuando se cierra una internación. M7 consume ese evento desde su cola `facturacion.requests`.
```
M6 backend
└─ POST /webhooks/hce/alta-medica (M1 avisa el alta médica)
└─ solicitud_service.procesar_alta_medica()
└─ facturacion.notify_cama_lista(cama, db)
└─ POST https://api.healthcare.cantero.ar/events/log
payload:
event_type_id: 19
publisher_module: "modulo_6"
payload: JSON.stringify({ evento: "CIERRE_INTERNACION", ... })
```
Datos del evento confirmados por M7:
```
event_name: facturacion.internacion.cama-lista.requested
event_type_id: 19
queue: facturacion.requests
publisher: modulo_6
```
### Canal fallback — REST directo a M7
Para testing manual o ante caída del Core, M7 expone dos endpoints REST que usan el mismo schema `InternacionM6Request`:
| Endpoint | Comportamiento |
|----------|---------------|
| `POST /api/v1/webhooks/internacion/cama-lista` | Persiste el evento, idempotente por `idEventoExterno` |
| `POST /api/integracion/internacion/cierre-episodio` | Igual + **si recibe paciente y episodio, consulta M1/HCE y registra los actos médicos facturables automáticamente** |
Ambos endpoints están implementados en `app/integrations/facturacion.py::notify_cama_lista()`.
> El endpoint `cierre-episodio` es el preferible para producción porque hace más trabajo automático del lado de M7.
---
## Schema `InternacionM6Request` (OpenAPI de M7)
Ambos endpoints REST usan el mismo schema. **Solo 2 campos son `required`.**
| Campo | Tipo | Req | Descripción |
|-------|------|-----|-------------|
| `idPacienteExterno` | `integer` | ✅ | ID numérico del paciente |
| `timestampEvento` | `datetime` | ✅ | Timestamp del cierre |
| `evento` | `string` | — | `"CIERRE_INTERNACION"` o `"CAMA_LISTA"` |
| `camaId` | `string` | — | ID de la cama |
| `idEventoExterno` | `string` | — | Clave de idempotencia |
| `idInternacionExterna` | `string` | — | ID de la solicitud HCE |
| `idEpisodioExterno` | `string` | — | ID del episodio clínico (M1) |
| `fechaIngreso` | `datetime` | — | Fecha de ingreso a la cama |
| `fechaAlta` | `datetime` | — | Fecha del alta médica |
| `tipoAlta` | `string` | — | Ej: `"ALTA_MEDICA"` |
| `medicoSolicitanteId` | `string` | — | ID del médico solicitante |
| `medicoFirmanteId` | `string` | — | ID del médico firmante del alta |
| `diagnosticoIngreso` | `string` | — | Diagnóstico de ingreso |
| `observaciones` | `string` | — | Observaciones adicionales |
| `camasUtilizadas` | `array` | — | Tramos de uso de cama (ver abajo) |
`camasUtilizadas[]` (cada ítem):
```json
{ "camaId": "101", "sector": "SALA_COMUN", "tipoCama": "SALA_COMUN",
"desde": "2026-06-20T14:30:00Z", "hasta": "2026-06-22T09:00:00Z" }
```
**Payload que enviamos actualmente** (canal Core/RabbitMQ — evento `CIERRE_INTERNACION`):
```json
{
"evento": "CIERRE_INTERNACION",
"idEventoExterno": "M6-CIERRE-INT-{cama_id}-{paciente_id}-{fecha}",
"idInternacionExterna": "{solicitud_hce_id}",
"idEpisodioExterno": null,
"idPacienteExterno": "{paciente_id}",
"fechaIngreso": "2026-06-20T14:30:00+00:00",
"fechaAlta": "2026-06-25T10:00:00+00:00",
"tipoAlta": "ALTA_MEDICA",
"timestampEvento": "2026-06-25T10:05:00+00:00"
}
```
> **Nota:** cuando M7 recibe `idPacienteExterno` + `idEpisodioExterno`, consulta M1/HCE automáticamente para registrar los actos médicos facturables del episodio. Sin `idEpisodioExterno` el cierre queda pendiente de completar de su lado.
---
## ✅ Hecho
| Qué | Dónde |
|-----|-------|
| Cliente de integración `notify_cama_lista()` | `app/integrations/facturacion.py` |
| Publicación de evento Core vía `publish_event()` | `app/integrations/core_events.py` |
| Payload rico `CIERRE_INTERNACION` (canal principal) | `facturacion.py` línea 51–64 |
| Payload mínimo `CAMA_LISTA` (canal fallback REST) | `facturacion.py` línea 40–48 |
| Persistencia de datos del episodio en `Cama` | `app/models/cama.py` (campos `solicitud_hce_id`, `fecha_ingreso`, `alta_tipo`, `alta_timestamp`) |
| Datos del episodio se guardan al aprobar internación | `solicitud_service.py` línea 202–203 |
| Datos del alta se guardan al procesar alta médica | `solicitud_service.py` línea 353–354 |
| Disparo en el momento correcto: alta médica (webhook de M1) | `solicitud_service.py::procesar_alta_medica` |
| Test de regresión: alta médica debe notificar a M7 | `tests/test_webhooks.py::test_alta_medica_notifica_a_facturacion` |
| Idempotencia del evento (`idEventoExterno` estable) | `facturacion.py` línea 38 |
| URL de M7 configurable | `config.py` → `m7_facturacion_url` |
| Variable de configuración `facturacion_cama_lista_event_type_id` | `config.py` línea 108 |
| Tests de integración (REST, evento Core, mock) | `tests/test_core_events.py` líneas 128–189 |
| Documentación del contrato de M7 | `documentation/integrations/M7_integration.md` |
---
## 🐛 Bugs encontrados al contrastar con el OpenAPI de M7
Hallados al comparar `app/integrations/facturacion.py` contra el schema real (`InternacionM6Request`):
### Bug 1 — REST fallback con nombres de campo incorrectos
El payload del canal REST fallback usa snake_case pero el schema espera camelCase:
| Código actual | Schema real |
|---------------|-------------|
| `"cama_id"` | `"camaId"` |
| `"paciente_id"` | `"idPacienteExterno"` |
| `"timestamp_evento"` | `"timestampEvento"` |
Esto significa que el canal REST fallback está enviando campos que M7 no reconoce (los ignora silenciosamente) y **no está enviando los campos que M7 sí lee**.
**Archivo:** `app/integrations/facturacion.py` línea 40–48.
### Bug 2 — `idPacienteExterno` enviado como string, el schema exige integer
El canal Core/RabbitMQ construye el payload con `"idPacienteExterno": str(paciente_id)`.
El OpenAPI de M7 define `idPacienteExterno` como `integer (int64)`.
**Archivo:** `app/integrations/facturacion.py` línea 57.
### Campos que M7 acepta y no estamos enviando (opcionales)
Los siguientes campos del schema están disponibles pero no los usamos todavía:
- `camaId` — ID de la cama (disponible en `cama.id`)
- `medicoFirmanteId` — ID del médico firmante (viene en `AltaMedicaWebhook.medico_firmante_id`, ya lo tenemos en el webhook pero no lo persistimos en `Cama`)
- `diagnosticoIngreso` — no se persiste en M6
- `camasUtilizadas[]` — tramos de uso de cama (ver sección dedicada abajo)
---
## 🟡 A medias / pendiente de activar
### 1. `idEpisodioExterno` va siempre como `null`
M1 no provee el ID del episodio clínico en el webhook `AltaMedicaWebhook`. El campo viaja como `null` en el evento a M7.
**Impacto:** M7 confirmó que el evento no se rechaza, pero queda "pendiente de completar" de su lado hasta que M1 lo provea.
**Desbloqueante:** coordinación con el equipo de M1 para que incluyan `episodio_id` en el payload del alta.
### 2. `FACTURACION_CAMA_LISTA_EVENT_TYPE_ID` ya configurado en `.env`, pero bloqueado por mock
El `event_type_id=19` está seteado en el `.env` real (`FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=19`). Sin embargo, `MOCK_EXTERNAL_SERVICES=true` hace que `notify_cama_lista()` retorne `True` de inmediato sin hacer ningún request.
**Impacto:** el canal Core/RabbitMQ está configurado pero inactivo en dev. En producción, para que realmente dispare hay que asegurarse de que `MOCK_EXTERNAL_SERVICES=false`.
**Nota:** el `.env.example` lo tiene comentado por diseño (para que quien clone el repo no active el event bus sin querer).
### 3. Credenciales de cuenta de servicio no configuradas
El header `Authorization` de las llamadas al Core requiere `CORE_SERVICE_EMAIL` y `CORE_SERVICE_PASSWORD`. Sin estos, el POST a `/events/log` sale sin auth.
**Para activar:** obtener las credenciales con el equipo de M10 y agregarlas al `.env`.
---
## 🔴 Falta
No hay bloqueantes de backend para el flujo principal. El único pendiente es coordinar `idEpisodioExterno` con M1 (ver sección 🟡).
---
## Flujo completo (cuando todo esté activado)
```
1. M1 → POST /webhooks/hce/alta-medica
└─ cama pasa a EN_LIMPIEZA
└─ se persisten alta_tipo y alta_timestamp en la cama
└─ facturacion.notify_cama_lista(cama, db) ←── acá se dispara M7
2. notify_cama_lista():
a) REST fallback → POST M7_URL/api/v1/webhooks/internacion/cama-lista (payload mínimo)
b) Core/RabbitMQ → POST Core/events/log (payload rico CIERRE_INTERNACION, event_type_id=19)
3. Personal de limpieza → PATCH /camas/{id} { estado: DISPONIBLE }
└─ cama_service limpia los campos del episodio de la cama (paciente_id, alta_tipo, etc.)
└─ cama queda disponible para el próximo paciente
4. M7 recibe el evento desde su cola facturacion.requests
└─ consulta a M1 con idPacienteExterno + idEpisodioExterno
└─ factura la internación con su propio ABM de obras sociales
```
---
## `camasUtilizadas[]` — cómo reconstruir los tramos
El campo `camasUtilizadas` es opcional en el schema de M7. Representa los tramos de uso de cada cama durante toda la internación (relevante cuando hubo traslados).
### Caso sin traslados (mayoría de casos)
En el momento en que `notify_cama_lista(cama, db)` dispara, la `cama` ya tiene todos los datos del único tramo:
```python
camas_utilizadas = [{
"camaId": str(cama.id),
"sector": cama.sector,
"tipoCama": cama.tipo,
"desde": cama.fecha_ingreso.isoformat() if cama.fecha_ingreso else None,
"hasta": cama.alta_timestamp.isoformat() if cama.alta_timestamp else None,
}]
```
### Caso con traslados — reconstrucción desde auditoria
Si el paciente pasó por múltiples camas, la información está en la tabla `auditoria`. Los eventos relevantes son:
| Evento | Qué marca |
|--------|-----------|
| `CAMA_ASIGNADA` | Inicio del tramo en esa cama (campo `cama_id`, `creado_en`) |
| `SOLICITUD_APROBADA` (traslado) | Fin del tramo anterior + inicio del siguiente (`detalle.cama_origen_id`, `detalle.cama_asignada_id`) |
| `CAMA_ALTA` | Fin del último tramo |
**Reconstrucción para un paciente que pasó por cama A → cama B:**
```
auditoria (ordenada por creado_en ASC, filtrada por paciente_id):
T1 → CAMA_ASIGNADA cama_id=1 ← ingreso a cama A
T2 → SOLICITUD_APROBADA cama_id=2, detalle.cama_origen_id=1 ← traslado A→B
T3 → CAMA_ALTA cama_id=2 ← alta médica en cama B
Tramos resultantes:
{ camaId:"1", desde:T1, hasta:T2 } ← tramo cama A
{ camaId:"2", desde:T2, hasta:T3 } ← tramo cama B (= cama final)
```
Para `sector` y `tipoCama` de cada `camaId` histórico: query a `camas` por id. Se asume que no cambiaron de sector/tipo desde que el paciente estuvo ahí.
### Query a auditoria
```python
resp = db.table("auditoria") \
.select("*") \
.eq("paciente_id", paciente_id) \
.in_("evento", ["CAMA_ASIGNADA", "SOLICITUD_APROBADA", "CAMA_ALTA"]) \
.order("creado_en") \
.execute()
```
### Implementación pendiente
Para implementar `camasUtilizadas` completo se requiere:
1. Pasar `db: Client` a `notify_cama_lista(cama, db)` (hoy no recibe la sesión de DB)
2. Actualizar el call site en `cama_service.py` línea 145
3. Agregar la función `_reconstruir_tramos(db, paciente_id, cama_final)` en `facturacion.py`
4. Actualizar tests en `test_core_events.py` (nueva firma + assert del campo)
**Estado:** pendiente de implementar. El campo es opcional, M7 no lo requiere para procesar el cierre.
---
## Checklist para poner el canal principal en producción
**Fixes de código requeridos (ver sección 🐛):**
- [ ] Corregir nombres de campo del REST fallback: `cama_id`→`camaId`, `paciente_id`→`idPacienteExterno`, `timestamp_evento`→`timestampEvento` (`facturacion.py` línea 40–48)
- [ ] Corregir tipo de `idPacienteExterno`: de `str(paciente_id)` a `paciente_id` (int) (`facturacion.py` línea 57)
**Configuración:**
- [ ] ~~`FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=19`~~ ya configurado en `.env` ✓ — verificar que esté en el deploy de producción
- [ ] Setear `MOCK_EXTERNAL_SERVICES=false` en producción (hoy bloquea toda llamada saliente)
- [ ] Configurar `CORE_SERVICE_EMAIL` y `CORE_SERVICE_PASSWORD` con las credenciales reales de M6 en M10
- [ ] Confirmar con M10 que la cola `facturacion.requests` está bindeada al `event_type_id=19`
**Coordinación entre módulos:**
- [ ] Coordinar con M1 para que provea `episodio_id` en el webhook de alta (desbloquea `idEpisodioExterno` → M7 factura automáticamente)
- [ ] Verificar con M7 que los eventos están llegando y siendo procesados
**Mejoras opcionales (enriquecen el payload):**
- [ ] Implementar `camasUtilizadas[]` reconstruyendo tramos desde auditoria (requiere pasar `db` a `notify_cama_lista`)
- [ ] Persistir `medico_firmante_id` en `Cama` al procesar el alta médica para poder enviarlo como `medicoFirmanteId`
|