Download app/services/cama_service.py from Modulo-6/api: direct link, hf CLI and curl.
- Browser
- Download file 35 kB
-
https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/services/cama_service.py
- Command line
-
hf download hf://spaces/Modulo-6/api/app/services/cama_service.py
-
curl -L -o cama_service.py https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/services/cama_service.py
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 | |