Implementacion algoritmo de cirugias urgencias. Desplazamiento de turnos de menor prioridad. Documentacion.
Browse files- .env.example +2 -0
- app/crud/reserva.py +23 -0
- app/integrations/turnos.py +23 -2
- app/routers/webhooks.py +23 -15
- app/schemas/reserva.py +13 -1
- app/services/cama_service.py +141 -94
- documentation/M6_DISEÑO.md +18 -5
- documentation/M6_demo_payloads.md +22 -7
- documentation/M6_openapi.json +59 -46
- documentation/algoritmo_urgencias.md +173 -0
- tests/test_webhooks.py +185 -45
.env.example
CHANGED
|
@@ -1,5 +1,7 @@
|
|
| 1 |
# ─── Base de datos ─────────────────────────────────────────────────────────
|
| 2 |
DATABASE_URL=postgresql://USUARIO:CONTRASEÑA@HOST/NOMBRE_BD?sslmode=require&channel_binding=require
|
|
|
|
|
|
|
| 3 |
|
| 4 |
# ─── JWT ───────────────────────────────────────────────────────────────────
|
| 5 |
# Generar con: python -c "import secrets; print(secrets.token_hex(32))"
|
|
|
|
| 1 |
# ─── Base de datos ─────────────────────────────────────────────────────────
|
| 2 |
DATABASE_URL=postgresql://USUARIO:CONTRASEÑA@HOST/NOMBRE_BD?sslmode=require&channel_binding=require
|
| 3 |
+
SUPABASE_URL=https://<tu-proyecto>.supabase.co
|
| 4 |
+
SUPABASE_KEY=<tu-service_role-key>
|
| 5 |
|
| 6 |
# ─── JWT ───────────────────────────────────────────────────────────────────
|
| 7 |
# Generar con: python -c "import secrets; print(secrets.token_hex(32))"
|
app/crud/reserva.py
CHANGED
|
@@ -91,6 +91,22 @@ def get_superpuestas(
|
|
| 91 |
return [ReservaQuirofano.from_dict(row) for row in resp.data]
|
| 92 |
|
| 93 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 94 |
def get_activa_por_turno(db: Client, turno_id: int) -> ReservaQuirofano | None:
|
| 95 |
resp = (
|
| 96 |
db.table(_TABLE)
|
|
@@ -144,6 +160,13 @@ def save(db: Client, reserva: ReservaQuirofano) -> ReservaQuirofano:
|
|
| 144 |
"estado": reserva.estado,
|
| 145 |
"observaciones": reserva.observaciones,
|
| 146 |
"desplazada_por_reserva_id": reserva.desplazada_por_reserva_id,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 147 |
}
|
| 148 |
db.table(_TABLE).update(updates).eq("id", reserva.id).execute()
|
| 149 |
return reserva
|
|
|
|
| 91 |
return [ReservaQuirofano.from_dict(row) for row in resp.data]
|
| 92 |
|
| 93 |
|
| 94 |
+
def get_futuras(db: Client, cama_id: int, desde: datetime) -> list[ReservaQuirofano]:
|
| 95 |
+
"""Reservas activas (RESERVADA/EN_CURSO) del quirófano que todavía no terminaron
|
| 96 |
+
en `desde`, ordenadas por inicio. Base para calcular el inicio más temprano factible
|
| 97 |
+
de una cirugía urgente (algoritmo ASAP, ver cama_service.crear_reserva_urgente)."""
|
| 98 |
+
resp = (
|
| 99 |
+
db.table(_TABLE)
|
| 100 |
+
.select("*")
|
| 101 |
+
.eq("cama_id", cama_id)
|
| 102 |
+
.in_("estado", ["RESERVADA", "EN_CURSO"])
|
| 103 |
+
.gt("fecha_hora_fin_estimada", desde.isoformat())
|
| 104 |
+
.order("fecha_hora_inicio")
|
| 105 |
+
.execute()
|
| 106 |
+
)
|
| 107 |
+
return [ReservaQuirofano.from_dict(row) for row in resp.data]
|
| 108 |
+
|
| 109 |
+
|
| 110 |
def get_activa_por_turno(db: Client, turno_id: int) -> ReservaQuirofano | None:
|
| 111 |
resp = (
|
| 112 |
db.table(_TABLE)
|
|
|
|
| 160 |
"estado": reserva.estado,
|
| 161 |
"observaciones": reserva.observaciones,
|
| 162 |
"desplazada_por_reserva_id": reserva.desplazada_por_reserva_id,
|
| 163 |
+
# fecha_hora_inicio/fin también se persisten: una reserva reprogramada por
|
| 164 |
+
# una urgencia (cama_service.reprogramar) cambia su ventana horaria y eso
|
| 165 |
+
# tiene que quedar en la DB de M6, no solo notificarse a M2.
|
| 166 |
+
"fecha_hora_inicio": reserva.fecha_hora_inicio.isoformat() if reserva.fecha_hora_inicio else None,
|
| 167 |
+
"fecha_hora_fin_estimada": (
|
| 168 |
+
reserva.fecha_hora_fin_estimada.isoformat() if reserva.fecha_hora_fin_estimada else None
|
| 169 |
+
),
|
| 170 |
}
|
| 171 |
db.table(_TABLE).update(updates).eq("id", reserva.id).execute()
|
| 172 |
return reserva
|
app/integrations/turnos.py
CHANGED
|
@@ -5,12 +5,20 @@ M6 no cancela turnos en M2: la cancelación siempre llega como webhook entrante
|
|
| 5 |
(POST /turnos/{turno_id}/cancelacion). Lo único que M6 le pide a M2 es reprogramar
|
| 6 |
un turno cuando una cirugía urgente desplaza a una reserva programada (la cirugía
|
| 7 |
desplazada no se cancela, se mueve a un nuevo horario).
|
|
|
|
|
|
|
|
|
|
|
|
|
| 8 |
"""
|
|
|
|
|
|
|
| 9 |
from datetime import datetime
|
| 10 |
|
| 11 |
from app.config import settings
|
| 12 |
from app.integrations._base import _patch
|
| 13 |
|
|
|
|
|
|
|
| 14 |
# Formato de fecha que espera M2 en el body de reschedule: "YYYY-MM-DD HH:mm:ss".
|
| 15 |
_M2_DT_FORMAT = "%Y-%m-%d %H:%M:%S"
|
| 16 |
|
|
@@ -20,12 +28,25 @@ def reschedule_turno(turno_id: int, starts_at: datetime, ends_at: datetime) -> b
|
|
| 20 |
Reprograma un turno en M2 (`PATCH /appointments/{turno_id}/reschedule`).
|
| 21 |
Devuelve True si M2 confirmó la reprogramación.
|
| 22 |
"""
|
| 23 |
-
if settings.mock_external_services:
|
| 24 |
-
return True
|
| 25 |
payload = {
|
| 26 |
"starts_at": starts_at.strftime(_M2_DT_FORMAT),
|
| 27 |
"ends_at": ends_at.strftime(_M2_DT_FORMAT),
|
| 28 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 29 |
return _patch(
|
| 30 |
f"{settings.m2_turnos_url}/appointments/{turno_id}/reschedule", payload
|
| 31 |
) is not None
|
|
|
|
| 5 |
(POST /turnos/{turno_id}/cancelacion). Lo único que M6 le pide a M2 es reprogramar
|
| 6 |
un turno cuando una cirugía urgente desplaza a una reserva programada (la cirugía
|
| 7 |
desplazada no se cancela, se mueve a un nuevo horario).
|
| 8 |
+
|
| 9 |
+
Contrato tomado de `documentation/M2_openapi.json` (`PATCH /appointments/{id}/reschedule`):
|
| 10 |
+
body `{starts_at, ends_at}` en formato `"YYYY-MM-DD HH:mm:ss"`, response
|
| 11 |
+
`{message, notification_id}`.
|
| 12 |
"""
|
| 13 |
+
import logging
|
| 14 |
+
import uuid
|
| 15 |
from datetime import datetime
|
| 16 |
|
| 17 |
from app.config import settings
|
| 18 |
from app.integrations._base import _patch
|
| 19 |
|
| 20 |
+
logger = logging.getLogger(__name__)
|
| 21 |
+
|
| 22 |
# Formato de fecha que espera M2 en el body de reschedule: "YYYY-MM-DD HH:mm:ss".
|
| 23 |
_M2_DT_FORMAT = "%Y-%m-%d %H:%M:%S"
|
| 24 |
|
|
|
|
| 28 |
Reprograma un turno en M2 (`PATCH /appointments/{turno_id}/reschedule`).
|
| 29 |
Devuelve True si M2 confirmó la reprogramación.
|
| 30 |
"""
|
|
|
|
|
|
|
| 31 |
payload = {
|
| 32 |
"starts_at": starts_at.strftime(_M2_DT_FORMAT),
|
| 33 |
"ends_at": ends_at.strftime(_M2_DT_FORMAT),
|
| 34 |
}
|
| 35 |
+
if settings.mock_external_services:
|
| 36 |
+
# Mock a nivel de cliente (M6_DISEÑO.md §7.4): no sale ninguna llamada de
|
| 37 |
+
# red, pero el payload se arma igual que en producción (mismo template de
|
| 38 |
+
# M2_openapi.json) y se loguea junto con la respuesta enlatada, para que
|
| 39 |
+
# quede visible qué se le habría informado a M2 sobre este turno.
|
| 40 |
+
mock_response = {
|
| 41 |
+
"message": "Appointment rescheduled successfully",
|
| 42 |
+
"notification_id": str(uuid.uuid4()),
|
| 43 |
+
}
|
| 44 |
+
logger.info(
|
| 45 |
+
"[MOCK M2] PATCH %s/appointments/%s/reschedule payload=%s",
|
| 46 |
+
settings.m2_turnos_url, turno_id, payload,
|
| 47 |
+
)
|
| 48 |
+
logger.info("[MOCK M2] respuesta enlatada: %s", mock_response)
|
| 49 |
+
return True
|
| 50 |
return _patch(
|
| 51 |
f"{settings.m2_turnos_url}/appointments/{turno_id}/reschedule", payload
|
| 52 |
) is not None
|
app/routers/webhooks.py
CHANGED
|
@@ -70,8 +70,10 @@ def recibir_alta_medica(
|
|
| 70 |
"/hce/cirugia-urgente",
|
| 71 |
summary="[M1] Recibir solicitud de cirugía urgente",
|
| 72 |
responses={
|
|
|
|
|
|
|
| 73 |
401: {"description": "No autenticado"},
|
| 74 |
-
409: {"description": "Sin quirófano
|
| 75 |
422: {"description": "Payload inválido"},
|
| 76 |
},
|
| 77 |
)
|
|
@@ -80,30 +82,36 @@ def recibir_cirugia_urgente(
|
|
| 80 |
db: Client = Depends(get_db),
|
| 81 |
user: dict = Depends(get_current_user),
|
| 82 |
):
|
| 83 |
-
reserva_urgente,
|
| 84 |
resp_reserva = ReservaQuirofanoResponse.model_validate(reserva_urgente)
|
| 85 |
|
| 86 |
-
|
| 87 |
-
|
| 88 |
-
|
| 89 |
-
|
| 90 |
-
|
| 91 |
-
|
| 92 |
-
|
| 93 |
-
notificado_a_m2=bool(reserva_desplazada.turno_id),
|
| 94 |
)
|
|
|
|
|
|
|
| 95 |
|
| 96 |
-
|
| 97 |
-
|
| 98 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 99 |
|
| 100 |
content = CirugiaUrgenteResponse(
|
| 101 |
mensaje=msg,
|
| 102 |
reserva=resp_reserva,
|
| 103 |
-
|
| 104 |
).model_dump(mode="json")
|
| 105 |
|
| 106 |
-
|
|
|
|
| 107 |
|
| 108 |
|
| 109 |
# ─── Desde M2 (Turnos) ─────────────────────────────────────────────────────
|
|
|
|
| 70 |
"/hce/cirugia-urgente",
|
| 71 |
summary="[M1] Recibir solicitud de cirugía urgente",
|
| 72 |
responses={
|
| 73 |
+
200: {"description": "Ya existía una reserva para esta solicitud (idempotencia)"},
|
| 74 |
+
201: {"description": "Reserva urgente creada"},
|
| 75 |
401: {"description": "No autenticado"},
|
| 76 |
+
409: {"description": "Sin quirófano compatible/operable"},
|
| 77 |
422: {"description": "Payload inválido"},
|
| 78 |
},
|
| 79 |
)
|
|
|
|
| 82 |
db: Client = Depends(get_db),
|
| 83 |
user: dict = Depends(get_current_user),
|
| 84 |
):
|
| 85 |
+
reserva_urgente, reservas_desplazadas, created = cama_service.crear_reserva_urgente(db, data)
|
| 86 |
resp_reserva = ReservaQuirofanoResponse.model_validate(reserva_urgente)
|
| 87 |
|
| 88 |
+
resp_desplazadas = [
|
| 89 |
+
ReservaDesplazadaInfo(
|
| 90 |
+
reserva_id=r.id,
|
| 91 |
+
cama_id=r.cama_id,
|
| 92 |
+
turno_id=r.turno_id,
|
| 93 |
+
prioridad_original=r.prioridad,
|
| 94 |
+
notificado_a_m2=bool(r.turno_id),
|
|
|
|
| 95 |
)
|
| 96 |
+
for r in reservas_desplazadas
|
| 97 |
+
]
|
| 98 |
|
| 99 |
+
if not created:
|
| 100 |
+
msg = f"Reserva urgente ya existente para la solicitud {data.solicitud_urgencia_hce_id}"
|
| 101 |
+
elif resp_desplazadas:
|
| 102 |
+
ids = ", ".join(str(r.reserva_id) for r in resp_desplazadas)
|
| 103 |
+
msg = f"Reserva urgente creada. Se reprogramaron las reservas {ids}"
|
| 104 |
+
else:
|
| 105 |
+
msg = "Reserva urgente creada exitosamente"
|
| 106 |
|
| 107 |
content = CirugiaUrgenteResponse(
|
| 108 |
mensaje=msg,
|
| 109 |
reserva=resp_reserva,
|
| 110 |
+
reservas_desplazadas=resp_desplazadas,
|
| 111 |
).model_dump(mode="json")
|
| 112 |
|
| 113 |
+
status_code = status.HTTP_201_CREATED if created else status.HTTP_200_OK
|
| 114 |
+
return JSONResponse(content=content, status_code=status_code)
|
| 115 |
|
| 116 |
|
| 117 |
# ─── Desde M2 (Turnos) ─────────────────────────────────────────────────────
|
app/schemas/reserva.py
CHANGED
|
@@ -56,10 +56,20 @@ class CirugiaUrgenteWebhook(BaseModel):
|
|
| 56 |
paciente_id: int
|
| 57 |
medico_cirujano_id: int
|
| 58 |
medico_solicitante_id: int
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 59 |
fecha_hora_inicio: datetime
|
| 60 |
fecha_hora_fin_estimada: datetime
|
| 61 |
diagnostico: Optional[str] = None
|
| 62 |
hospital_id: Optional[str] = None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 63 |
timestamp: datetime
|
| 64 |
|
| 65 |
@model_validator(mode="after")
|
|
@@ -94,4 +104,6 @@ class ReservaDesplazadaInfo(BaseModel):
|
|
| 94 |
class CirugiaUrgenteResponse(BaseModel):
|
| 95 |
mensaje: str
|
| 96 |
reserva: ReservaQuirofanoResponse
|
| 97 |
-
|
|
|
|
|
|
|
|
|
| 56 |
paciente_id: int
|
| 57 |
medico_cirujano_id: int
|
| 58 |
medico_solicitante_id: int
|
| 59 |
+
# Algoritmo ASAP (ver cama_service.crear_reserva_urgente): M6 no reserva
|
| 60 |
+
# necesariamente esta ventana tal cual. `fecha_hora_inicio` se interpreta como
|
| 61 |
+
# "no antes de" y `fecha_hora_fin_estimada - fecha_hora_inicio` como la duración
|
| 62 |
+
# de la cirugía; M6 calcula el inicio real más temprano posible entre los
|
| 63 |
+
# quirófanos compatibles y puede ser posterior a `fecha_hora_inicio`.
|
| 64 |
fecha_hora_inicio: datetime
|
| 65 |
fecha_hora_fin_estimada: datetime
|
| 66 |
diagnostico: Optional[str] = None
|
| 67 |
hospital_id: Optional[str] = None
|
| 68 |
+
# Preferencia de especialidad del quirófano (ver algoritmo ASAP en
|
| 69 |
+
# cama_service.crear_reserva_urgente). No es obligatoria: si no viene o no hay
|
| 70 |
+
# quirófano de esa especialidad libre, se usa cualquier quirófano compatible
|
| 71 |
+
# del hospital antes que dejar al paciente sin asignar.
|
| 72 |
+
specialty_id: Optional[int] = None
|
| 73 |
timestamp: datetime
|
| 74 |
|
| 75 |
@model_validator(mode="after")
|
|
|
|
| 104 |
class CirugiaUrgenteResponse(BaseModel):
|
| 105 |
mensaje: str
|
| 106 |
reserva: ReservaQuirofanoResponse
|
| 107 |
+
# Con ventana ASAP y varios quirófanos, la reserva urgente puede caer en un hueco
|
| 108 |
+
# que solapa más de una reserva programada; todas las que se reprograman van acá.
|
| 109 |
+
reservas_desplazadas: list[ReservaDesplazadaInfo] = []
|
app/services/cama_service.py
CHANGED
|
@@ -2,7 +2,7 @@
|
|
| 2 |
Lógica de negocio para Camas y Reservas de Quirófano.
|
| 3 |
"""
|
| 4 |
from __future__ import annotations
|
| 5 |
-
from datetime import datetime, timezone
|
| 6 |
from fastapi import HTTPException
|
| 7 |
from supabase import Client
|
| 8 |
|
|
@@ -29,10 +29,6 @@ from app.schemas.enums import EntidadAuditoriaEnum, TipoEventoAuditoriaEnum, Ori
|
|
| 29 |
|
| 30 |
# ─── Constantes de dominio ─────────────────────────────────────────────────
|
| 31 |
|
| 32 |
-
_PRIORIDAD_ORDER = {
|
| 33 |
-
"MUY_BAJA": 0, "BAJA": 1, "MEDIA": 2, "ALTA": 3, "MUY_ALTA": 4, "URGENTE": 5
|
| 34 |
-
}
|
| 35 |
-
|
| 36 |
_ERR_CAMA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Cama no encontrada"}
|
| 37 |
_ERR_RESERVA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Reserva no encontrada"}
|
| 38 |
|
|
@@ -560,119 +556,170 @@ def get_disponibilidad_quirofanos(
|
|
| 560 |
return result
|
| 561 |
|
| 562 |
|
| 563 |
-
def
|
| 564 |
-
|
| 565 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 566 |
"""
|
| 567 |
-
|
| 568 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 569 |
"""
|
| 570 |
-
|
| 571 |
-
|
| 572 |
-
|
| 573 |
-
|
| 574 |
-
|
| 575 |
-
|
| 576 |
-
|
| 577 |
-
|
| 578 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 579 |
)
|
| 580 |
-
|
| 581 |
-
cama_libre = None
|
| 582 |
-
for q in quirofanos:
|
| 583 |
-
solapadas = reserva_crud.get_superpuestas(db, q.id, data.fecha_hora_inicio, data.fecha_hora_fin_estimada)
|
| 584 |
if not solapadas:
|
| 585 |
-
cama_libre = q
|
| 586 |
break
|
|
|
|
| 587 |
|
| 588 |
-
|
| 589 |
-
|
| 590 |
-
|
| 591 |
-
|
| 592 |
-
|
| 593 |
-
|
| 594 |
-
|
| 595 |
-
|
| 596 |
-
|
| 597 |
-
|
| 598 |
-
|
| 599 |
-
descripcion=f"Reserva urgente creada en quirófano {cama_libre.id}",
|
| 600 |
-
hospital_id=cama_libre.hospital_id,
|
| 601 |
)
|
| 602 |
-
return reserva, None
|
| 603 |
|
| 604 |
-
|
| 605 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 606 |
raise HTTPException(
|
| 607 |
status_code=409,
|
| 608 |
detail={
|
| 609 |
-
"codigo": "
|
| 610 |
-
"mensaje": "No hay quirófanos
|
| 611 |
},
|
| 612 |
)
|
| 613 |
|
| 614 |
-
|
| 615 |
|
| 616 |
-
|
| 617 |
-
|
| 618 |
-
|
| 619 |
-
|
| 620 |
-
nuevo_fin = nuevo_inicio + duracion
|
| 621 |
-
candidata.fecha_hora_inicio = nuevo_inicio
|
| 622 |
-
candidata.fecha_hora_fin_estimada = nuevo_fin
|
| 623 |
-
|
| 624 |
-
if candidata.turno_id:
|
| 625 |
-
turnos.reschedule_turno(
|
| 626 |
-
turno_id=candidata.turno_id,
|
| 627 |
-
starts_at=nuevo_inicio,
|
| 628 |
-
ends_at=nuevo_fin,
|
| 629 |
-
)
|
| 630 |
|
| 631 |
-
|
| 632 |
-
candidata.desplazada_por_reserva_id = reserva_urgente.id
|
| 633 |
-
reserva_crud.save(db, candidata)
|
| 634 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 635 |
auditoria_crud.registrar(
|
| 636 |
db,
|
| 637 |
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
|
| 638 |
entidad_id=reserva_urgente.id,
|
| 639 |
-
cama_id=
|
| 640 |
evento=TipoEventoAuditoriaEnum.RESERVA_URGENTE.value,
|
| 641 |
estado_nuevo=reserva_urgente.estado,
|
| 642 |
paciente_id=reserva_urgente.paciente_id,
|
| 643 |
origen=OrigenAuditoriaEnum.WEBHOOK.value,
|
| 644 |
-
descripcion=f"Reserva urgente creada en quirófano {
|
| 645 |
-
|
| 646 |
-
auditoria_crud.registrar(
|
| 647 |
-
db,
|
| 648 |
-
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
|
| 649 |
-
entidad_id=candidata.id,
|
| 650 |
-
cama_id=candidata_cama_id,
|
| 651 |
-
evento=TipoEventoAuditoriaEnum.RESERVA_DESPLAZADA.value,
|
| 652 |
-
estado_nuevo=candidata.estado,
|
| 653 |
-
paciente_id=candidata.paciente_id,
|
| 654 |
-
origen=OrigenAuditoriaEnum.WEBHOOK.value,
|
| 655 |
-
descripcion=f"Reserva {candidata.id} reprogramada por urgencia",
|
| 656 |
-
detalle={"desplazada_por_reserva_id": reserva_urgente.id, "turno_id": candidata.turno_id},
|
| 657 |
)
|
| 658 |
|
| 659 |
-
|
| 660 |
-
|
| 661 |
-
|
| 662 |
-
|
| 663 |
-
|
| 664 |
-
|
| 665 |
-
|
| 666 |
-
|
| 667 |
-
|
| 668 |
-
|
| 669 |
-
|
| 670 |
-
|
| 671 |
-
|
| 672 |
-
|
| 673 |
-
|
| 674 |
-
|
| 675 |
-
|
| 676 |
-
|
| 677 |
-
|
| 678 |
-
|
|
|
|
|
|
|
|
|
| 2 |
Lógica de negocio para Camas y Reservas de Quirófano.
|
| 3 |
"""
|
| 4 |
from __future__ import annotations
|
| 5 |
+
from datetime import datetime, timedelta, timezone
|
| 6 |
from fastapi import HTTPException
|
| 7 |
from supabase import Client
|
| 8 |
|
|
|
|
| 29 |
|
| 30 |
# ─── Constantes de dominio ─────────────────────────────────────────────────
|
| 31 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 32 |
_ERR_CAMA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Cama no encontrada"}
|
| 33 |
_ERR_RESERVA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Reserva no encontrada"}
|
| 34 |
|
|
|
|
| 556 |
return result
|
| 557 |
|
| 558 |
|
| 559 |
+
def _es_bloqueante(r: ReservaQuirofano) -> bool:
|
| 560 |
+
"""Una reserva EN_CURSO o URGENTE nunca se desplaza: define cuándo se libera
|
| 561 |
+
de verdad el quirófano (o directamente no compite, si también es urgente)."""
|
| 562 |
+
return r.estado == "EN_CURSO" or r.prioridad == "URGENTE"
|
| 563 |
+
|
| 564 |
+
|
| 565 |
+
def _earliest_start(
|
| 566 |
+
db: Client, cama_id: int, no_antes_de: datetime, duracion: timedelta
|
| 567 |
+
) -> tuple[datetime, list[ReservaQuirofano]]:
|
| 568 |
"""
|
| 569 |
+
Inicio más temprano factible para una cirugía de `duracion` en el quirófano
|
| 570 |
+
`cama_id`, no antes de `no_antes_de` ("ASAP"). Devuelve (inicio, desplazables):
|
| 571 |
+
`desplazables` son las reservas RESERVADA no-urgentes que quedan dentro de
|
| 572 |
+
`[inicio, inicio+duracion)` y que habría que reprogramar para asignar ahí.
|
| 573 |
+
|
| 574 |
+
Sweep: arranca en `no_antes_de` y, mientras el hueco elegido choque con una
|
| 575 |
+
reserva bloqueante (EN_CURSO o URGENTE — nunca se desplazan), lo empuja hasta
|
| 576 |
+
que esa bloqueante libera el quirófano. Como una reserva empujada puede topar
|
| 577 |
+
con la siguiente, se repite hasta que ninguna bloqueante solape más.
|
| 578 |
"""
|
| 579 |
+
futuras = reserva_crud.get_futuras(db, cama_id, no_antes_de)
|
| 580 |
+
inicio = no_antes_de
|
| 581 |
+
fin = inicio + duracion
|
| 582 |
+
changed = True
|
| 583 |
+
while changed:
|
| 584 |
+
changed = False
|
| 585 |
+
for r in futuras:
|
| 586 |
+
if _es_bloqueante(r) and r.fecha_hora_inicio < fin and r.fecha_hora_fin_estimada > inicio:
|
| 587 |
+
inicio = r.fecha_hora_fin_estimada
|
| 588 |
+
fin = inicio + duracion
|
| 589 |
+
changed = True
|
| 590 |
+
|
| 591 |
+
desplazables = [
|
| 592 |
+
r for r in futuras
|
| 593 |
+
if not _es_bloqueante(r) and r.fecha_hora_inicio < fin and r.fecha_hora_fin_estimada > inicio
|
| 594 |
+
]
|
| 595 |
+
return inicio, desplazables
|
| 596 |
+
|
| 597 |
+
|
| 598 |
+
def reprogramar(db: Client, reserva: ReservaQuirofano, no_antes_de: datetime, motivo: str) -> ReservaQuirofano:
|
| 599 |
+
"""
|
| 600 |
+
Reubica `reserva` en el próximo hueco libre (>= su duración original) a partir
|
| 601 |
+
de `no_antes_de`, en el mismo quirófano, y reprograma el turno en M2 si tiene uno.
|
| 602 |
+
|
| 603 |
+
Seam mínimo: garantiza que la reserva no quede duplicada de horario con otra,
|
| 604 |
+
pero no hace nada más inteligente que "empujarla" hasta el próximo hueco.
|
| 605 |
+
TODO (algoritmo `reprogramar()` completo, tarea siguiente): evaluar mover a otro
|
| 606 |
+
quirófano compatible si el hueco en este es demasiado tardío, y cascadear el
|
| 607 |
+
desplazamiento (si el hueco elegido choca con otra reserva de menor prioridad,
|
| 608 |
+
desplazar a esa en vez de simplemente seguir empujando `reserva`).
|
| 609 |
+
"""
|
| 610 |
+
duracion = reserva.fecha_hora_fin_estimada - reserva.fecha_hora_inicio
|
| 611 |
+
inicio = no_antes_de
|
| 612 |
+
while True:
|
| 613 |
+
solapadas = reserva_crud.get_superpuestas(
|
| 614 |
+
db, reserva.cama_id, inicio, inicio + duracion, exclude_id=reserva.id
|
| 615 |
)
|
|
|
|
|
|
|
|
|
|
|
|
|
| 616 |
if not solapadas:
|
|
|
|
| 617 |
break
|
| 618 |
+
inicio = max(r.fecha_hora_fin_estimada for r in solapadas)
|
| 619 |
|
| 620 |
+
reserva.fecha_hora_inicio = inicio
|
| 621 |
+
reserva.fecha_hora_fin_estimada = inicio + duracion
|
| 622 |
+
reserva.observaciones = (
|
| 623 |
+
f"{reserva.observaciones} | {motivo}" if reserva.observaciones else motivo
|
| 624 |
+
)
|
| 625 |
+
|
| 626 |
+
if reserva.turno_id:
|
| 627 |
+
turnos.reschedule_turno(
|
| 628 |
+
turno_id=reserva.turno_id,
|
| 629 |
+
starts_at=reserva.fecha_hora_inicio,
|
| 630 |
+
ends_at=reserva.fecha_hora_fin_estimada,
|
|
|
|
|
|
|
| 631 |
)
|
|
|
|
| 632 |
|
| 633 |
+
return reserva_crud.save(db, reserva)
|
| 634 |
+
|
| 635 |
+
|
| 636 |
+
def crear_reserva_urgente(
|
| 637 |
+
db: Client, data: CirugiaUrgenteWebhook
|
| 638 |
+
) -> tuple[ReservaQuirofano, list[ReservaQuirofano], bool]:
|
| 639 |
+
"""
|
| 640 |
+
Crea una reserva urgente (EMERGENCIA, prioridad URGENTE) lo antes posible.
|
| 641 |
+
|
| 642 |
+
Algoritmo ASAP: `data.fecha_hora_inicio` se interpreta como "no antes de" y
|
| 643 |
+
`data.fecha_hora_fin_estimada - data.fecha_hora_inicio` como la duración de la
|
| 644 |
+
cirugía. Para cada quirófano compatible (mismo hospital, operable) se calcula
|
| 645 |
+
el inicio más temprano factible (`_earliest_start`); se elige el mínimo global.
|
| 646 |
+
Si ese inicio coincide con "no antes de", el quirófano estaba libre. Si no,
|
| 647 |
+
las reservas programadas (no urgentes) que quedan en el medio se reprograman
|
| 648 |
+
(`reprogramar`), nunca se cancelan. Las reservas EN_CURSO o ya URGENTE jamás
|
| 649 |
+
se desplazan.
|
| 650 |
+
|
| 651 |
+
Retorna (reserva_urgente, reservas_desplazadas, created). `created=False` es
|
| 652 |
+
el caso idempotente (misma `solicitud_urgencia_hce_id` ya procesada).
|
| 653 |
+
"""
|
| 654 |
+
existing = reserva_crud.get_by_urgencia_hce_id(db, data.solicitud_urgencia_hce_id)
|
| 655 |
+
if existing:
|
| 656 |
+
return existing, [], False
|
| 657 |
+
|
| 658 |
+
duracion = data.fecha_hora_fin_estimada - data.fecha_hora_inicio
|
| 659 |
+
no_antes_de = data.fecha_hora_inicio
|
| 660 |
+
|
| 661 |
+
quirofanos = cama_crud.get_quirofanos(
|
| 662 |
+
db,
|
| 663 |
+
hospital_id=data.hospital_id,
|
| 664 |
+
exclude_estados=["FUERA_DE_SERVICIO", "BAJA_PERMANENTE", "EN_LIMPIEZA"],
|
| 665 |
+
)
|
| 666 |
+
if not quirofanos:
|
| 667 |
raise HTTPException(
|
| 668 |
status_code=409,
|
| 669 |
detail={
|
| 670 |
+
"codigo": "SIN_QUIROFANO_COMPATIBLE",
|
| 671 |
+
"mensaje": "No hay quirófanos operables para el hospital indicado",
|
| 672 |
},
|
| 673 |
)
|
| 674 |
|
| 675 |
+
candidatos = [(q, *_earliest_start(db, q.id, no_antes_de, duracion)) for q in quirofanos]
|
| 676 |
|
| 677 |
+
def _orden(candidato: tuple[Cama, datetime, list[ReservaQuirofano]]):
|
| 678 |
+
q, inicio, _ = candidato
|
| 679 |
+
specialty_match = 0 if (data.specialty_id is not None and q.specialty_id == data.specialty_id) else 1
|
| 680 |
+
return (inicio, specialty_match, q.id)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 681 |
|
| 682 |
+
quirofano, inicio_elegido, desplazables = min(candidatos, key=_orden)
|
|
|
|
|
|
|
| 683 |
|
| 684 |
+
data_ajustada = data.model_copy(
|
| 685 |
+
update={
|
| 686 |
+
"fecha_hora_inicio": inicio_elegido,
|
| 687 |
+
"fecha_hora_fin_estimada": inicio_elegido + duracion,
|
| 688 |
+
}
|
| 689 |
+
)
|
| 690 |
+
reserva_urgente = reserva_crud.create_urgente(db, quirofano.id, data_ajustada)
|
| 691 |
auditoria_crud.registrar(
|
| 692 |
db,
|
| 693 |
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
|
| 694 |
entidad_id=reserva_urgente.id,
|
| 695 |
+
cama_id=quirofano.id,
|
| 696 |
evento=TipoEventoAuditoriaEnum.RESERVA_URGENTE.value,
|
| 697 |
estado_nuevo=reserva_urgente.estado,
|
| 698 |
paciente_id=reserva_urgente.paciente_id,
|
| 699 |
origen=OrigenAuditoriaEnum.WEBHOOK.value,
|
| 700 |
+
descripcion=f"Reserva urgente creada en quirófano {quirofano.id}",
|
| 701 |
+
hospital_id=quirofano.hospital_id,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 702 |
)
|
| 703 |
|
| 704 |
+
reservas_desplazadas = []
|
| 705 |
+
for r in sorted(desplazables, key=lambda r: r.fecha_hora_inicio):
|
| 706 |
+
r.desplazada_por_reserva_id = reserva_urgente.id
|
| 707 |
+
r = reprogramar(
|
| 708 |
+
db, r, no_antes_de=reserva_urgente.fecha_hora_fin_estimada,
|
| 709 |
+
motivo=f"Reprogramada por cirugía urgente {reserva_urgente.id}",
|
| 710 |
+
)
|
| 711 |
+
reservas_desplazadas.append(r)
|
| 712 |
+
auditoria_crud.registrar(
|
| 713 |
+
db,
|
| 714 |
+
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
|
| 715 |
+
entidad_id=r.id,
|
| 716 |
+
cama_id=r.cama_id,
|
| 717 |
+
evento=TipoEventoAuditoriaEnum.RESERVA_DESPLAZADA.value,
|
| 718 |
+
estado_nuevo=r.estado,
|
| 719 |
+
paciente_id=r.paciente_id,
|
| 720 |
+
origen=OrigenAuditoriaEnum.WEBHOOK.value,
|
| 721 |
+
descripcion=f"Reserva {r.id} reprogramada por urgencia {reserva_urgente.id}",
|
| 722 |
+
detalle={"desplazada_por_reserva_id": reserva_urgente.id, "turno_id": r.turno_id},
|
| 723 |
+
)
|
| 724 |
+
|
| 725 |
+
return reserva_urgente, reservas_desplazadas, True
|
documentation/M6_DISEÑO.md
CHANGED
|
@@ -190,11 +190,14 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
|
|
| 190 |
|
| 191 |
`POST /quirofanos/{quirofanoId}/reservas` crea una reserva `PROGRAMADA` en estado `RESERVADA`. Disponibilidad consultable con `GET /quirofanos/disponibilidad?desde&hasta&specialty_id`. El estado se avanza con `PATCH /quirofanos/{quirofanoId}/reservas/{reservaId}` (`EN_CURSO`, `COMPLETADA`, `CANCELADA`).
|
| 192 |
|
| 193 |
-
### 5.5 Cirugía urgente con
|
| 194 |
|
| 195 |
-
1. M1 hace `POST /webhooks/hce/cirugia-urgente`.
|
| 196 |
-
2. M6
|
| 197 |
-
3.
|
|
|
|
|
|
|
|
|
|
| 198 |
|
| 199 |
### 5.6 Cancelación de turno quirúrgico desde M2
|
| 200 |
|
|
@@ -215,7 +218,7 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
|
|
| 215 |
- **Compatibilidad sector/tipo:** la cama asignada debe ser coherente con la necesidad clínica de la solicitud (criterio a definir y documentar; mínimamente, no asignar `QUIROFANO`/`CIRUGIA` a una internación común).
|
| 216 |
- **Resolución única:** una solicitud `APROBADA` o `RECHAZADA` no se puede volver a resolver → `409`.
|
| 217 |
- **Idempotencia de webhooks entrantes:** los webhooks de M1 y M9 traen ids de origen (`solicitud_hce_id`, etc.). M6 debe deduplicar por ese id para tolerar reintentos sin duplicar solicitudes ni movimientos.
|
| 218 |
-
- **Desplazamiento solo por urgencia:** una reserva `PROGRAMADA` solo se
|
| 219 |
|
| 220 |
---
|
| 221 |
|
|
@@ -394,3 +397,13 @@ Autenticación por JWT centralizada en Core (M10). Un middleware en FastAPI vali
|
|
| 394 |
16. **Reemplazo de WebSocket in-process por Supabase Realtime.** La primera versión de auditoría en tiempo real se implementó con un hub WebSocket in-process (`app/realtime.py`, endpoint `WS /auditoria/ws`). Se **eliminó** y se reemplazó por Supabase Realtime, consumido directo por el frontend sobre las tablas `camas` y `auditoria` (§9). Razón: el hub in-process solo funciona con un único proceso uvicorn; Supabase Realtime no tiene esa limitación y elimina código de pub/sub del backend. El backend ya no expone ningún endpoint WebSocket.
|
| 395 |
17. **Rol LIMPIEZA: alcance de lectura ampliado, escritura más restringida.** Antes, `GET /camas` filtraba para LIMPIEZA solo las camas en `EN_LIMPIEZA`. Ahora LIMPIEZA ve **todas** las camas (igual que MEDICO/ADMINISTRATIVO), pero la única escritura permitida es la transición `EN_LIMPIEZA → DISPONIBLE` vía `PATCH /camas/{camaId}`, enforced en `cama_service.update_cama` (no solo en el frontend). Se cerró además un loophole donde LIMPIEZA podía modificar `contraindicaciones_incompatibles` enviándolo sin acompañar un cambio de `estado`.
|
| 396 |
18. **Rol MEDICO: removido permiso de escritura indebido.** `POST /quirofanos/{quirofanoId}/reservas` (crear reserva de quirófano) aceptaba el rol `MEDICO`, pese a que MEDICO debe ser estrictamente de solo lectura sobre todo el dominio de M6. Corregido a solo `ADMINISTRATIVO`. Matriz completa de permisos por rol en `documentation/roles.md`.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 190 |
|
| 191 |
`POST /quirofanos/{quirofanoId}/reservas` crea una reserva `PROGRAMADA` en estado `RESERVADA`. Disponibilidad consultable con `GET /quirofanos/disponibilidad?desde&hasta&specialty_id`. El estado se avanza con `PATCH /quirofanos/{quirofanoId}/reservas/{reservaId}` (`EN_CURSO`, `COMPLETADA`, `CANCELADA`).
|
| 192 |
|
| 193 |
+
### 5.5 Cirugía urgente con priorización ASAP
|
| 194 |
|
| 195 |
+
1. M1 hace `POST /webhooks/hce/cirugia-urgente`. `fecha_hora_inicio` se interpreta como "no antes de" y `fecha_hora_fin_estimada - fecha_hora_inicio` como la duración de la cirugía — **no** una ventana fija: M6 decide el horario real.
|
| 196 |
+
2. M6 considera los quirófanos compatibles: mismo `hospital_id`, excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`/`EN_LIMPIEZA`. Para cada uno calcula el **inicio más temprano factible** (`earliest_start`): arranca en "no antes de" y lo empuja cada vez que choca con una reserva **bloqueante** (`EN_CURSO`, o `RESERVADA` con prioridad `URGENTE` — estas nunca se desplazan) hasta que ninguna bloqueante solapa más. Se elige el quirófano con menor `earliest_start`; empata por preferencia de `specialty_id` (si vino en el webhook) y luego por menor `id` de quirófano.
|
| 197 |
+
3. Si en el hueco elegido caían reservas `PROGRAMADA` (no urgentes), **se reprograman** — nunca se cancelan — vía el algoritmo `reprogramar()` (busca el próximo hueco libre para esa reserva y notifica el nuevo horario a M2 si tiene `turno_id`). Cada reserva desplazada guarda `desplazada_por_reserva_id` apuntando a la urgente que la corrió. Puede haber **más de una** reserva desplazada si varias caían dentro de la ventana.
|
| 198 |
+
4. La respuesta incluye la reserva urgente creada y, si hubo, la lista `reservas_desplazadas` (puede tener 0, 1 o más elementos). Si `solicitud_urgencia_hce_id` ya se había procesado, se devuelve `200` con la reserva existente (idempotencia) en vez de crear una nueva.
|
| 199 |
+
|
| 200 |
+
> El algoritmo `reprogramar()` de esta sección tiene una implementación mínima (evita solapar horarios, pero no cascadea desplazamientos ni cambia de quirófano si el hueco es demasiado tardío). Diseño completo: pendiente, tarea siguiente.
|
| 201 |
|
| 202 |
### 5.6 Cancelación de turno quirúrgico desde M2
|
| 203 |
|
|
|
|
| 218 |
- **Compatibilidad sector/tipo:** la cama asignada debe ser coherente con la necesidad clínica de la solicitud (criterio a definir y documentar; mínimamente, no asignar `QUIROFANO`/`CIRUGIA` a una internación común).
|
| 219 |
- **Resolución única:** una solicitud `APROBADA` o `RECHAZADA` no se puede volver a resolver → `409`.
|
| 220 |
- **Idempotencia de webhooks entrantes:** los webhooks de M1 y M9 traen ids de origen (`solicitud_hce_id`, etc.). M6 debe deduplicar por ese id para tolerar reintentos sin duplicar solicitudes ni movimientos.
|
| 221 |
+
- **Desplazamiento solo por urgencia:** una reserva `PROGRAMADA` solo se reprograma automáticamente por una `EMERGENCIA` (nunca por otra programada), y nunca se cancela por este motivo — ver §5.5. Reservas `EN_CURSO` o ya `URGENTE` nunca se desplazan.
|
| 222 |
|
| 223 |
---
|
| 224 |
|
|
|
|
| 397 |
16. **Reemplazo de WebSocket in-process por Supabase Realtime.** La primera versión de auditoría en tiempo real se implementó con un hub WebSocket in-process (`app/realtime.py`, endpoint `WS /auditoria/ws`). Se **eliminó** y se reemplazó por Supabase Realtime, consumido directo por el frontend sobre las tablas `camas` y `auditoria` (§9). Razón: el hub in-process solo funciona con un único proceso uvicorn; Supabase Realtime no tiene esa limitación y elimina código de pub/sub del backend. El backend ya no expone ningún endpoint WebSocket.
|
| 398 |
17. **Rol LIMPIEZA: alcance de lectura ampliado, escritura más restringida.** Antes, `GET /camas` filtraba para LIMPIEZA solo las camas en `EN_LIMPIEZA`. Ahora LIMPIEZA ve **todas** las camas (igual que MEDICO/ADMINISTRATIVO), pero la única escritura permitida es la transición `EN_LIMPIEZA → DISPONIBLE` vía `PATCH /camas/{camaId}`, enforced en `cama_service.update_cama` (no solo en el frontend). Se cerró además un loophole donde LIMPIEZA podía modificar `contraindicaciones_incompatibles` enviándolo sin acompañar un cambio de `estado`.
|
| 399 |
18. **Rol MEDICO: removido permiso de escritura indebido.** `POST /quirofanos/{quirofanoId}/reservas` (crear reserva de quirófano) aceptaba el rol `MEDICO`, pese a que MEDICO debe ser estrictamente de solo lectura sobre todo el dominio de M6. Corregido a solo `ADMINISTRATIVO`. Matriz completa de permisos por rol en `documentation/roles.md`.
|
| 400 |
+
|
| 401 |
+
### 14.4 Cirugía urgente: algoritmo de priorización ASAP (2026-06)
|
| 402 |
+
|
| 403 |
+
19. **Reescritura del algoritmo de §5.5.** La implementación original asumía una ventana horaria fija enviada por M1 y solo verificaba si estaba libre; si no, desplazaba (reprogramando) la única reserva superpuesta de menor prioridad, sin distinguir reservas `EN_CURSO` (que ya está ocurriendo, no se puede tocar) de `RESERVADA`, sin filtrar por `hospital_id`/estado operable del quirófano, y sin soportar más de una reserva desplazada. Se reemplazó por un algoritmo ASAP: `fecha_hora_inicio` del webhook pasa a interpretarse como "no antes de" y la duración se deriva de `fecha_hora_fin_estimada - fecha_hora_inicio`; M6 calcula el inicio más temprano factible entre los quirófanos compatibles (`_earliest_start`, `app/services/cama_service.py`) y puede desplazar **varias** reservas `PROGRAMADA` si caen dentro de la ventana elegida. Las reservas `EN_CURSO` o ya `URGENTE` son bloqueantes y nunca se desplazan.
|
| 404 |
+
20. **Contrato de respuesta cambiado.** `CirugiaUrgenteResponse.reserva_desplazada` (objeto u `null`) se reemplazó por `reservas_desplazadas` (array, puede tener 0, 1 o más elementos). Actualizar `M6_openapi.json` y cualquier cliente que integre contra este webhook.
|
| 405 |
+
21. **`CirugiaUrgenteWebhook.specialty_id` agregado** (opcional): preferencia de especialidad del quirófano a asignar; si no viene o no hay quirófano libre de esa especialidad, se usa cualquier quirófano compatible del hospital (la urgencia nunca queda sin asignar por esto).
|
| 406 |
+
22. **Idempotencia devuelve `200`, no `201`.** Antes el webhook respondía siempre `201`, incluso cuando `solicitud_urgencia_hce_id` ya existía (reintento de M1). Corregido: `200` para el caso idempotente, `201` solo cuando se crea una reserva nueva.
|
| 407 |
+
23. **Filtro de quirófanos por hospital y por estado operable.** El algoritmo original no filtraba por `hospital_id` (podía asignar una urgencia a un quirófano de otra sede) ni excluía quirófanos `EN_LIMPIEZA` (además de los ya excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`). Corregido en `crear_reserva_urgente`.
|
| 408 |
+
24. **Bug de persistencia corregido.** `reserva_crud.save` solo persistía `estado`/`observaciones`/`desplazada_por_reserva_id`; el nuevo horario de una reserva reprogramada nunca se guardaba en la tabla `reservas_quirofano` de M6 (solo se notificaba a M2). Ahora `save` también persiste `fecha_hora_inicio`/`fecha_hora_fin_estimada`.
|
| 409 |
+
25. **Seam `reprogramar()`.** Se introdujo `cama_service.reprogramar(db, reserva, no_antes_de, motivo)` como interfaz estable que consume el algoritmo de urgencia para reubicar una reserva desplazada. La implementación actual es mínima (evita solapar horarios en el mismo quirófano) — el diseño completo (cascada, cambio de quirófano) queda pendiente como tarea siguiente.
|
documentation/M6_demo_payloads.md
CHANGED
|
@@ -117,9 +117,13 @@ Para `TRASLADO` se usan `cama_origen_id` y `cama_destino_solicitada_id`; el rest
|
|
| 117 |
## 2. [M1] Recibir solicitud de cirugía urgente
|
| 118 |
|
| 119 |
`POST /webhooks/hce/cirugia-urgente` · emisor: **M1 HCE**.
|
| 120 |
-
|
| 121 |
-
|
| 122 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 123 |
|
| 124 |
```bash
|
| 125 |
curl -X POST "https://modulo-6-api.hf.space/api/v1/webhooks/hce/cirugia-urgente" \
|
|
@@ -141,7 +145,9 @@ curl -X POST "https://modulo-6-api.hf.space/api/v1/webhooks/hce/cirugia-urgente"
|
|
| 141 |
**Campos.** Requeridos: `solicitud_urgencia_hce_id`, `paciente_id`, `medico_cirujano_id`,
|
| 142 |
`medico_solicitante_id`, `fecha_hora_inicio`, `fecha_hora_fin_estimada`, `timestamp`.
|
| 143 |
`fecha_hora_inicio` debe ser anterior a `fecha_hora_fin_estimada` (si no → `422`).
|
| 144 |
-
Opcionales: `diagnostico`, `hospital_id`
|
|
|
|
|
|
|
| 145 |
|
| 146 |
**Respuesta 201 (sin desplazamiento):**
|
| 147 |
|
|
@@ -156,12 +162,21 @@ Opcionales: `diagnostico`, `hospital_id`.
|
|
| 156 |
"prioridad": "URGENTE",
|
| 157 |
"paciente_id": 33
|
| 158 |
},
|
| 159 |
-
"
|
| 160 |
}
|
| 161 |
```
|
| 162 |
|
| 163 |
-
**Respuesta 201 (con desplazamiento):** `
|
| 164 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 165 |
|
| 166 |
---
|
| 167 |
|
|
|
|
| 117 |
## 2. [M1] Recibir solicitud de cirugía urgente
|
| 118 |
|
| 119 |
`POST /webhooks/hce/cirugia-urgente` · emisor: **M1 HCE**.
|
| 120 |
+
Algoritmo **ASAP**: `fecha_hora_inicio` se interpreta como "no antes de" y la resta con
|
| 121 |
+
`fecha_hora_fin_estimada` como la duración de la cirugía. M6 calcula, entre los quirófanos
|
| 122 |
+
compatibles (mismo hospital, operables), el inicio más temprano posible y asigna ahí —
|
| 123 |
+
el horario final puede no coincidir con el pedido. Si para lograrlo hay que correr alguna
|
| 124 |
+
reserva programada, esa reserva **no se cancela**: se **reprograma** en M2 (algoritmo
|
| 125 |
+
`reprogramar()`) preservando su duración. Reservas `EN_CURSO` o ya `URGENTE` nunca se
|
| 126 |
+
desplazan; pueden ser varias las reservas desplazadas dentro de la ventana elegida.
|
| 127 |
|
| 128 |
```bash
|
| 129 |
curl -X POST "https://modulo-6-api.hf.space/api/v1/webhooks/hce/cirugia-urgente" \
|
|
|
|
| 145 |
**Campos.** Requeridos: `solicitud_urgencia_hce_id`, `paciente_id`, `medico_cirujano_id`,
|
| 146 |
`medico_solicitante_id`, `fecha_hora_inicio`, `fecha_hora_fin_estimada`, `timestamp`.
|
| 147 |
`fecha_hora_inicio` debe ser anterior a `fecha_hora_fin_estimada` (si no → `422`).
|
| 148 |
+
Opcionales: `diagnostico`, `hospital_id`, `specialty_id` (preferencia de especialidad del
|
| 149 |
+
quirófano; si no hay quirófano libre de esa especialidad se usa cualquier otro compatible
|
| 150 |
+
del hospital, no se deja al paciente sin asignar).
|
| 151 |
|
| 152 |
**Respuesta 201 (sin desplazamiento):**
|
| 153 |
|
|
|
|
| 162 |
"prioridad": "URGENTE",
|
| 163 |
"paciente_id": 33
|
| 164 |
},
|
| 165 |
+
"reservas_desplazadas": []
|
| 166 |
}
|
| 167 |
```
|
| 168 |
|
| 169 |
+
**Respuesta 201 (con desplazamiento):** `reservas_desplazadas` trae la(s) reserva(s)
|
| 170 |
+
programada(s) que fueron reprogramadas (siguen `RESERVADA`, con nuevo horario; `turno_id`
|
| 171 |
+
reprogramado en M2 si correspondía). Puede haber más de una si varias caían dentro de la
|
| 172 |
+
ventana elegida.
|
| 173 |
+
|
| 174 |
+
**Respuesta 200:** si `solicitud_urgencia_hce_id` ya se había procesado (idempotencia),
|
| 175 |
+
se devuelve la reserva existente sin crear nada nuevo, con `200` en vez de `201`.
|
| 176 |
+
|
| 177 |
+
**Respuesta 409** `SIN_QUIROFANO_COMPATIBLE`: no hay ningún quirófano operable
|
| 178 |
+
(`FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`/`EN_LIMPIEZA` excluidos) para el `hospital_id`
|
| 179 |
+
indicado.
|
| 180 |
|
| 181 |
---
|
| 182 |
|
documentation/M6_openapi.json
CHANGED
|
@@ -2381,7 +2381,7 @@
|
|
| 2381 |
"post": {
|
| 2382 |
"summary": "[M1] Recibir solicitud de cirugía urgente",
|
| 2383 |
"deprecated": false,
|
| 2384 |
-
"description": "El Módulo 1 (HCE) llama a este endpoint cuando un médico decide que un paciente necesita una cirugía de emergencia y requiere quirófano
|
| 2385 |
"operationId": "recibirCirugiaUrgente",
|
| 2386 |
"tags": [
|
| 2387 |
"Quirófanos"
|
|
@@ -2447,13 +2447,13 @@
|
|
| 2447 |
"desplazada_por_reserva_id": null,
|
| 2448 |
"created_at": "2025-01-18T13:46:00Z"
|
| 2449 |
},
|
| 2450 |
-
"
|
| 2451 |
}
|
| 2452 |
},
|
| 2453 |
"con_desplazamiento": {
|
| 2454 |
-
"summary": "Se
|
| 2455 |
"value": {
|
| 2456 |
-
"mensaje": "Reserva urgente creada. Se
|
| 2457 |
"reserva": {
|
| 2458 |
"id": 23,
|
| 2459 |
"cama_id": 501,
|
|
@@ -2465,17 +2465,19 @@
|
|
| 2465 |
"medico_cirujano_id": 45,
|
| 2466 |
"fecha_hora_inicio": "2025-01-18T14:00:00Z",
|
| 2467 |
"fecha_hora_fin_estimada": "2025-01-18T16:00:00Z",
|
| 2468 |
-
"observaciones": "Cirugía urgente solicitada por HCE (HCE-URG-00045)
|
| 2469 |
"desplazada_por_reserva_id": null,
|
| 2470 |
"created_at": "2025-01-18T13:46:00Z"
|
| 2471 |
},
|
| 2472 |
-
"
|
| 2473 |
-
|
| 2474 |
-
|
| 2475 |
-
|
| 2476 |
-
|
| 2477 |
-
|
| 2478 |
-
|
|
|
|
|
|
|
| 2479 |
}
|
| 2480 |
}
|
| 2481 |
}
|
|
@@ -2537,11 +2539,11 @@
|
|
| 2537 |
},
|
| 2538 |
"examples": {
|
| 2539 |
"sin_quirofanos": {
|
| 2540 |
-
"summary": "No hay quirófanos
|
| 2541 |
"value": {
|
| 2542 |
-
"codigo": "
|
| 2543 |
-
"mensaje": "No hay quirófanos
|
| 2544 |
-
"detalle": "
|
| 2545 |
}
|
| 2546 |
}
|
| 2547 |
}
|
|
@@ -5870,7 +5872,7 @@
|
|
| 5870 |
},
|
| 5871 |
"CirugiaUrgenteWebhook": {
|
| 5872 |
"type": "object",
|
| 5873 |
-
"description": "Payload que envía HCE (M1) para solicitar un quirófano de forma urgente.
|
| 5874 |
"required": [
|
| 5875 |
"solicitud_urgencia_hce_id",
|
| 5876 |
"paciente_id",
|
|
@@ -5904,11 +5906,13 @@
|
|
| 5904 |
"fecha_hora_inicio": {
|
| 5905 |
"type": "string",
|
| 5906 |
"format": "date-time",
|
|
|
|
| 5907 |
"example": "2025-01-18T14:00:00Z"
|
| 5908 |
},
|
| 5909 |
"fecha_hora_fin_estimada": {
|
| 5910 |
"type": "string",
|
| 5911 |
"format": "date-time",
|
|
|
|
| 5912 |
"example": "2025-01-18T16:00:00Z"
|
| 5913 |
},
|
| 5914 |
"diagnostico": {
|
|
@@ -5921,6 +5925,12 @@
|
|
| 5921 |
"nullable": true,
|
| 5922 |
"example": "HOSP-001"
|
| 5923 |
},
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 5924 |
"observaciones": {
|
| 5925 |
"type": "string",
|
| 5926 |
"nullable": true
|
|
@@ -5935,10 +5945,11 @@
|
|
| 5935 |
},
|
| 5936 |
"CirugiaUrgenteResponse": {
|
| 5937 |
"type": "object",
|
| 5938 |
-
"description": "Respuesta al webhook de cirugía urgente. Informa
|
| 5939 |
"required": [
|
| 5940 |
"mensaje",
|
| 5941 |
-
"reserva"
|
|
|
|
| 5942 |
],
|
| 5943 |
"properties": {
|
| 5944 |
"mensaje": {
|
|
@@ -5948,34 +5959,36 @@
|
|
| 5948 |
"reserva": {
|
| 5949 |
"$ref": "#/components/schemas/ReservaQuirofanoResponse"
|
| 5950 |
},
|
| 5951 |
-
"
|
| 5952 |
-
"type": "
|
| 5953 |
-
"description": "
|
| 5954 |
-
"
|
| 5955 |
-
"
|
| 5956 |
-
|
| 5957 |
-
"
|
| 5958 |
-
|
| 5959 |
-
|
| 5960 |
-
|
| 5961 |
-
"
|
| 5962 |
-
|
| 5963 |
-
|
| 5964 |
-
|
| 5965 |
-
"
|
| 5966 |
-
|
| 5967 |
-
|
| 5968 |
-
|
| 5969 |
-
|
| 5970 |
-
|
| 5971 |
-
|
| 5972 |
-
|
| 5973 |
-
|
| 5974 |
-
"
|
| 5975 |
-
|
|
|
|
|
|
|
|
|
|
| 5976 |
}
|
| 5977 |
-
}
|
| 5978 |
-
"nullable": true
|
| 5979 |
}
|
| 5980 |
}
|
| 5981 |
},
|
|
|
|
| 2381 |
"post": {
|
| 2382 |
"summary": "[M1] Recibir solicitud de cirugía urgente",
|
| 2383 |
"deprecated": false,
|
| 2384 |
+
"description": "El Módulo 1 (HCE) llama a este endpoint cuando un médico decide que un paciente necesita una cirugía de emergencia y requiere quirófano lo antes posible.\n\n## Diferencia con el flujo de reserva programada\n\nEste endpoint es uno de los dos mecanismos automáticos por los que entran reservas a M6. Se diferencia del flujo de reserva programada (`POST /camas/{quirofanoId}/reservas`, invocado por M1) en cuatro aspectos:\n\n| Aspecto | Este webhook | `POST /camas/{quirofanoId}/reservas` |\n|---------|--------------|----------------------------------|\n| Origen | M1 (HCE) vía webhook urgente | M1 (HCE) vía cirugía programada |\n| Cama destino | M6 la elige automáticamente | La fija M1 en el path |\n| Horario | M6 lo calcula (ASAP) | Lo fija M1 |\n| Prioridad | Siempre `URGENTE` | Cualquiera excepto `URGENTE` |\n| Desplazamiento de otras reservas | Sí, automático (reprograma, no cancela) | No |\n| Quién lo invoca | M1 (HCE) exclusivamente | M2 (Turnos) exclusivamente |\n\nEn otras palabras: **este webhook es el único camino por el que una reserva URGENTE puede entrar al sistema**, y es el único flujo que puede reprogramar automáticamente a otras reservas ya confirmadas.\n\n## Algoritmo ASAP (\"lo antes posible\")\n\n`fecha_hora_inicio` se interpreta como \"no antes de\" y `fecha_hora_fin_estimada - fecha_hora_inicio` como la duración de la cirugía — **no** es una ventana fija: M6 decide el horario real.\n\n1. Se consideran los quirófanos compatibles: mismo `hospital_id` (si se envió), excluidos los que están `FUERA_DE_SERVICIO`, `BAJA_PERMANENTE` o `EN_LIMPIEZA`. Si no queda ninguno, responde `409 SIN_QUIROFANO_COMPATIBLE`.\n\n2. Para cada quirófano candidato se calcula el **inicio más temprano factible**: arranca en \"no antes de\" y se empuja cada vez que choca con una reserva **bloqueante** — `EN_CURSO` (ya está pasando, no se puede tocar) o `RESERVADA` con prioridad `URGENTE` (nunca se desplaza entre urgencias) — hasta que ninguna bloqueante solapa más.\n\n3. Se elige el quirófano con menor inicio factible. Empate: preferencia por `specialty_id` si se envió, luego menor `id` de quirófano.\n\n4. Si en la ventana elegida caían reservas `PROGRAMADA` (no urgentes, no bloqueantes), se **reprograman** (nunca se cancelan): cada una se reubica en el próximo hueco libre y, si tiene `turno_id`, se notifica el nuevo horario a M2 vía `PATCH /appointments/{turno_id}/reschedule`. Puede haber más de una reserva reprogramada si varias caían dentro de la ventana.\n\n5. Se crea la reserva urgente (`origen=EMERGENCIA`, `prioridad=URGENTE`, `estado=RESERVADA`) con el horario finalmente calculado. Responde `201`.\n\n## Idempotencia\n\nEl payload debe incluir `solicitud_urgencia_hce_id`. Si ya existe una reserva URGENTE creada con ese mismo `solicitud_urgencia_hce_id`, el endpoint responde `200` con la reserva ya existente en vez de crear una nueva. Esto protege frente a reintentos de M1.\n",
|
| 2385 |
"operationId": "recibirCirugiaUrgente",
|
| 2386 |
"tags": [
|
| 2387 |
"Quirófanos"
|
|
|
|
| 2447 |
"desplazada_por_reserva_id": null,
|
| 2448 |
"created_at": "2025-01-18T13:46:00Z"
|
| 2449 |
},
|
| 2450 |
+
"reservas_desplazadas": []
|
| 2451 |
}
|
| 2452 |
},
|
| 2453 |
"con_desplazamiento": {
|
| 2454 |
+
"summary": "Se reprogramó una reserva programada para liberar el quirófano",
|
| 2455 |
"value": {
|
| 2456 |
+
"mensaje": "Reserva urgente creada. Se reprogramaron las reservas 15",
|
| 2457 |
"reserva": {
|
| 2458 |
"id": 23,
|
| 2459 |
"cama_id": 501,
|
|
|
|
| 2465 |
"medico_cirujano_id": 45,
|
| 2466 |
"fecha_hora_inicio": "2025-01-18T14:00:00Z",
|
| 2467 |
"fecha_hora_fin_estimada": "2025-01-18T16:00:00Z",
|
| 2468 |
+
"observaciones": "Cirugía urgente solicitada por HCE (HCE-URG-00045)",
|
| 2469 |
"desplazada_por_reserva_id": null,
|
| 2470 |
"created_at": "2025-01-18T13:46:00Z"
|
| 2471 |
},
|
| 2472 |
+
"reservas_desplazadas": [
|
| 2473 |
+
{
|
| 2474 |
+
"reserva_id": 15,
|
| 2475 |
+
"cama_id": 501,
|
| 2476 |
+
"turno_id": 89,
|
| 2477 |
+
"prioridad_original": "BAJA",
|
| 2478 |
+
"notificado_a_m2": true
|
| 2479 |
+
}
|
| 2480 |
+
]
|
| 2481 |
}
|
| 2482 |
}
|
| 2483 |
}
|
|
|
|
| 2539 |
},
|
| 2540 |
"examples": {
|
| 2541 |
"sin_quirofanos": {
|
| 2542 |
+
"summary": "No hay quirófanos compatibles/operables",
|
| 2543 |
"value": {
|
| 2544 |
+
"codigo": "SIN_QUIROFANO_COMPATIBLE",
|
| 2545 |
+
"mensaje": "No hay quirófanos operables para el hospital indicado",
|
| 2546 |
+
"detalle": "No existe ningún quirófano del hospital solicitado que no esté FUERA_DE_SERVICIO, BAJA_PERMANENTE o EN_LIMPIEZA. M1 debe derivar a otro hospital."
|
| 2547 |
}
|
| 2548 |
}
|
| 2549 |
}
|
|
|
|
| 5872 |
},
|
| 5873 |
"CirugiaUrgenteWebhook": {
|
| 5874 |
"type": "object",
|
| 5875 |
+
"description": "Payload que envía HCE (M1) para solicitar un quirófano de forma urgente. No se especifica cama destino: M6 decide qué quirófano utilizar. `fecha_hora_inicio` se interpreta como \"no antes de\" y `fecha_hora_fin_estimada - fecha_hora_inicio` como la duración de la cirugía (algoritmo ASAP): M6 calcula el inicio real más temprano posible y reprograma las reservas programadas que haga falta.\n",
|
| 5876 |
"required": [
|
| 5877 |
"solicitud_urgencia_hce_id",
|
| 5878 |
"paciente_id",
|
|
|
|
| 5906 |
"fecha_hora_inicio": {
|
| 5907 |
"type": "string",
|
| 5908 |
"format": "date-time",
|
| 5909 |
+
"description": "Interpretado como \"no antes de\": M6 puede asignar un inicio posterior si no hay quirófano libre en ese momento.\n",
|
| 5910 |
"example": "2025-01-18T14:00:00Z"
|
| 5911 |
},
|
| 5912 |
"fecha_hora_fin_estimada": {
|
| 5913 |
"type": "string",
|
| 5914 |
"format": "date-time",
|
| 5915 |
+
"description": "Junto con `fecha_hora_inicio` define la duración estimada de la cirugía (`fecha_hora_fin_estimada - fecha_hora_inicio`); el horario final que asigna M6 preserva esa duración pero puede empezar más tarde.\n",
|
| 5916 |
"example": "2025-01-18T16:00:00Z"
|
| 5917 |
},
|
| 5918 |
"diagnostico": {
|
|
|
|
| 5925 |
"nullable": true,
|
| 5926 |
"example": "HOSP-001"
|
| 5927 |
},
|
| 5928 |
+
"specialty_id": {
|
| 5929 |
+
"type": "integer",
|
| 5930 |
+
"description": "Preferencia de especialidad del quirófano a asignar. No es obligatoria ni excluyente: si no viene, o no hay quirófano libre de esa especialidad a tiempo, M6 usa cualquier quirófano compatible del hospital antes que dejar la urgencia sin asignar.\n",
|
| 5931 |
+
"nullable": true,
|
| 5932 |
+
"example": 43
|
| 5933 |
+
},
|
| 5934 |
"observaciones": {
|
| 5935 |
"type": "string",
|
| 5936 |
"nullable": true
|
|
|
|
| 5945 |
},
|
| 5946 |
"CirugiaUrgenteResponse": {
|
| 5947 |
"type": "object",
|
| 5948 |
+
"description": "Respuesta al webhook de cirugía urgente. Informa la reserva urgente creada (o ya existente, si fue un reintento idempotente) y qué reservas programadas, si alguna, se tuvieron que reprogramar para ubicarla.\n",
|
| 5949 |
"required": [
|
| 5950 |
"mensaje",
|
| 5951 |
+
"reserva",
|
| 5952 |
+
"reservas_desplazadas"
|
| 5953 |
],
|
| 5954 |
"properties": {
|
| 5955 |
"mensaje": {
|
|
|
|
| 5959 |
"reserva": {
|
| 5960 |
"$ref": "#/components/schemas/ReservaQuirofanoResponse"
|
| 5961 |
},
|
| 5962 |
+
"reservas_desplazadas": {
|
| 5963 |
+
"type": "array",
|
| 5964 |
+
"description": "Reservas PROGRAMADA que se reprogramaron (nunca canceladas) para ubicar la cirugía urgente. Vacío si había quirófano libre en el horario pedido. Con el algoritmo ASAP puede haber más de un elemento si varias reservas caían dentro de la ventana finalmente elegida.\n",
|
| 5965 |
+
"items": {
|
| 5966 |
+
"type": "object",
|
| 5967 |
+
"properties": {
|
| 5968 |
+
"reserva_id": {
|
| 5969 |
+
"type": "integer",
|
| 5970 |
+
"example": 15
|
| 5971 |
+
},
|
| 5972 |
+
"cama_id": {
|
| 5973 |
+
"type": "integer",
|
| 5974 |
+
"example": 501
|
| 5975 |
+
},
|
| 5976 |
+
"turno_id": {
|
| 5977 |
+
"type": "integer",
|
| 5978 |
+
"description": "Si la reserva desplazada tenía turno asociado en M2, aparece acá (es el appointment_id de M2). Indica que se disparó la notificación a M2.",
|
| 5979 |
+
"nullable": true,
|
| 5980 |
+
"example": 89
|
| 5981 |
+
},
|
| 5982 |
+
"prioridad_original": {
|
| 5983 |
+
"$ref": "#/components/schemas/PrioridadQuirofanoEnum"
|
| 5984 |
+
},
|
| 5985 |
+
"notificado_a_m2": {
|
| 5986 |
+
"type": "boolean",
|
| 5987 |
+
"description": "`true` si la reserva desplazada tenía turno y se pudo notificar a M2. `false` si no tenía turno o si la notificación falló (igual así la reserva urgente se creó).\n",
|
| 5988 |
+
"example": true
|
| 5989 |
+
}
|
| 5990 |
}
|
| 5991 |
+
}
|
|
|
|
| 5992 |
}
|
| 5993 |
}
|
| 5994 |
},
|
documentation/algoritmo_urgencias.md
ADDED
|
@@ -0,0 +1,173 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Algoritmo de priorización de cirugías urgentes
|
| 2 |
+
|
| 3 |
+
**Módulo 6 · Quirófanos**
|
| 4 |
+
|
| 5 |
+
> Este documento detalla la implementación del algoritmo que resuelve `POST /webhooks/hce/cirugia-urgente`. Es un desarrollo de `M6_DISEÑO.md` §5.5 (que manda como resumen de negocio) y del changelog §14.4 (que resume qué cambió respecto de la versión anterior). Ante cualquier diferencia entre este documento y el código, manda el código — actualizar este archivo si el algoritmo cambia.
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. El problema que resuelve
|
| 10 |
+
|
| 11 |
+
M1 (HCE) avisa que un médico necesita quirófano **lo antes posible** para una cirugía urgente. Una urgencia tiene prioridad sobre cualquier cirugía que no sea también urgente. El sistema tiene que:
|
| 12 |
+
|
| 13 |
+
1. Conseguir un quirófano ya, si hay alguno libre.
|
| 14 |
+
2. Si no hay ninguno libre, encontrar el quirófano que se va a liberar antes y ocupar ese hueco.
|
| 15 |
+
3. Si el próximo turno de ese quirófano tiene una cirugía programada de menor prioridad, reprogramarla (nunca cancelarla) para hacerle lugar a la urgencia.
|
| 16 |
+
4. Si ese hueco también está ocupado por otra urgencia, no tocarla y evaluar el siguiente quirófano candidato, hasta encontrar el mejor lugar posible.
|
| 17 |
+
|
| 18 |
+
## 2. Modelo horario: ASAP, no ventana fija
|
| 19 |
+
|
| 20 |
+
El payload del webhook (`CirugiaUrgenteWebhook`, `app/schemas/reserva.py`) trae `fecha_hora_inicio` y `fecha_hora_fin_estimada`, pero **no se usan como una ventana que haya que respetar tal cual**. Se reinterpretan así:
|
| 21 |
+
|
| 22 |
+
- `no_antes_de = fecha_hora_inicio` — el horario más temprano en el que la cirugía podría arrancar, según M1.
|
| 23 |
+
- `duracion = fecha_hora_fin_estimada - fecha_hora_inicio` — cuánto va a durar la cirugía.
|
| 24 |
+
|
| 25 |
+
M6 **calcula su propio inicio** (`inicio_elegido`), que puede coincidir con `no_antes_de` (si había quirófano libre) o ser posterior (si hubo que esperar o desplazar). La reserva urgente que se crea usa siempre `inicio_elegido` y `inicio_elegido + duracion`, nunca los valores crudos del webhook.
|
| 26 |
+
|
| 27 |
+
Esto es deliberado: con una ventana fija no existe el concepto de "el quirófano que se libera antes", porque un quirófano está libre en esa ventana exacta o no lo está. El "próximo en liberarse" solo tiene sentido si M6 puede correr el inicio hacia adelante.
|
| 28 |
+
|
| 29 |
+
Campo opcional adicional: `specialty_id` — preferencia de especialidad del quirófano. No es excluyente: si no hay quirófano libre de esa especialidad a tiempo, se usa cualquier otro compatible del hospital antes que dejar la urgencia sin asignar (ver §4).
|
| 30 |
+
|
| 31 |
+
## 3. Piezas del algoritmo
|
| 32 |
+
|
| 33 |
+
Todo vive en `app/services/cama_service.py`.
|
| 34 |
+
|
| 35 |
+
### 3.1 `_es_bloqueante(r)` (línea ~559)
|
| 36 |
+
|
| 37 |
+
```python
|
| 38 |
+
def _es_bloqueante(r: ReservaQuirofano) -> bool:
|
| 39 |
+
return r.estado == "EN_CURSO" or r.prioridad == "URGENTE"
|
| 40 |
+
```
|
| 41 |
+
|
| 42 |
+
Una reserva es **bloqueante** si:
|
| 43 |
+
- está `EN_CURSO` (la cirugía ya está pasando — no se puede tocar bajo ningún concepto), o
|
| 44 |
+
- es `RESERVADA` con `prioridad == "URGENTE"` (otra urgencia ya confirmada — nunca se desplaza por una urgencia nueva).
|
| 45 |
+
|
| 46 |
+
Las bloqueantes **nunca se reprograman**. Definen cuándo un quirófano se libera de verdad.
|
| 47 |
+
|
| 48 |
+
### 3.2 `_earliest_start(db, cama_id, no_antes_de, duracion)` (línea ~565)
|
| 49 |
+
|
| 50 |
+
Calcula, para un quirófano puntual, el inicio más temprano factible ("cuándo se libera este quirófano para esta cirugía").
|
| 51 |
+
|
| 52 |
+
Algoritmo (sweep):
|
| 53 |
+
|
| 54 |
+
1. Trae las reservas futuras del quirófano con `reserva_crud.get_futuras(db, cama_id, no_antes_de)`: todas las `RESERVADA`/`EN_CURSO` cuyo fin es posterior a `no_antes_de`, ordenadas por inicio.
|
| 55 |
+
2. Arranca con `inicio = no_antes_de`, `fin = inicio + duracion`.
|
| 56 |
+
3. Mientras exista alguna reserva **bloqueante** que solape `[inicio, fin)` (`r.fecha_hora_inicio < fin and r.fecha_hora_fin_estimada > inicio`), empuja `inicio = r.fecha_hora_fin_estimada` (y recalcula `fin`). Como una reserva empujada puede toparse con otra bloqueante más adelante, el loop se repite hasta que ninguna bloqueante solapa más.
|
| 57 |
+
4. Una vez estabilizado `inicio`, junta las **desplazables**: reservas `RESERVADA` **no urgentes** que caen dentro de `[inicio, fin)`. Pueden ser **cero, una o varias**.
|
| 58 |
+
|
| 59 |
+
Devuelve `(inicio, desplazables)`.
|
| 60 |
+
|
| 61 |
+
**Por qué es un sweep y no un "primero, segundo, tercer más próximo"**: empujar sobre una sola bloqueante a la vez y volver a chequear es lo que garantiza encontrar el inicio *real* más temprano, incluso si hay varias bloqueantes en cadena (p. ej. una `EN_CURSO` seguida de una `URGENTE` ya reservada justo después).
|
| 62 |
+
|
| 63 |
+
### 3.3 `crear_reserva_urgente(db, data)` (línea ~636)
|
| 64 |
+
|
| 65 |
+
Orquesta todo el flujo. Devuelve `(reserva_urgente, reservas_desplazadas, created)`.
|
| 66 |
+
|
| 67 |
+
**Paso 1 — Idempotencia.** Busca por `solicitud_urgencia_hce_id` (`reserva_crud.get_by_urgencia_hce_id`). Si ya existe, devuelve `(existing, [], False)` sin tocar nada más. El router responde `200` en vez de `201` en este caso (ver §6).
|
| 68 |
+
|
| 69 |
+
**Paso 2 — Candidatos.** `cama_crud.get_quirofanos(db, hospital_id=data.hospital_id, exclude_estados=["FUERA_DE_SERVICIO", "BAJA_PERMANENTE", "EN_LIMPIEZA"])`. Dos filtros duros:
|
| 70 |
+
- **Hospital**: si `data.hospital_id` viene, solo se consideran quirófanos de ese hospital (nunca cruza de sede). Si no viene, se consideran todos.
|
| 71 |
+
- **Estado operable**: se excluyen quirófanos fuera de servicio, dados de baja o en limpieza — no importa qué tan "libres" estén de reservas, no se les puede asignar una cirugía.
|
| 72 |
+
|
| 73 |
+
Si no queda ningún candidato → `409 SIN_QUIROFANO_COMPATIBLE`.
|
| 74 |
+
|
| 75 |
+
**Paso 3 — Mejor quirófano.** Para cada candidato se calcula `_earliest_start`, y se elige el mínimo con este orden de desempate:
|
| 76 |
+
|
| 77 |
+
```python
|
| 78 |
+
def _orden(candidato):
|
| 79 |
+
q, inicio, _ = candidato
|
| 80 |
+
specialty_match = 0 if (data.specialty_id is not None and q.specialty_id == data.specialty_id) else 1
|
| 81 |
+
return (inicio, specialty_match, q.id)
|
| 82 |
+
|
| 83 |
+
quirofano, inicio_elegido, desplazables = min(candidatos, key=_orden)
|
| 84 |
+
```
|
| 85 |
+
|
| 86 |
+
1. Menor `inicio` (el que se libera antes gana — esto es lo que en la conversación de diseño se llamó "el próximo en liberarse").
|
| 87 |
+
2. Ante empate, el que matchea `specialty_id` (si se pidió).
|
| 88 |
+
3. Ante empate final, menor `id` de quirófano (determinismo).
|
| 89 |
+
|
| 90 |
+
**Paso 4 — Crear la urgente.** Se arma `data_ajustada` (copia de `data` con `fecha_hora_inicio=inicio_elegido` y `fecha_hora_fin_estimada=inicio_elegido + duracion`) y se persiste con `reserva_crud.create_urgente(db, quirofano.id, data_ajustada)` — `origen=EMERGENCIA`, `prioridad=URGENTE`, `estado=RESERVADA`. Se audita (`RESERVA_URGENTE`).
|
| 91 |
+
|
| 92 |
+
**Paso 5 — Reprogramar las desplazadas.** Para cada reserva en `desplazables` (ordenadas por `fecha_hora_inicio`):
|
| 93 |
+
1. Se le asigna `desplazada_por_reserva_id = reserva_urgente.id`.
|
| 94 |
+
2. Se llama a `reprogramar(db, r, no_antes_de=reserva_urgente.fecha_hora_fin_estimada, motivo=...)` (detalle en §5).
|
| 95 |
+
3. Se audita (`RESERVA_DESPLAZADA`), con `detalle={"desplazada_por_reserva_id": ..., "turno_id": ...}`.
|
| 96 |
+
|
| 97 |
+
## 4. Mapeo caso por caso (narrativa de negocio → código)
|
| 98 |
+
|
| 99 |
+
| Caso descrito | Qué hace el algoritmo |
|
| 100 |
+
|---|---|
|
| 101 |
+
| Hay un quirófano disponible ya | `_earliest_start` da `inicio == no_antes_de` para ese quirófano y es el mínimo global → se asigna directo, `reservas_desplazadas = []`. |
|
| 102 |
+
| Todos ocupados, hay que buscar el que se libera antes | Se corre `_earliest_start` en **todos** los candidatos y se toma el mínimo — no es un recorrido secuencial "primero, segundo, tercero", es un mínimo global sobre todos a la vez. |
|
| 103 |
+
| El siguiente turno de ese quirófano está libre | La reserva bloqueante (si la hay) libera el quirófano en `r.fecha_hora_fin_estimada`, y no hay ninguna `RESERVADA` justo después → `desplazables = []`, se ocupa ese instante. |
|
| 104 |
+
| El siguiente turno tiene una programada de menor prioridad | Cae dentro de `[inicio, inicio+duracion)` tras el sweep → entra a `desplazables` → se reprograma (§5), nunca se cancela. |
|
| 105 |
+
| El siguiente turno es también una urgencia | Es bloqueante (`prioridad == URGENTE`) → nunca se desplaza; `_earliest_start` empuja el inicio más allá de su fin, o directamente ese quirófano deja de ser competitivo y gana otro con un `inicio` menor. |
|
| 106 |
+
| Hay que seguir buscando el "segundo, tercer más próximo en liberarse" | No hace falta iterarlo a mano: el `min()` sobre todos los candidatos ya contempla, para cada quirófano, cuál es su propio próximo hueco libre real (empujando sobre todas sus bloqueantes en cadena), así que el resultado final ya es "el mejor entre todos los próximos en liberarse". |
|
| 107 |
+
| Cirugía en curso en el quirófano candidato | Es bloqueante (`estado == EN_CURSO`) → nunca se desplaza; el inicio se empuja hasta `r.fecha_hora_fin_estimada`. |
|
| 108 |
+
| Varias reservas programadas caen en la ventana elegida | `desplazables` puede tener más de un elemento (ventanas arbitrarias, no slots fijos) → se reprograman todas, en orden de `fecha_hora_inicio`. |
|
| 109 |
+
| Ningún quirófano operable en el hospital pedido | `409 SIN_QUIROFANO_COMPATIBLE` antes de intentar nada más. |
|
| 110 |
+
| M1 reintenta el mismo webhook (mismo `solicitud_urgencia_hce_id`) | Se devuelve la reserva ya creada, `reservas_desplazadas = []`, sin crear nada nuevo. Response `200` en vez de `201`. |
|
| 111 |
+
|
| 112 |
+
## 5. Reprogramación de una reserva desplazada — `reprogramar()`
|
| 113 |
+
|
| 114 |
+
```python
|
| 115 |
+
def reprogramar(db: Client, reserva: ReservaQuirofano, no_antes_de: datetime, motivo: str) -> ReservaQuirofano
|
| 116 |
+
```
|
| 117 |
+
|
| 118 |
+
Es el algoritmo que reubica **una** reserva ya desplazada. Se invoca una vez por cada elemento de `desplazables`, con `no_antes_de = reserva_urgente.fecha_hora_fin_estimada` (es decir: "no antes de que termine la cirugía urgente que la corrió").
|
| 119 |
+
|
| 120 |
+
Pasos:
|
| 121 |
+
|
| 122 |
+
1. **Duración preservada**: `duracion = reserva.fecha_hora_fin_estimada - reserva.fecha_hora_inicio` (la duración original de la reserva desplazada, no cambia).
|
| 123 |
+
2. **Busca hueco libre en el mismo quirófano**: arranca en `no_antes_de` y, mientras `reserva_crud.get_superpuestas(db, reserva.cama_id, inicio, inicio+duracion, exclude_id=reserva.id)` devuelva algo, empuja `inicio` al `fecha_hora_fin_estimada` más tardío de las solapadas. A diferencia de `_earliest_start` (que solo esquiva bloqueantes), acá se esquiva **cualquier** reserva activa — la prioridad es no dejar dos reservas superpuestas en la tabla, no negociar prioridades entre ellas.
|
| 124 |
+
3. **Actualiza la reserva en memoria**: nuevo `fecha_hora_inicio`/`fecha_hora_fin_estimada`, y agrega el `motivo` a sus `observaciones` (concatenado si ya tenía algo).
|
| 125 |
+
4. **Notifica a M2 si corresponde**: si `reserva.turno_id` existe (la reserva desplazada nació de un turno real, no fue creada por otra urgencia), llama a `turnos.reschedule_turno(turno_id, starts_at, ends_at)` — ver §6.
|
| 126 |
+
5. **Persiste**: `reserva_crud.save(db, reserva)`.
|
| 127 |
+
|
| 128 |
+
**Lo que garantiza:** la reserva reprogramada nunca queda con un horario que choque con otra reserva activa del mismo quirófano en la tabla `reservas_quirofano`.
|
| 129 |
+
|
| 130 |
+
**Lo que NO hace todavía (alcance de esta tarea, pendiente para la siguiente):**
|
| 131 |
+
- No evalúa mover la reserva a **otro quirófano** si el próximo hueco en el suyo es demasiado tardío.
|
| 132 |
+
- No **cascadea**: si el hueco elegido choca con otra reserva de menor prioridad, hoy simplemente sigue empujando la reserva actual más tarde, en vez de desplazar a esa otra reserva de menor prioridad para acomodarse antes.
|
| 133 |
+
|
| 134 |
+
Estas dos limitaciones están marcadas con `TODO` explícito en el docstring de `reprogramar()` en el código.
|
| 135 |
+
|
| 136 |
+
## 6. Persistencia y contrato de respuesta
|
| 137 |
+
|
| 138 |
+
- **Bug corregido**: antes, `reserva_crud.save` solo persistía `estado`, `observaciones` y `desplazada_por_reserva_id` — el nuevo horario de una reserva reprogramada nunca quedaba guardado en la tabla `reservas_quirofano` de M6, solo se le avisaba a M2. Ahora `save` también persiste `fecha_hora_inicio` y `fecha_hora_fin_estimada` (`app/crud/reserva.py`).
|
| 139 |
+
- **`CirugiaUrgenteResponse.reservas_desplazadas`** es una lista (antes era un único objeto `reserva_desplazada` nullable). Cada elemento: `{reserva_id, cama_id, turno_id, prioridad_original, notificado_a_m2}`.
|
| 140 |
+
- **Códigos de respuesta** (`app/routers/webhooks.py::recibir_cirugia_urgente`):
|
| 141 |
+
- `201` — se creó una reserva urgente nueva (con o sin desplazamientos).
|
| 142 |
+
- `200` — idempotencia: ya existía una reserva para ese `solicitud_urgencia_hce_id`.
|
| 143 |
+
- `409 SIN_QUIROFANO_COMPATIBLE` — no hay ningún quirófano operable para el hospital indicado.
|
| 144 |
+
- `422` — payload inválido (p. ej. `fecha_hora_inicio >= fecha_hora_fin_estimada`).
|
| 145 |
+
|
| 146 |
+
## 7. Notificación a M2 (mock)
|
| 147 |
+
|
| 148 |
+
Cuando `reprogramar()` mueve una reserva que tiene `turno_id` (es decir, nació de una reserva programada real, no de otra urgencia), llama a `turnos.reschedule_turno(turno_id, starts_at, ends_at)` (`app/integrations/turnos.py`), que sigue el contrato de `documentation/M2_openapi.json` (`PATCH /appointments/{id}/reschedule`): body `{starts_at, ends_at}` en formato `"YYYY-MM-DD HH:mm:ss"`.
|
| 149 |
+
|
| 150 |
+
Con `MOCK_EXTERNAL_SERVICES=true` (default), **no sale ninguna llamada de red** — decisión de arquitectura documentada en `M6_DISEÑO.md` §7.4 (el mock vive en la capa de clientes, no en la red). Pero a diferencia de una versión anterior que cortaba en silencio, ahora:
|
| 151 |
+
|
| 152 |
+
1. Arma el payload real (`{starts_at, ends_at}` con el formato de M2) sin importar si está mockeado o no.
|
| 153 |
+
2. En modo mock, lo loguea (`[MOCK M2] PATCH .../appointments/{turno_id}/reschedule payload=...`) junto con una respuesta enlatada con la forma real de M2 (`{message, notification_id}` con UUID) — para que quede visible en los logs del backend qué se le habría informado a M2 sobre ese turno.
|
| 154 |
+
3. En modo real (`MOCK_EXTERNAL_SERVICES=false`), hace el `PATCH` real contra `M2_TURNOS_URL`.
|
| 155 |
+
|
| 156 |
+
`notificado_a_m2` en la respuesta del webhook se deriva de `bool(reserva.turno_id)` — es `true` si la reserva desplazada tenía turno asociado (sin importar si el modo es mock o real).
|
| 157 |
+
|
| 158 |
+
## 8. Archivos involucrados
|
| 159 |
+
|
| 160 |
+
| Archivo | Rol |
|
| 161 |
+
|---|---|
|
| 162 |
+
| `app/services/cama_service.py` | `_es_bloqueante`, `_earliest_start`, `reprogramar`, `crear_reserva_urgente` — el algoritmo completo. |
|
| 163 |
+
| `app/crud/reserva.py` | `get_futuras` (reservas activas futuras de un quirófano, para `_earliest_start`), `get_superpuestas` (solapamiento exacto, para `reprogramar` y para chequeos de reservas programadas), `save` (persiste estado + horario + `desplazada_por_reserva_id`), `create_urgente`, `get_by_urgencia_hce_id`. |
|
| 164 |
+
| `app/schemas/reserva.py` | `CirugiaUrgenteWebhook` (payload entrante, con `specialty_id` opcional), `CirugiaUrgenteResponse` (con `reservas_desplazadas: list[...]`). |
|
| 165 |
+
| `app/routers/webhooks.py` | `recibir_cirugia_urgente` — arma la respuesta HTTP y decide `200` vs `201`. |
|
| 166 |
+
| `app/integrations/turnos.py` | `reschedule_turno` — notificación (mock o real) a M2. |
|
| 167 |
+
| `tests/test_webhooks.py` | Casos de test: quirófano libre, sin compatibles, exclusión de estados no operables, desplazamiento simple y múltiple, `EN_CURSO` bloqueante, `URGENTE` bloqueante con alternativa, idempotencia. |
|
| 168 |
+
|
| 169 |
+
## 9. Pendiente (fuera de alcance de esta versión)
|
| 170 |
+
|
| 171 |
+
- Diseño completo de `reprogramar()`: cambio de quirófano cuando el hueco propio es muy tardío, y cascada de desplazamientos (cuando el hueco elegido para la reserva desplazada choca con otra de menor prioridad).
|
| 172 |
+
- Lock transaccional para el caso de dos urgencias concurrentes sobre el mismo conjunto de quirófanos (hoy no hay bloqueo de fila explícito en este flujo).
|
| 173 |
+
- Qué hacer cuando no hay ningún quirófano operable: hoy es un `409` seco; podría valer la pena escalar o encolar en una versión futura.
|
tests/test_webhooks.py
CHANGED
|
@@ -87,62 +87,98 @@ def test_alerta_resuelta_404(client: TestClient, admin_headers, monkeypatch):
|
|
| 87 |
assert resp.status_code == 404
|
| 88 |
|
| 89 |
|
| 90 |
-
# ─── Cirugía urgente (M1 HCE) ───────────────────────────
|
| 91 |
-
|
| 92 |
-
|
| 93 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 94 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 95 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 96 |
-
monkeypatch.setattr("app.crud.reserva.
|
| 97 |
-
|
| 98 |
-
|
| 99 |
-
|
| 100 |
-
|
| 101 |
-
|
| 102 |
-
|
| 103 |
-
|
| 104 |
-
|
| 105 |
-
"timestamp": _NOW_ISO,
|
| 106 |
-
}
|
| 107 |
-
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=payload, headers=admin_headers)
|
| 108 |
assert resp.status_code == 201
|
| 109 |
data = resp.json()
|
| 110 |
assert data["reserva"]["estado"] == "RESERVADA"
|
| 111 |
-
assert data["
|
|
|
|
|
|
|
| 112 |
|
| 113 |
|
| 114 |
-
|
| 115 |
-
|
| 116 |
-
def test_cirugia_urgente_sin_quirofanos_409(client: TestClient, admin_headers, monkeypatch):
|
| 117 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 118 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [])
|
| 119 |
-
|
| 120 |
-
"solicitud_urgencia_hce_id": "URG-001",
|
| 121 |
-
"paciente_id": 7,
|
| 122 |
-
"medico_cirujano_id": 22,
|
| 123 |
-
"medico_solicitante_id": 10,
|
| 124 |
-
"fecha_hora_inicio": "2025-01-18T10:00:00Z",
|
| 125 |
-
"fecha_hora_fin_estimada": "2025-01-18T12:00:00Z",
|
| 126 |
-
"timestamp": _NOW_ISO,
|
| 127 |
-
}
|
| 128 |
-
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=payload, headers=admin_headers)
|
| 129 |
assert resp.status_code == 409
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 130 |
|
| 131 |
|
| 132 |
def test_cirugia_urgente_desplaza_y_reprograma(client: TestClient, admin_headers, monkeypatch):
|
| 133 |
-
"""Si
|
| 134 |
-
|
| 135 |
programada = make_reserva(
|
| 136 |
id=3, turno_id=5501, origen="PROGRAMADA", prioridad="MEDIA",
|
| 137 |
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 138 |
fecha_hora_fin_estimada=datetime(2025, 1, 18, 12, 0, tzinfo=timezone.utc),
|
| 139 |
)
|
| 140 |
-
urgente = make_reserva(
|
|
|
|
|
|
|
|
|
|
|
|
|
| 141 |
reschedule_calls = []
|
| 142 |
|
| 143 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 144 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 145 |
-
|
|
|
|
|
|
|
|
|
|
| 146 |
monkeypatch.setattr("app.crud.reserva.create_urgente", lambda db, cama_id, data: urgente)
|
| 147 |
monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
|
| 148 |
monkeypatch.setattr(
|
|
@@ -150,21 +186,14 @@ def test_cirugia_urgente_desplaza_y_reprograma(client: TestClient, admin_headers
|
|
| 150 |
lambda turno_id, starts_at, ends_at: reschedule_calls.append((turno_id, starts_at, ends_at)) or True,
|
| 151 |
)
|
| 152 |
|
| 153 |
-
|
| 154 |
-
"solicitud_urgencia_hce_id": "URG-002",
|
| 155 |
-
"paciente_id": 7,
|
| 156 |
-
"medico_cirujano_id": 22,
|
| 157 |
-
"medico_solicitante_id": 10,
|
| 158 |
-
"fecha_hora_inicio": "2025-01-18T10:00:00Z",
|
| 159 |
-
"fecha_hora_fin_estimada": "2025-01-18T11:00:00Z",
|
| 160 |
-
"timestamp": _NOW_ISO,
|
| 161 |
-
}
|
| 162 |
-
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=payload, headers=admin_headers)
|
| 163 |
assert resp.status_code == 201
|
| 164 |
data = resp.json()
|
| 165 |
-
assert data["
|
|
|
|
| 166 |
# Se reprogramó (no se canceló): la programada conserva estado RESERVADA.
|
| 167 |
assert programada.estado == "RESERVADA"
|
|
|
|
| 168 |
# reschedule_turno fue llamado con el turno desplazado, arrancando al terminar la urgente.
|
| 169 |
assert len(reschedule_calls) == 1
|
| 170 |
turno_id, starts_at, ends_at = reschedule_calls[0]
|
|
@@ -174,6 +203,117 @@ def test_cirugia_urgente_desplaza_y_reprograma(client: TestClient, admin_headers
|
|
| 174 |
assert ends_at == datetime(2025, 1, 18, 13, 0, tzinfo=timezone.utc)
|
| 175 |
|
| 176 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 177 |
# ─── Cancelación de reserva de quirófano (M2 Turnos) ─────────────────────
|
| 178 |
|
| 179 |
def test_cancelar_reserva_quirofano_ok(client: TestClient, admin_headers, monkeypatch):
|
|
|
|
| 87 |
assert resp.status_code == 404
|
| 88 |
|
| 89 |
|
| 90 |
+
# ─── Cirugía urgente (M1 HCE) — algoritmo ASAP ───────────────────────────
|
| 91 |
+
#
|
| 92 |
+
# El webhook manda `fecha_hora_inicio` ("no antes de") y `fecha_hora_fin_estimada`
|
| 93 |
+
# (de ahí sale la duración); M6 calcula el inicio real más temprano posible entre
|
| 94 |
+
# los quirófanos compatibles. Ver cama_service.crear_reserva_urgente / _earliest_start.
|
| 95 |
+
|
| 96 |
+
_URG_PAYLOAD_BASE = {
|
| 97 |
+
"solicitud_urgencia_hce_id": "URG-001",
|
| 98 |
+
"paciente_id": 7,
|
| 99 |
+
"medico_cirujano_id": 22,
|
| 100 |
+
"medico_solicitante_id": 10,
|
| 101 |
+
"fecha_hora_inicio": "2025-01-18T10:00:00Z",
|
| 102 |
+
"fecha_hora_fin_estimada": "2025-01-18T11:00:00Z", # duración: 1h
|
| 103 |
+
"timestamp": _NOW_ISO,
|
| 104 |
+
}
|
| 105 |
+
|
| 106 |
+
|
| 107 |
+
def test_cirugia_urgente_quirofano_libre_201(client: TestClient, admin_headers, monkeypatch):
|
| 108 |
+
"""Caso base: hay un quirófano sin ninguna reserva futura -> se asigna de
|
| 109 |
+
inmediato en el horario pedido, sin desplazar nada."""
|
| 110 |
+
reserva_urgente = make_reserva(
|
| 111 |
+
origen="EMERGENCIA", prioridad="URGENTE",
|
| 112 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 113 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 11, 0, tzinfo=timezone.utc),
|
| 114 |
+
)
|
| 115 |
+
create_calls = []
|
| 116 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 117 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 118 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", lambda db, cama_id, desde: [])
|
| 119 |
+
|
| 120 |
+
def _create_urgente(db, cama_id, data):
|
| 121 |
+
create_calls.append((cama_id, data))
|
| 122 |
+
return reserva_urgente
|
| 123 |
+
|
| 124 |
+
monkeypatch.setattr("app.crud.reserva.create_urgente", _create_urgente)
|
| 125 |
+
|
| 126 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
|
|
|
|
|
|
|
|
|
| 127 |
assert resp.status_code == 201
|
| 128 |
data = resp.json()
|
| 129 |
assert data["reserva"]["estado"] == "RESERVADA"
|
| 130 |
+
assert data["reservas_desplazadas"] == []
|
| 131 |
+
# El horario asignado es exactamente el pedido: no hubo que empujarlo.
|
| 132 |
+
assert create_calls[0][1].fecha_hora_inicio == datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc)
|
| 133 |
|
| 134 |
|
| 135 |
+
def test_cirugia_urgente_sin_quirofanos_compatibles_409(client: TestClient, admin_headers, monkeypatch):
|
|
|
|
|
|
|
| 136 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 137 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [])
|
| 138 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 139 |
assert resp.status_code == 409
|
| 140 |
+
assert resp.json()["detail"]["codigo"] == "SIN_QUIROFANO_COMPATIBLE"
|
| 141 |
+
|
| 142 |
+
|
| 143 |
+
def test_cirugia_urgente_excluye_quirofanos_no_operables(client: TestClient, admin_headers, monkeypatch):
|
| 144 |
+
"""FUERA_DE_SERVICIO / EN_LIMPIEZA / BAJA_PERMANENTE no deben considerarse."""
|
| 145 |
+
exclude_calls = []
|
| 146 |
+
|
| 147 |
+
def _get_quirofanos(db, hospital_id=None, specialty_id=None, exclude_estados=None, estado=None):
|
| 148 |
+
exclude_calls.append(exclude_estados)
|
| 149 |
+
return [make_quirofano()]
|
| 150 |
+
|
| 151 |
+
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 152 |
+
monkeypatch.setattr("app.crud.cama.get_quirofanos", _get_quirofanos)
|
| 153 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", lambda db, cama_id, desde: [])
|
| 154 |
+
monkeypatch.setattr("app.crud.reserva.create_urgente", lambda db, cama_id, data: make_reserva(prioridad="URGENTE"))
|
| 155 |
+
|
| 156 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
| 157 |
+
assert resp.status_code == 201
|
| 158 |
+
assert set(exclude_calls[0]) == {"FUERA_DE_SERVICIO", "BAJA_PERMANENTE", "EN_LIMPIEZA"}
|
| 159 |
|
| 160 |
|
| 161 |
def test_cirugia_urgente_desplaza_y_reprograma(client: TestClient, admin_headers, monkeypatch):
|
| 162 |
+
"""Si el único quirófano tiene una programada superpuesta, se REPROGRAMA (no se
|
| 163 |
+
cancela): se la mueve a continuación de la urgente y se llama reschedule_turno."""
|
| 164 |
programada = make_reserva(
|
| 165 |
id=3, turno_id=5501, origen="PROGRAMADA", prioridad="MEDIA",
|
| 166 |
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 167 |
fecha_hora_fin_estimada=datetime(2025, 1, 18, 12, 0, tzinfo=timezone.utc),
|
| 168 |
)
|
| 169 |
+
urgente = make_reserva(
|
| 170 |
+
id=9, origen="EMERGENCIA", prioridad="URGENTE",
|
| 171 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 172 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 11, 0, tzinfo=timezone.utc),
|
| 173 |
+
)
|
| 174 |
reschedule_calls = []
|
| 175 |
|
| 176 |
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 177 |
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 178 |
+
# La programada no es bloqueante (no es EN_CURSO ni URGENTE) -> earliest_start
|
| 179 |
+
# no se empuja, pero cae en la ventana elegida y se marca como desplazable.
|
| 180 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", lambda db, cama_id, desde: [programada])
|
| 181 |
+
monkeypatch.setattr("app.crud.reserva.get_superpuestas", lambda *a, **k: [])
|
| 182 |
monkeypatch.setattr("app.crud.reserva.create_urgente", lambda db, cama_id, data: urgente)
|
| 183 |
monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
|
| 184 |
monkeypatch.setattr(
|
|
|
|
| 186 |
lambda turno_id, starts_at, ends_at: reschedule_calls.append((turno_id, starts_at, ends_at)) or True,
|
| 187 |
)
|
| 188 |
|
| 189 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 190 |
assert resp.status_code == 201
|
| 191 |
data = resp.json()
|
| 192 |
+
assert len(data["reservas_desplazadas"]) == 1
|
| 193 |
+
assert data["reservas_desplazadas"][0]["turno_id"] == 5501
|
| 194 |
# Se reprogramó (no se canceló): la programada conserva estado RESERVADA.
|
| 195 |
assert programada.estado == "RESERVADA"
|
| 196 |
+
assert programada.desplazada_por_reserva_id == urgente.id
|
| 197 |
# reschedule_turno fue llamado con el turno desplazado, arrancando al terminar la urgente.
|
| 198 |
assert len(reschedule_calls) == 1
|
| 199 |
turno_id, starts_at, ends_at = reschedule_calls[0]
|
|
|
|
| 203 |
assert ends_at == datetime(2025, 1, 18, 13, 0, tzinfo=timezone.utc)
|
| 204 |
|
| 205 |
|
| 206 |
+
def test_cirugia_urgente_en_curso_no_se_desplaza_empuja_inicio(client: TestClient, admin_headers, monkeypatch):
|
| 207 |
+
"""Una reserva EN_CURSO nunca se reprograma: define cuándo se libera el
|
| 208 |
+
quirófano. El inicio de la urgente se empuja hasta que termina."""
|
| 209 |
+
en_curso = make_reserva(
|
| 210 |
+
id=4, estado="EN_CURSO", prioridad="MEDIA",
|
| 211 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 9, 0, tzinfo=timezone.utc),
|
| 212 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 10, 30, tzinfo=timezone.utc),
|
| 213 |
+
)
|
| 214 |
+
create_calls = []
|
| 215 |
+
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 216 |
+
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 217 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", lambda db, cama_id, desde: [en_curso])
|
| 218 |
+
|
| 219 |
+
def _create_urgente(db, cama_id, data):
|
| 220 |
+
create_calls.append(data)
|
| 221 |
+
return make_reserva(
|
| 222 |
+
prioridad="URGENTE", fecha_hora_inicio=data.fecha_hora_inicio,
|
| 223 |
+
fecha_hora_fin_estimada=data.fecha_hora_fin_estimada,
|
| 224 |
+
)
|
| 225 |
+
|
| 226 |
+
monkeypatch.setattr("app.crud.reserva.create_urgente", _create_urgente)
|
| 227 |
+
|
| 228 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
| 229 |
+
assert resp.status_code == 201
|
| 230 |
+
assert resp.json()["reservas_desplazadas"] == []
|
| 231 |
+
# Pedido a las 10:00, pero la EN_CURSO libera recién a las 10:30 -> arranca ahí.
|
| 232 |
+
assert create_calls[0].fecha_hora_inicio == datetime(2025, 1, 18, 10, 30, tzinfo=timezone.utc)
|
| 233 |
+
assert en_curso.estado == "EN_CURSO" # no se tocó
|
| 234 |
+
|
| 235 |
+
|
| 236 |
+
def test_cirugia_urgente_elige_quirofano_libre_sobre_uno_con_urgente(client: TestClient, admin_headers, monkeypatch):
|
| 237 |
+
"""Una reserva URGENTE ya existente es bloqueante: nunca se desplaza. Si hay
|
| 238 |
+
otro quirófano libre, el algoritmo debe preferirlo (menor earliest_start)."""
|
| 239 |
+
q_ocupado = make_quirofano(id=501)
|
| 240 |
+
q_libre = make_quirofano(id=502)
|
| 241 |
+
urgente_existente = make_reserva(
|
| 242 |
+
id=5, estado="RESERVADA", prioridad="URGENTE", cama_id=501,
|
| 243 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 244 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 11, 0, tzinfo=timezone.utc),
|
| 245 |
+
)
|
| 246 |
+
|
| 247 |
+
def _get_futuras(db, cama_id, desde):
|
| 248 |
+
return [urgente_existente] if cama_id == 501 else []
|
| 249 |
+
|
| 250 |
+
create_calls = []
|
| 251 |
+
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 252 |
+
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [q_ocupado, q_libre])
|
| 253 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", _get_futuras)
|
| 254 |
+
|
| 255 |
+
def _create_urgente(db, cama_id, data):
|
| 256 |
+
create_calls.append((cama_id, data))
|
| 257 |
+
return make_reserva(prioridad="URGENTE", cama_id=cama_id)
|
| 258 |
+
|
| 259 |
+
monkeypatch.setattr("app.crud.reserva.create_urgente", _create_urgente)
|
| 260 |
+
|
| 261 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
| 262 |
+
assert resp.status_code == 201
|
| 263 |
+
assert resp.json()["reservas_desplazadas"] == []
|
| 264 |
+
cama_elegida, data_creada = create_calls[0]
|
| 265 |
+
assert cama_elegida == 502
|
| 266 |
+
assert data_creada.fecha_hora_inicio == datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc)
|
| 267 |
+
|
| 268 |
+
|
| 269 |
+
def test_cirugia_urgente_desplaza_varias_reservas(client: TestClient, admin_headers, monkeypatch):
|
| 270 |
+
"""Con ventanas arbitrarias, más de una reserva programada puede caer dentro
|
| 271 |
+
del hueco elegido para la urgencia: todas se reprograman."""
|
| 272 |
+
programada_a = make_reserva(
|
| 273 |
+
id=6, turno_id=601, prioridad="BAJA",
|
| 274 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 275 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 10, 30, tzinfo=timezone.utc),
|
| 276 |
+
)
|
| 277 |
+
programada_b = make_reserva(
|
| 278 |
+
id=7, turno_id=602, prioridad="MEDIA",
|
| 279 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 30, tzinfo=timezone.utc),
|
| 280 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 11, 0, tzinfo=timezone.utc),
|
| 281 |
+
)
|
| 282 |
+
urgente = make_reserva(
|
| 283 |
+
id=10, prioridad="URGENTE",
|
| 284 |
+
fecha_hora_inicio=datetime(2025, 1, 18, 10, 0, tzinfo=timezone.utc),
|
| 285 |
+
fecha_hora_fin_estimada=datetime(2025, 1, 18, 11, 0, tzinfo=timezone.utc),
|
| 286 |
+
)
|
| 287 |
+
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: None)
|
| 288 |
+
monkeypatch.setattr("app.crud.cama.get_quirofanos", lambda *a, **k: [make_quirofano()])
|
| 289 |
+
monkeypatch.setattr("app.crud.reserva.get_futuras", lambda db, cama_id, desde: [programada_a, programada_b])
|
| 290 |
+
monkeypatch.setattr("app.crud.reserva.get_superpuestas", lambda *a, **k: [])
|
| 291 |
+
monkeypatch.setattr("app.crud.reserva.create_urgente", lambda db, cama_id, data: urgente)
|
| 292 |
+
monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
|
| 293 |
+
monkeypatch.setattr("app.integrations.turnos.reschedule_turno", lambda *a, **k: True)
|
| 294 |
+
|
| 295 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
| 296 |
+
assert resp.status_code == 201
|
| 297 |
+
desplazadas = resp.json()["reservas_desplazadas"]
|
| 298 |
+
assert {d["turno_id"] for d in desplazadas} == {601, 602}
|
| 299 |
+
|
| 300 |
+
|
| 301 |
+
def test_cirugia_urgente_idempotente_200(client: TestClient, admin_headers, monkeypatch):
|
| 302 |
+
"""Reintento de M1 con la misma solicitud_urgencia_hce_id: no se crea de nuevo."""
|
| 303 |
+
existing = make_reserva(prioridad="URGENTE", solicitud_urgencia_hce_id="URG-001")
|
| 304 |
+
create_calls = []
|
| 305 |
+
monkeypatch.setattr("app.crud.reserva.get_by_urgencia_hce_id", lambda db, hce_id: existing)
|
| 306 |
+
monkeypatch.setattr(
|
| 307 |
+
"app.crud.reserva.create_urgente",
|
| 308 |
+
lambda db, cama_id, data: create_calls.append(1) or make_reserva(),
|
| 309 |
+
)
|
| 310 |
+
|
| 311 |
+
resp = client.post(f"{WEBHOOKS_PREFIX}/hce/cirugia-urgente", json=_URG_PAYLOAD_BASE, headers=admin_headers)
|
| 312 |
+
assert resp.status_code == 200
|
| 313 |
+
assert resp.json()["reservas_desplazadas"] == []
|
| 314 |
+
assert create_calls == []
|
| 315 |
+
|
| 316 |
+
|
| 317 |
# ─── Cancelación de reserva de quirófano (M2 Turnos) ─────────────────────
|
| 318 |
|
| 319 |
def test_cancelar_reserva_quirofano_ok(client: TestClient, admin_headers, monkeypatch):
|