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`