api / app /services /cama_service.py
juampisor's picture
Fix alerta roja
c03d875
Raw History Blame Contribute Delete
35 kB
"""
Lógica de negocio para Camas y Reservas de Quirófano.
"""
from __future__ import annotations
import logging
from datetime import datetime, timedelta, timezone
from fastapi import HTTPException
from supabase import Client
from app.models.cama import Cama
from app.models.reserva import ReservaQuirofano
from app.schemas.cama import (
CamaCreateRequest,
CamaUpdateRequest,
QuirofanoCreateRequest,
QuirofanoUpdateRequest,
)
from app.schemas.reserva import (
ReservaQuirofanoCreateRequest,
ReservaProgramadaAutoRequest,
ReservaEstadoUpdateRequest,
CirugiaUrgenteWebhook,
)
from app.schemas.enums import EstadoCamaEnum, EstadoReservaEnum, SectorEnum, TipoCamaEnum
from app.crud import cama as cama_crud
from app.crud import reserva as reserva_crud
from app.crud import auditoria as auditoria_crud
from app.integrations import hce, monitoreo, turnos
from app.schemas.enums import EntidadAuditoriaEnum, TipoEventoAuditoriaEnum, OrigenAuditoriaEnum
from app.services._common import validar_paciente_o_502
logger = logging.getLogger(__name__)
# ─── Constantes de dominio ─────────────────────────────────────────────────
_ERR_CAMA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Cama no encontrada"}
_ERR_RESERVA_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Reserva no encontrada"}
# ─── Helpers ───────────────────────────────────────────────────────────────
def _get_cama_or_404(db: Client, cama_id: int) -> Cama:
cama = cama_crud.get_by_id(db, cama_id)
if not cama:
raise HTTPException(status_code=404, detail=_ERR_CAMA_NOT_FOUND)
return cama
def _is_quirofano(cama: Cama) -> bool:
return cama.sector == "QUIROFANO" and cama.tipo == "CIRUGIA"
def _verificar_contraindicaciones(paciente_id: int, cama: Cama) -> None:
contraindicaciones = hce.get_contraindicaciones(paciente_id)
incompatibles = cama.contraindicaciones_incompatibles or []
conflicto = set(contraindicaciones) & set(incompatibles)
if conflicto:
raise HTTPException(
status_code=422,
detail={
"codigo": "CONTRAINDICACION_DETECTADA",
"mensaje": "El paciente tiene contraindicaciones incompatibles con la cama destino",
},
)
# ─── Camas ─────────────────────────────────────────────────────────────────
def get_camas(
db: Client,
piso: int | None = None,
sector: str | None = None,
estado: str | None = None,
hospital_id: str | None = None,
) -> list[Cama]:
return cama_crud.get_all(db, piso, sector, estado, hospital_id)
def create_cama(db: Client, data: CamaCreateRequest, actor: dict | None = None) -> Cama:
logger.info("Creando cama numero=%s sector=%s tipo=%s", data.numero, data.sector, data.tipo)
cama = cama_crud.create(db, data)
logger.info("Cama creada — id=%s numero=%s", cama.id, cama.numero)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_CREADA.value,
estado_nuevo=cama.estado,
actor=actor,
descripcion=f"Cama {cama.numero} creada en {cama.sector}",
hospital_id=cama.hospital_id,
)
return cama
def get_cama(db: Client, cama_id: int) -> Cama:
return _get_cama_or_404(db, cama_id)
def update_cama(
db: Client, cama_id: int, data: CamaUpdateRequest, rol: str, actor: dict | None = None
) -> Cama:
logger.info("Actualizando cama id=%s rol=%s nuevo_estado=%s", cama_id, rol, data.estado)
cama = _get_cama_or_404(db, cama_id)
estado_previo = cama.estado
if rol == "LIMPIEZA" and data.contraindicaciones_incompatibles is not None:
logger.warning("Intento de modificar contraindicaciones por rol LIMPIEZA — cama_id=%s", cama_id)
raise HTTPException(
status_code=403,
detail={
"codigo": "NO_AUTORIZADO",
"mensaje": "El rol LIMPIEZA no puede modificar contraindicaciones",
},
)
if data.estado is not None:
nuevo_estado = data.estado.value
if nuevo_estado in (
EstadoCamaEnum.OCUPADA.value,
EstadoCamaEnum.CODIGO_ROJO.value,
EstadoCamaEnum.EN_LIMPIEZA.value,
):
raise HTTPException(
status_code=409,
detail={
"codigo": "CONFLICTO_ESTADO",
"mensaje": f"El estado {nuevo_estado} solo se asigna automáticamente",
},
)
if rol == "LIMPIEZA" and not (
cama.estado == EstadoCamaEnum.EN_LIMPIEZA.value
and nuevo_estado == EstadoCamaEnum.DISPONIBLE.value
):
raise HTTPException(
status_code=403,
detail={
"codigo": "NO_AUTORIZADO",
"mensaje": "El rol LIMPIEZA solo puede transicionar de EN_LIMPIEZA a DISPONIBLE",
},
)
estado_anterior = cama.estado
cama.estado = nuevo_estado
if (
estado_anterior == EstadoCamaEnum.EN_LIMPIEZA.value
and nuevo_estado == EstadoCamaEnum.DISPONIBLE.value
and cama.ultimo_movimiento_tipo in ("ALTA", "TRASLADO")
):
# Cierra el episodio: sea por alta o por traslado, la cama que el paciente
# deja no debe seguir cargando su episodio — el próximo paciente que la ocupe
# no puede arrancar con datos del episodio anterior (ver M6_DISEÑO.md).
fue_alta = cama.ultimo_movimiento_tipo == "ALTA"
cama.paciente_id = None
cama.ultimo_movimiento_tipo = None
cama.solicitud_hce_id = None
cama.fecha_ingreso = None
cama.episodio_id = None
if fue_alta:
cama.alta_tipo = None
cama.alta_timestamp = None
elif nuevo_estado == EstadoCamaEnum.DISPONIBLE.value and cama.paciente_id:
cama.paciente_id = None
cama.ultimo_movimiento_tipo = None
if data.contraindicaciones_incompatibles is not None:
cama.contraindicaciones_incompatibles = data.contraindicaciones_incompatibles
cama.ultima_actualizacion = datetime.now(timezone.utc)
cama = cama_crud.save(db, cama)
if data.estado is not None and cama.estado != estado_previo:
logger.info("Cama id=%s: %s → %s", cama.id, estado_previo, cama.estado)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_CAMBIO_ESTADO.value,
estado_anterior=estado_previo,
estado_nuevo=cama.estado,
paciente_id=cama.paciente_id,
actor=actor,
descripcion=f"Cama {cama.numero}: {estado_previo} → {cama.estado}",
hospital_id=cama.hospital_id,
)
return cama
def delete_cama(db: Client, cama_id: int, actor: dict | None = None) -> Cama:
cama = _get_cama_or_404(db, cama_id)
if cama.estado in (
EstadoCamaEnum.OCUPADA.value,
EstadoCamaEnum.EN_LIMPIEZA.value,
EstadoCamaEnum.CODIGO_ROJO.value,
):
raise HTTPException(
status_code=409,
detail={
"codigo": "CAMA_EN_USO",
"mensaje": "No se puede dar de baja una cama en uso",
"detalle": f"La cama {cama_id} está en estado {cama.estado}",
},
)
if cama.estado == EstadoCamaEnum.BAJA_PERMANENTE.value:
raise HTTPException(
status_code=409,
detail={"codigo": "CONFLICTO_ESTADO", "mensaje": "La cama ya está dada de baja"},
)
estado_previo = cama.estado
cama.estado = EstadoCamaEnum.BAJA_PERMANENTE.value
cama.ultima_actualizacion = datetime.now(timezone.utc)
cama = cama_crud.save(db, cama)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_BAJA.value,
estado_anterior=estado_previo,
estado_nuevo=cama.estado,
actor=actor,
descripcion=f"Baja permanente de la cama {cama.numero}",
hospital_id=cama.hospital_id,
)
return cama
def asignar_cama(
db: Client, cama_id: int, tipo: str, paciente_id: int, cama_origen_id: int | None,
actor: dict | None = None,
) -> Cama:
logger.info("Asignando cama id=%s tipo=%s paciente_id=%s", cama_id, tipo, paciente_id)
cama_destino = _get_cama_or_404(db, cama_id)
if cama_destino.estado != EstadoCamaEnum.DISPONIBLE.value:
logger.warning(
"Cama id=%s no disponible para asignación — estado_actual=%s",
cama_id, cama_destino.estado,
)
raise HTTPException(
status_code=409,
detail={
"codigo": "CAMA_NO_DISPONIBLE",
"mensaje": "La cama destino no está disponible",
"detalle": f"La cama {cama_id} está en estado {cama_destino.estado}",
},
)
validar_paciente_o_502(paciente_id)
_verificar_contraindicaciones(paciente_id, cama_destino)
if tipo == "TRASLADO":
if not cama_origen_id:
raise HTTPException(
status_code=400,
detail={"codigo": "ERROR_VALIDACION", "mensaje": "cama_origen_id es requerido para TRASLADO"},
)
cama_origen = _get_cama_or_404(db, cama_origen_id)
origen_en_codigo_rojo = cama_origen.estado == EstadoCamaEnum.CODIGO_ROJO.value
# El episodio (fecha de ingreso, id de la internación, id del episodio en M1) es
# continuo a través de un traslado — se hereda de la cama origen, igual que en
# `solicitud_service._aprobar_traslado`. La cama origen lo pierde recién cuando se
# libere de verdad (`update_cama`, EN_LIMPIEZA → DISPONIBLE).
cama_destino.solicitud_hce_id = cama_origen.solicitud_hce_id
cama_destino.fecha_ingreso = cama_origen.fecha_ingreso
cama_destino.episodio_id = cama_origen.episodio_id
cama_origen.estado = EstadoCamaEnum.EN_LIMPIEZA.value
cama_origen.ultimo_movimiento_tipo = "TRASLADO"
cama_origen.ultima_actualizacion = datetime.now(timezone.utc)
cama_crud.save(db, cama_origen)
hce.notify_movimiento(cama_destino, paciente_id, actor)
monitoreo.notify_baja(paciente_id, cama_origen_id)
monitoreo.notify_alta(paciente_id, cama_id)
else:
origen_en_codigo_rojo = False
hce.notify_movimiento(cama_destino, paciente_id, actor)
monitoreo.notify_alta(paciente_id, cama_id)
# Si la cama origen estaba en CODIGO_ROJO (emergencia activa), el destino hereda ese
# estado — el traslado no puede "resolver" una emergencia que sigue en curso. En
# cualquier otro caso (origen OCUPADA, lo normal), el destino pasa a OCUPADA como
# siempre. Sin esto, `procesar_alerta_resuelta` (M9) deja de encontrar la cama por
# paciente_id+CODIGO_ROJO tras el traslado y devuelve 404 aunque la emergencia siga.
cama_destino.estado = (
EstadoCamaEnum.CODIGO_ROJO.value if origen_en_codigo_rojo else EstadoCamaEnum.OCUPADA.value
)
cama_destino.paciente_id = paciente_id
cama_destino.ultima_actualizacion = datetime.now(timezone.utc)
cama_destino = cama_crud.save(db, cama_destino)
es_traslado = tipo == "TRASLADO"
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama_destino.id,
cama_id=cama_destino.id,
evento=(
TipoEventoAuditoriaEnum.CAMA_TRASLADO.value
if es_traslado
else TipoEventoAuditoriaEnum.CAMA_ASIGNADA.value
),
estado_nuevo=cama_destino.estado,
paciente_id=paciente_id,
actor=actor,
descripcion=(
f"Traslado del paciente {paciente_id} a la cama {cama_destino.numero}"
if es_traslado
else f"Ingreso del paciente {paciente_id} a la cama {cama_destino.numero}"
),
detalle={"tipo": tipo, "cama_origen_id": cama_origen_id} if es_traslado else {"tipo": tipo},
hospital_id=cama_destino.hospital_id,
)
return cama_destino
# ─── Quirófanos (entidad) ──────────────────────────────────────────────────
_ERR_QUIROFANO_NOT_FOUND = {
"codigo": "RECURSO_NO_ENCONTRADO",
"mensaje": "Quirófano no encontrado",
}
def _get_quirofano_or_404(db: Client, quirofano_id: int) -> Cama:
cama = _get_cama_or_404(db, quirofano_id)
if not _is_quirofano(cama):
raise HTTPException(status_code=404, detail=_ERR_QUIROFANO_NOT_FOUND)
return cama
def get_quirofanos_list(
db: Client,
hospital_id: str | None = None,
estado: str | None = None,
specialty_id: int | None = None,
) -> list[Cama]:
return cama_crud.get_quirofanos(
db, hospital_id, specialty_id,
exclude_estados=[EstadoCamaEnum.BAJA_PERMANENTE.value], estado=estado,
)
def create_quirofano(db: Client, data: QuirofanoCreateRequest, actor: dict | None = None) -> Cama:
cama_req = CamaCreateRequest(
numero=data.numero,
piso=data.piso,
sector=SectorEnum.QUIROFANO,
tipo=TipoCamaEnum.CIRUGIA,
specialty_id=data.specialty_id,
hospital_id=data.hospital_id,
contraindicaciones_incompatibles=data.contraindicaciones_incompatibles,
)
cama = cama_crud.create(db, cama_req)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_CREADA.value,
estado_nuevo=cama.estado,
actor=actor,
descripcion=f"Quirófano {cama.numero} creado",
hospital_id=cama.hospital_id,
)
return cama
def get_quirofano(db: Client, quirofano_id: int) -> Cama:
return _get_quirofano_or_404(db, quirofano_id)
def update_quirofano(
db: Client, quirofano_id: int, data: QuirofanoUpdateRequest, actor: dict | None = None
) -> Cama:
cama = _get_quirofano_or_404(db, quirofano_id)
estado_previo = cama.estado
if data.estado is not None:
nuevo_estado = data.estado.value
if nuevo_estado in (
EstadoCamaEnum.OCUPADA.value,
EstadoCamaEnum.CODIGO_ROJO.value,
EstadoCamaEnum.EN_LIMPIEZA.value,
):
raise HTTPException(
status_code=409,
detail={
"codigo": "CONFLICTO_ESTADO",
"mensaje": f"El estado {nuevo_estado} solo se asigna automáticamente",
},
)
cama.estado = nuevo_estado
if nuevo_estado == EstadoCamaEnum.DISPONIBLE.value and cama.paciente_id:
cama.paciente_id = None
cama.ultimo_movimiento_tipo = None
if data.specialty_id is not None:
cama.specialty_id = data.specialty_id
if data.contraindicaciones_incompatibles is not None:
cama.contraindicaciones_incompatibles = data.contraindicaciones_incompatibles
cama.ultima_actualizacion = datetime.now(timezone.utc)
cama = cama_crud.save(db, cama)
if data.estado is not None and cama.estado != estado_previo:
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_CAMBIO_ESTADO.value,
estado_anterior=estado_previo,
estado_nuevo=cama.estado,
actor=actor,
descripcion=f"Quirófano {cama.numero}: {estado_previo} → {cama.estado}",
hospital_id=cama.hospital_id,
)
return cama
# ─── Reservas de Quirófano ─────────────────────────────────────────────────
def get_reservas(
db: Client,
cama_id: int,
estado: str | None = None,
prioridad: str | None = None,
fecha_desde: str | None = None,
fecha_hasta: str | None = None,
) -> list[ReservaQuirofano]:
cama = _get_cama_or_404(db, cama_id)
if not _is_quirofano(cama):
raise HTTPException(
status_code=409,
detail={"codigo": "CAMA_NO_ES_QUIROFANO", "mensaje": "La cama no es un quirófano"},
)
return reserva_crud.get_all(db, cama_id, estado, prioridad, fecha_desde, fecha_hasta)
def create_reserva(
db: Client, cama_id: int, data: ReservaQuirofanoCreateRequest, actor: dict | None = None
) -> tuple[ReservaQuirofano, bool]:
"""Retorna (reserva, created). created=False si ya existía (idempotencia)."""
cama = _get_cama_or_404(db, cama_id)
if not _is_quirofano(cama):
raise HTTPException(
status_code=409,
detail={"codigo": "CAMA_NO_ES_QUIROFANO", "mensaje": "La cama no es un quirófano"},
)
if cama.estado in (EstadoCamaEnum.FUERA_DE_SERVICIO.value, EstadoCamaEnum.BAJA_PERMANENTE.value):
raise HTTPException(
status_code=409,
detail={"codigo": "CAMA_NO_DISPONIBLE", "mensaje": f"La cama está {cama.estado}"},
)
if data.prioridad.value == "URGENTE":
raise HTTPException(
status_code=422,
detail={
"codigo": "PRIORIDAD_URGENTE_NO_PERMITIDA",
"mensaje": "La prioridad URGENTE no puede asignarse desde este endpoint",
},
)
existing = reserva_crud.get_activa_por_turno(db, data.turno_id)
if existing:
return existing, False
solapadas = reserva_crud.get_superpuestas(db, cama_id, data.fecha_hora_inicio, data.fecha_hora_fin_estimada)
if solapadas:
raise HTTPException(
status_code=409,
detail={
"codigo": "RESERVA_SUPERPUESTA",
"mensaje": "El quirófano ya tiene una reserva activa en ese horario",
},
)
reserva = reserva_crud.create_programada(db, cama_id, data)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
entidad_id=reserva.id,
cama_id=cama_id,
evento=TipoEventoAuditoriaEnum.RESERVA_CREADA.value,
estado_nuevo=reserva.estado,
paciente_id=reserva.paciente_id,
actor=actor,
descripcion=f"Reserva programada en quirófano {cama_id}",
detalle={"turno_id": reserva.turno_id, "prioridad": reserva.prioridad},
hospital_id=cama.hospital_id,
)
return reserva, True
def create_reserva_auto(
db: Client, data: ReservaProgramadaAutoRequest, actor: dict | None = None
) -> tuple[ReservaQuirofano, bool]:
"""
Crea una reserva programada eligiendo automáticamente el quirófano disponible.
M6 busca el primer quirófano libre en el horario solicitado dentro del hospital,
con preferencia por la especialidad indicada si se provee.
Retorna (reserva, created). created=False si ya existía (idempotencia por turno_id).
"""
if data.prioridad.value == "URGENTE":
raise HTTPException(
status_code=422,
detail={
"codigo": "PRIORIDAD_URGENTE_NO_PERMITIDA",
"mensaje": "La prioridad URGENTE no puede asignarse desde este endpoint",
},
)
existing = reserva_crud.get_activa_por_turno(db, data.turno_id)
if existing:
return existing, False
quirofanos = cama_crud.get_quirofanos(
db,
hospital_id=data.hospital_id,
exclude_estados=["FUERA_DE_SERVICIO", "BAJA_PERMANENTE", "EN_LIMPIEZA"],
)
if not quirofanos:
raise HTTPException(
status_code=409,
detail={
"codigo": "SIN_QUIROFANO_COMPATIBLE",
"mensaje": "No hay quirófanos operables para el hospital indicado",
},
)
def _orden_quirofano(q: Cama) -> int:
if data.specialty_id is not None and q.specialty_id == data.specialty_id:
return 0
return 1
candidatos = sorted(quirofanos, key=_orden_quirofano)
for quirofano in candidatos:
solapadas = reserva_crud.get_superpuestas(
db, quirofano.id, data.fecha_hora_inicio, data.fecha_hora_fin_estimada
)
if not solapadas:
create_data = ReservaQuirofanoCreateRequest(
turno_id=data.turno_id,
paciente_id=data.paciente_id,
medico_cirujano_id=data.medico_cirujano_id,
fecha_hora_inicio=data.fecha_hora_inicio,
fecha_hora_fin_estimada=data.fecha_hora_fin_estimada,
prioridad=data.prioridad,
observaciones=data.observaciones,
)
reserva = reserva_crud.create_programada(db, quirofano.id, create_data)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
entidad_id=reserva.id,
cama_id=quirofano.id,
evento=TipoEventoAuditoriaEnum.RESERVA_CREADA.value,
estado_nuevo=reserva.estado,
paciente_id=reserva.paciente_id,
actor=actor,
descripcion=f"Reserva programada asignada automáticamente a quirófano {quirofano.id}",
detalle={"turno_id": reserva.turno_id, "prioridad": reserva.prioridad},
hospital_id=quirofano.hospital_id,
)
return reserva, True
raise HTTPException(
status_code=409,
detail={
"codigo": "SIN_QUIROFANO_DISPONIBLE",
"mensaje": "No hay quirófanos disponibles en el horario solicitado",
},
)
def get_reserva(db: Client, cama_id: int, reserva_id: int) -> ReservaQuirofano:
_get_cama_or_404(db, cama_id)
r = reserva_crud.get_by_cama_and_id(db, cama_id, reserva_id)
if not r:
raise HTTPException(status_code=404, detail=_ERR_RESERVA_NOT_FOUND)
return r
def update_reserva_estado(
db: Client, cama_id: int, reserva_id: int, data: ReservaEstadoUpdateRequest,
actor: dict | None = None,
) -> ReservaQuirofano:
reserva = get_reserva(db, cama_id, reserva_id)
cama = _get_cama_or_404(db, cama_id)
reserva_estado_previo = reserva.estado
cama_estado_previo = cama.estado
TRANSICIONES_VALIDAS = {
EstadoReservaEnum.RESERVADA.value: [EstadoReservaEnum.EN_CURSO.value, EstadoReservaEnum.CANCELADA.value],
EstadoReservaEnum.EN_CURSO.value: [EstadoReservaEnum.COMPLETADA.value],
}
permitidas = TRANSICIONES_VALIDAS.get(reserva.estado, [])
nuevo = data.estado.value
if nuevo not in permitidas:
raise HTTPException(
status_code=409,
detail={
"codigo": "CONFLICTO_ESTADO",
"mensaje": f"Transición inválida: {reserva.estado} → {nuevo}",
},
)
reserva.estado = nuevo
if data.observaciones:
reserva.observaciones = data.observaciones
if nuevo == EstadoReservaEnum.EN_CURSO.value:
cama.estado = EstadoCamaEnum.OCUPADA.value
cama.paciente_id = reserva.paciente_id
elif nuevo == EstadoReservaEnum.COMPLETADA.value:
cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
cama.ultimo_movimiento_tipo = "ALTA"
cama.ultima_actualizacion = datetime.now(timezone.utc)
cama_crud.save(db, cama)
reserva = reserva_crud.save(db, reserva)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
entidad_id=reserva.id,
cama_id=cama_id,
evento=TipoEventoAuditoriaEnum.RESERVA_CAMBIO_ESTADO.value,
estado_anterior=reserva_estado_previo,
estado_nuevo=reserva.estado,
paciente_id=reserva.paciente_id,
actor=actor,
descripcion=f"Reserva {reserva.id}: {reserva_estado_previo} → {reserva.estado}",
hospital_id=cama.hospital_id,
)
if cama.estado != cama_estado_previo:
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.CAMA.value,
entidad_id=cama.id,
cama_id=cama.id,
evento=TipoEventoAuditoriaEnum.CAMA_CAMBIO_ESTADO.value,
estado_anterior=cama_estado_previo,
estado_nuevo=cama.estado,
paciente_id=cama.paciente_id,
actor=actor,
descripcion=f"Cama {cama.numero}: {cama_estado_previo} → {cama.estado} (reserva {reserva.id})",
hospital_id=cama.hospital_id,
)
return reserva
def procesar_transiciones_automaticas(db: Client) -> dict:
"""
Avanza automáticamente el estado de las reservas de quirófano según su horario:
`RESERVADA → EN_CURSO` al llegar `fecha_hora_inicio`, `EN_CURSO → COMPLETADA` al
llegar `fecha_hora_fin_estimada`. Pensado para dispararse desde un tick externo
(`app/routers/internal.py`), no desde un scheduler en memoria — ver `M6_DISEÑO.md`
§5.4 para el porqué.
Reusa `update_reserva_estado` tal cual: mismos side-effects que la transición manual
(cama a OCUPADA/EN_LIMPIEZA, auditoría). `actor=None` cae en el default ya existente
de `auditoria_crud.registrar` (rol SISTEMA, sin usuario humano detrás).
Que el filtro de origen (`reserva_crud.get_pendientes_de_inicio`) sea `estado=
RESERVADA` ya resuelve "si no se canceló, arranca sola": una reserva `CANCELADA`
nunca es candidata. Y como una reserva ya transicionada deja de matchear el filtro,
reintentar este tick (por ejemplo si el cron externo se solapa) es idempotente.
"""
ahora = datetime.now(timezone.utc)
iniciadas = [
update_reserva_estado(
db, r.cama_id, r.id, ReservaEstadoUpdateRequest(estado=EstadoReservaEnum.EN_CURSO), actor=None,
)
for r in reserva_crud.get_pendientes_de_inicio(db, ahora)
]
completadas = [
update_reserva_estado(
db, r.cama_id, r.id, ReservaEstadoUpdateRequest(estado=EstadoReservaEnum.COMPLETADA), actor=None,
)
for r in reserva_crud.get_pendientes_de_fin(db, ahora)
]
return {"iniciadas": len(iniciadas), "completadas": len(completadas)}
def get_disponibilidad_quirofanos(
db: Client,
desde: datetime,
hasta: datetime,
hospital_id: str | None = None,
specialty_id: int | None = None,
) -> list[dict]:
quirofanos = cama_crud.get_quirofanos(db, hospital_id, specialty_id)
result = []
for q_cama in quirofanos:
reservas_en_rango = reserva_crud.get_superpuestas(db, q_cama.id, desde, hasta)
result.append({
"cama_id": q_cama.id,
"numero": q_cama.numero,
"piso": q_cama.piso,
"hospital_id": q_cama.hospital_id,
"estado": q_cama.estado,
"specialty_id": q_cama.specialty_id,
"reservas_en_rango": reservas_en_rango,
})
return result
def _es_bloqueante(r: ReservaQuirofano) -> bool:
"""Una reserva EN_CURSO o URGENTE nunca se desplaza: define cuándo se libera
de verdad el quirófano (o directamente no compite, si también es urgente)."""
return r.estado == "EN_CURSO" or r.prioridad == "URGENTE"
def _earliest_start(
db: Client, cama_id: int, no_antes_de: datetime, duracion: timedelta
) -> tuple[datetime, list[ReservaQuirofano]]:
"""
Inicio más temprano factible para una cirugía de `duracion` en el quirófano
`cama_id`, no antes de `no_antes_de` ("ASAP"). Devuelve (inicio, desplazables):
`desplazables` son las reservas RESERVADA no-urgentes que quedan dentro de
`[inicio, inicio+duracion)` y que habría que reprogramar para asignar ahí.
Sweep: arranca en `no_antes_de` y, mientras el hueco elegido choque con una
reserva bloqueante (EN_CURSO o URGENTE — nunca se desplazan), lo empuja hasta
que esa bloqueante libera el quirófano. Como una reserva empujada puede topar
con la siguiente, se repite hasta que ninguna bloqueante solape más.
"""
futuras = reserva_crud.get_futuras(db, cama_id, no_antes_de)
inicio = no_antes_de
fin = inicio + duracion
changed = True
while changed:
changed = False
for r in futuras:
if _es_bloqueante(r) and r.fecha_hora_inicio < fin and r.fecha_hora_fin_estimada > inicio:
inicio = r.fecha_hora_fin_estimada
fin = inicio + duracion
changed = True
desplazables = [
r for r in futuras
if not _es_bloqueante(r) and r.fecha_hora_inicio < fin and r.fecha_hora_fin_estimada > inicio
]
return inicio, desplazables
def reprogramar(db: Client, reserva: ReservaQuirofano, no_antes_de: datetime, motivo: str) -> ReservaQuirofano:
"""
Reubica `reserva` en el próximo hueco libre (>= su duración original) a partir
de `no_antes_de`, en el mismo quirófano, y reprograma el turno en M2 si tiene uno.
Seam mínimo: garantiza que la reserva no quede duplicada de horario con otra,
pero no hace nada más inteligente que "empujarla" hasta el próximo hueco.
TODO (algoritmo `reprogramar()` completo, tarea siguiente): evaluar mover a otro
quirófano compatible si el hueco en este es demasiado tardío, y cascadear el
desplazamiento (si el hueco elegido choca con otra reserva de menor prioridad,
desplazar a esa en vez de simplemente seguir empujando `reserva`).
"""
duracion = reserva.fecha_hora_fin_estimada - reserva.fecha_hora_inicio
inicio = no_antes_de
while True:
solapadas = reserva_crud.get_superpuestas(
db, reserva.cama_id, inicio, inicio + duracion, exclude_id=reserva.id
)
if not solapadas:
break
inicio = max(r.fecha_hora_fin_estimada for r in solapadas)
reserva.fecha_hora_inicio = inicio
reserva.fecha_hora_fin_estimada = inicio + duracion
reserva.observaciones = (
f"{reserva.observaciones} | {motivo}" if reserva.observaciones else motivo
)
if reserva.turno_id:
turnos.reschedule_turno(
turno_id=reserva.turno_id,
starts_at=reserva.fecha_hora_inicio,
ends_at=reserva.fecha_hora_fin_estimada,
)
return reserva_crud.save(db, reserva)
def crear_reserva_urgente(
db: Client, data: CirugiaUrgenteWebhook
) -> tuple[ReservaQuirofano, list[ReservaQuirofano], bool]:
"""
Crea una reserva urgente (EMERGENCIA, prioridad URGENTE) lo antes posible.
Algoritmo ASAP: `data.fecha_hora_inicio` se interpreta como "no antes de" y
`data.fecha_hora_fin_estimada - data.fecha_hora_inicio` como la duración de la
cirugía. Para cada quirófano compatible (mismo hospital, operable) se calcula
el inicio más temprano factible (`_earliest_start`); se elige el mínimo global.
Si ese inicio coincide con "no antes de", el quirófano estaba libre. Si no,
las reservas programadas (no urgentes) que quedan en el medio se reprograman
(`reprogramar`), nunca se cancelan. Las reservas EN_CURSO o ya URGENTE jamás
se desplazan.
Retorna (reserva_urgente, reservas_desplazadas, created). `created=False` es
el caso idempotente (misma `solicitud_urgencia_hce_id` ya procesada).
"""
existing = reserva_crud.get_by_urgencia_hce_id(db, data.solicitud_urgencia_hce_id)
if existing:
return existing, [], False
duracion = data.fecha_hora_fin_estimada - data.fecha_hora_inicio
no_antes_de = data.fecha_hora_inicio
quirofanos = cama_crud.get_quirofanos(
db,
hospital_id=data.hospital_id,
exclude_estados=["FUERA_DE_SERVICIO", "BAJA_PERMANENTE", "EN_LIMPIEZA"],
)
if not quirofanos:
raise HTTPException(
status_code=409,
detail={
"codigo": "SIN_QUIROFANO_COMPATIBLE",
"mensaje": "No hay quirófanos operables para el hospital indicado",
},
)
candidatos = [(q, *_earliest_start(db, q.id, no_antes_de, duracion)) for q in quirofanos]
def _orden(candidato: tuple[Cama, datetime, list[ReservaQuirofano]]):
q, inicio, _ = candidato
specialty_match = 0 if (data.specialty_id is not None and q.specialty_id == data.specialty_id) else 1
return (inicio, specialty_match, q.id)
quirofano, inicio_elegido, desplazables = min(candidatos, key=_orden)
data_ajustada = data.model_copy(
update={
"fecha_hora_inicio": inicio_elegido,
"fecha_hora_fin_estimada": inicio_elegido + duracion,
}
)
reserva_urgente = reserva_crud.create_urgente(db, quirofano.id, data_ajustada)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
entidad_id=reserva_urgente.id,
cama_id=quirofano.id,
evento=TipoEventoAuditoriaEnum.RESERVA_URGENTE.value,
estado_nuevo=reserva_urgente.estado,
paciente_id=reserva_urgente.paciente_id,
origen=OrigenAuditoriaEnum.WEBHOOK.value,
descripcion=f"Reserva urgente creada en quirófano {quirofano.id}",
hospital_id=quirofano.hospital_id,
)
reservas_desplazadas = []
for r in sorted(desplazables, key=lambda r: r.fecha_hora_inicio):
r.desplazada_por_reserva_id = reserva_urgente.id
r = reprogramar(
db, r, no_antes_de=reserva_urgente.fecha_hora_fin_estimada,
motivo=f"Reprogramada por cirugía urgente {reserva_urgente.id}",
)
reservas_desplazadas.append(r)
auditoria_crud.registrar(
db,
entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
entidad_id=r.id,
cama_id=r.cama_id,
evento=TipoEventoAuditoriaEnum.RESERVA_DESPLAZADA.value,
estado_nuevo=r.estado,
paciente_id=r.paciente_id,
origen=OrigenAuditoriaEnum.WEBHOOK.value,
descripcion=f"Reserva {r.id} reprogramada por urgencia {reserva_urgente.id}",
detalle={"desplazada_por_reserva_id": reserva_urgente.id, "turno_id": r.turno_id},
)
return reserva_urgente, reservas_desplazadas, True