""" 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