juampisor commited on
Commit
0ea0860
·
1 Parent(s): d53b1d7

Implementacion algoritmo de cirugias urgencias. Desplazamiento de turnos de menor prioridad. Documentacion.

Browse files
.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 disponible"},
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, reserva_desplazada = cama_service.crear_reserva_urgente(db, data)
84
  resp_reserva = ReservaQuirofanoResponse.model_validate(reserva_urgente)
85
 
86
- resp_desplazada = None
87
- if reserva_desplazada:
88
- resp_desplazada = ReservaDesplazadaInfo(
89
- reserva_id=reserva_desplazada.id,
90
- cama_id=reserva_desplazada.cama_id,
91
- turno_id=reserva_desplazada.turno_id,
92
- prioridad_original=reserva_desplazada.prioridad,
93
- notificado_a_m2=bool(reserva_desplazada.turno_id),
94
  )
 
 
95
 
96
- msg = "Reserva urgente creada exitosamente"
97
- if resp_desplazada:
98
- msg = f"Reserva urgente creada. Se desplazó la reserva {reserva_desplazada.id} (prioridad {reserva_desplazada.prioridad})"
 
 
 
 
99
 
100
  content = CirugiaUrgenteResponse(
101
  mensaje=msg,
102
  reserva=resp_reserva,
103
- reserva_desplazada=resp_desplazada,
104
  ).model_dump(mode="json")
105
 
106
- return JSONResponse(content=content, status_code=status.HTTP_201_CREATED)
 
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
- reserva_desplazada: Optional[ReservaDesplazadaInfo] = None
 
 
 
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 crear_reserva_urgente(
564
- db: Client, data: CirugiaUrgenteWebhook
565
- ) -> tuple[ReservaQuirofano, ReservaQuirofano | None]:
 
 
 
 
 
 
566
  """
567
- Crea una reserva urgente (EMERGENCIA, prioridad URGENTE).
568
- Desplaza la de menor prioridad si todos los quirófanos están ocupados.
 
 
 
 
 
 
 
569
  """
570
- existing = reserva_crud.get_by_urgencia_hce_id(db, data.solicitud_urgencia_hce_id)
571
- if existing:
572
- return existing, None
573
-
574
- quirofanos = cama_crud.get_quirofanos(db)
575
- if not quirofanos:
576
- raise HTTPException(
577
- status_code=409,
578
- detail={"codigo": "SIN_QUIROFANO_DISPONIBLE", "mensaje": "No hay quirófanos en el sistema"},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
- if cama_libre:
589
- reserva = reserva_crud.create_urgente(db, cama_libre.id, data)
590
- auditoria_crud.registrar(
591
- db,
592
- entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
593
- entidad_id=reserva.id,
594
- cama_id=cama_libre.id,
595
- evento=TipoEventoAuditoriaEnum.RESERVA_URGENTE.value,
596
- estado_nuevo=reserva.estado,
597
- paciente_id=reserva.paciente_id,
598
- origen=OrigenAuditoriaEnum.WEBHOOK.value,
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
- candidata = _find_desplazable(db, quirofanos, data.fecha_hora_inicio, data.fecha_hora_fin_estimada)
605
- if not candidata:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
606
  raise HTTPException(
607
  status_code=409,
608
  detail={
609
- "codigo": "SIN_QUIROFANO_DISPONIBLE",
610
- "mensaje": "No hay quirófanos disponibles y no existe reserva desplazable",
611
  },
612
  )
613
 
614
- candidata_cama_id = candidata.cama_id
615
 
616
- # La cirugía desplazada NO se cancela: se reprograma. La movemos a continuación
617
- # de la urgente, en el mismo quirófano, preservando su duración original.
618
- duracion = candidata.fecha_hora_fin_estimada - candidata.fecha_hora_inicio
619
- nuevo_inicio = data.fecha_hora_fin_estimada
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
- reserva_urgente = reserva_crud.create_urgente(db, candidata_cama_id, data)
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=candidata_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 {candidata_cama_id} (desplazó la reserva {candidata.id})",
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
- return reserva_urgente, candidata
660
-
661
-
662
- def _find_desplazable(
663
- db: Client, quirofanos: list[Cama], inicio: datetime, fin: datetime
664
- ) -> ReservaQuirofano | None:
665
- candidata = None
666
- for q in quirofanos:
667
- solapadas = reserva_crud.get_superpuestas(db, q.id, inicio, fin)
668
- for r in solapadas:
669
- if r.prioridad == "URGENTE":
670
- continue
671
- if candidata is None:
672
- candidata = r
673
- else:
674
- p_r = _PRIORIDAD_ORDER.get(r.prioridad, 99)
675
- p_c = _PRIORIDAD_ORDER.get(candidata.prioridad, 99)
676
- if p_r < p_c or (p_r == p_c and r.fecha_hora_inicio < candidata.fecha_hora_inicio):
677
- candidata = r
678
- return candidata
 
 
 
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 desplazamiento
194
 
195
- 1. M1 hace `POST /webhooks/hce/cirugia-urgente`.
196
- 2. M6 busca un quirófano compatible en la ventana. Si está libre, reserva `EMERGENCIA`. Si está ocupado por una `PROGRAMADA`, **la desplaza**: la programada pasa a `CANCELADA` y la urgente se crea con referencia inversa; la urgente guarda `desplazada_por_reserva_id` apuntando a la desplazada.
197
- 3. La respuesta incluye la reserva creada y, si hubo, la `reserva_desplazada`.
 
 
 
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 cancela automáticamente por una `EMERGENCIA`; nunca por otra programada.
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
- M6 busca un quirófano libre en la ventana; si están todos ocupados **desplaza** la reserva
121
- programada de menor prioridad: **no la cancela**, la **reprograma** en M2 (la mueve a
122
- continuación de la urgente, preservando su duración) y crea la urgente en su lugar.
 
 
 
 
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
- "reserva_desplazada": null
160
  }
161
  ```
162
 
163
- **Respuesta 201 (con desplazamiento):** `reserva_desplazada` trae la reserva programada que fue
164
- reprogramada (sigue `RESERVADA`, con nuevo horario; `turno_id` reprogramado en M2).
 
 
 
 
 
 
 
 
 
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 de forma inmediata.\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| Prioridad | Siempre `URGENTE` | Cualquiera excepto `URGENTE` |\n| Desplazamiento de otras reservas | Sí, automático | 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 cancelar automáticamente a otras reservas ya confirmadas.\n\n## Acciones que ejecuta este módulo\n\n1. Busca quirófanos disponibles (sector=QUIROFANO, tipo=CIRUGIA, estado\n distinto de FUERA_DE_SERVICIO y BAJA_PERMANENTE) en el rango\n [`fecha_hora_inicio`, `fecha_hora_fin_estimada`].\n\n2. **Si hay algún quirófano libre (sin reservas superpuestas):** crea la\n reserva con `origen=EMERGENCIA`, `prioridad=URGENTE` y `estado=RESERVADA`.\n Responde `201`.\n\n3. **Si todos los quirófanos del rango tienen reservas activas:**\n selecciona la reserva candidata a desplazar según el siguiente\n criterio:\n 1. Menor prioridad (`MUY_BAJA` antes que `BAJA`, etc.). Sólo se\n consideran reservas con prioridad menor a `URGENTE`.\n 2. Dentro de las de menor prioridad, la que tiene `fecha_hora_inicio`\n más cercana al momento actual.\n 3. Si hay empate, la de menor `id`.\n\n4. La reserva elegida pasa a `estado=CANCELADA` con\n `desplazada_por_reserva_id` apuntando a la nueva reserva urgente.\n\n5. **[EXT]** Si la reserva desplazada tiene `turno_id`, se notifica a M2\n vía `POST /turnos/{turnoId}/resultado-quirofano` con\n `resultado=CANCELADA` y `motivo_cancelacion=DESPLAZADA_POR_URGENCIA`.\n\n6. Se crea la nueva reserva urgente en el quirófano liberado con\n `origen=EMERGENCIA`, `prioridad=URGENTE` y `estado=RESERVADA`.\n Responde `201`.\n\n7. **Si no existe ninguna reserva desplazable** (todas las reservas\n activas son también `URGENTE`, o no hay quirófanos en el sistema),\n responde `409 SIN_QUIROFANO_DISPONIBLE`. M1 es responsable de decidir\n el siguiente paso (reprogramar, derivar a otro hospital, etc.).\n\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,13 +2447,13 @@
2447
  "desplazada_por_reserva_id": null,
2448
  "created_at": "2025-01-18T13:46:00Z"
2449
  },
2450
- "reserva_desplazada": null
2451
  }
2452
  },
2453
  "con_desplazamiento": {
2454
- "summary": "Se canceló una reserva de menor prioridad",
2455
  "value": {
2456
- "mensaje": "Reserva urgente creada. Se desplazó la reserva 15 (prioridad BAJA) para liberar el quirófano 501.",
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). Desplazó reserva 15.",
2469
  "desplazada_por_reserva_id": null,
2470
  "created_at": "2025-01-18T13:46:00Z"
2471
  },
2472
- "reserva_desplazada": {
2473
- "reserva_id": 15,
2474
- "cama_id": 501,
2475
- "turno_id": 89,
2476
- "prioridad_original": "BAJA",
2477
- "notificado_a_m2": true
2478
- }
 
 
2479
  }
2480
  }
2481
  }
@@ -2537,11 +2539,11 @@
2537
  },
2538
  "examples": {
2539
  "sin_quirofanos": {
2540
- "summary": "No hay quirófanos desplazables",
2541
  "value": {
2542
- "codigo": "SIN_QUIROFANO_DISPONIBLE",
2543
- "mensaje": "No hay quirófanos disponibles y no existe reserva desplazable de menor prioridad",
2544
- "detalle": "Todas las reservas activas en el rango solicitado tienen prioridad URGENTE. M1 debe reprogramar o derivar el paciente."
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. A diferencia de una reserva programada, no se especifica cama destino: M6 decide qué quirófano utilizar y si desplaza o no una reserva de menor prioridad.\n",
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 si hubo desplazamiento de una reserva existente y los datos de la nueva reserva creada.\n",
5939
  "required": [
5940
  "mensaje",
5941
- "reserva"
 
5942
  ],
5943
  "properties": {
5944
  "mensaje": {
@@ -5948,34 +5959,36 @@
5948
  "reserva": {
5949
  "$ref": "#/components/schemas/ReservaQuirofanoResponse"
5950
  },
5951
- "reserva_desplazada": {
5952
- "type": "object",
5953
- "description": "Presente sólo si se canceló una reserva de menor prioridad para ubicar la cirugía urgente. `null` si había quirófano libre.\n",
5954
- "properties": {
5955
- "reserva_id": {
5956
- "type": "integer",
5957
- "example": 15
5958
- },
5959
- "cama_id": {
5960
- "type": "integer",
5961
- "example": 501
5962
- },
5963
- "turno_id": {
5964
- "type": "integer",
5965
- "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.",
5966
- "nullable": true,
5967
- "example": 89
5968
- },
5969
- "prioridad_original": {
5970
- "$ref": "#/components/schemas/PrioridadQuirofanoEnum"
5971
- },
5972
- "notificado_a_m2": {
5973
- "type": "boolean",
5974
- "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",
5975
- "example": true
 
 
 
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
- def test_cirugia_urgente_ok_201(client: TestClient, admin_headers, monkeypatch):
93
- reserva_urgente = make_reserva(origen="EMERGENCIA", prioridad="URGENTE")
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.get_superpuestas", lambda *a, **k: [])
97
- monkeypatch.setattr("app.crud.reserva.create_urgente", lambda db, cama_id, data: reserva_urgente)
98
- payload = {
99
- "solicitud_urgencia_hce_id": "URG-001",
100
- "paciente_id": 7,
101
- "medico_cirujano_id": 22,
102
- "medico_solicitante_id": 10,
103
- "fecha_hora_inicio": "2025-01-18T10:00:00Z",
104
- "fecha_hora_fin_estimada": "2025-01-18T12:00:00Z",
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["reserva_desplazada"] is None
 
 
112
 
113
 
114
- # ─── Cirugía urgente sin quirófanos disponibles (M1 HCE) ─────────────────
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
- payload = {
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 no hay quirófano libre, la programada de menor prioridad se REPROGRAMA en M2
134
- (no se cancela): se la mueve a continuación de la urgente y se llama reschedule_turno."""
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(id=9, origen="EMERGENCIA", prioridad="URGENTE")
 
 
 
 
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
- monkeypatch.setattr("app.crud.reserva.get_superpuestas", lambda *a, **k: [programada])
 
 
 
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
- payload = {
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["reserva_desplazada"]["turno_id"] == 5501
 
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):