Mate11 commited on
Commit
0e75654
·
1 Parent(s): 17c36bc

Integracion con M7 para las altas de las camas

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