Mate11 commited on
Commit ·
0e75654
1
Parent(s): 17c36bc
Integracion con M7 para las altas de las camas
Browse files- app/integrations/facturacion.py +92 -6
- app/services/cama_service.py +1 -2
- app/services/solicitud_service.py +5 -4
- documentation/integracion_m7_estado.md +287 -0
- tests/test_core_events.py +8 -6
- tests/test_webhooks.py +9 -10
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
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
"
|
| 44 |
-
"
|
| 45 |
-
"
|
| 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":
|
| 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,
|
| 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 |
-
"
|
| 150 |
-
"
|
| 151 |
-
"
|
| 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"] ==
|
| 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
|
| 58 |
"""
|
| 59 |
-
El alta médica
|
| 60 |
-
|
| 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 |
-
|
| 70 |
-
|
| 71 |
-
|
| 72 |
-
|
| 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):
|