Download app/services/solicitud_service.py from Modulo-6/api: direct link, hf CLI and curl.
- Browser
- Download file 22.4 kB
-
https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/services/solicitud_service.py
- Command line
-
hf download hf://spaces/Modulo-6/api/app/services/solicitud_service.py
-
curl -L -o solicitud_service.py https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/services/solicitud_service.py
22.4 kB
| """ | |
| LΓ³gica de negocio para Solicitudes de InternaciΓ³n / Traslado. | |
| """ | |
| from __future__ import annotations | |
| import logging | |
| from datetime import datetime, timezone | |
| from fastapi import HTTPException | |
| from supabase import Client | |
| from app.models.solicitud import Solicitud | |
| from app.models.cama import Cama | |
| from app.models.reserva import ReservaQuirofano | |
| from app.schemas.solicitud import SolicitudHceWebhook, SolicitudResolucionRequest, AltaMedicaWebhook | |
| from app.schemas.enums import EstadoCamaEnum, EstadoReservaEnum | |
| from app.crud import solicitud as solicitud_crud | |
| 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, facturacion | |
| from app.services._common import validar_paciente_o_502 | |
| from app.schemas.enums import ( | |
| EntidadAuditoriaEnum, | |
| TipoEventoAuditoriaEnum, | |
| OrigenAuditoriaEnum, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| _ERR_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Solicitud no encontrada"} | |
| # βββ Helpers βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _parse_solicitud_id(solicitud_id: str) -> int: | |
| try: | |
| return int(solicitud_id.split("-")[-1]) | |
| except (ValueError, IndexError): | |
| raise HTTPException( | |
| status_code=400, | |
| detail={"codigo": "ERROR_VALIDACION", "mensaje": f"ID de solicitud invΓ‘lido: {solicitud_id}"}, | |
| ) | |
| def _get_solicitud_or_404(db: Client, solicitud_id: str) -> Solicitud: | |
| num_id = _parse_solicitud_id(solicitud_id) | |
| sol = solicitud_crud.get_by_id(db, num_id) | |
| if not sol: | |
| raise HTTPException(status_code=404, detail=_ERR_NOT_FOUND) | |
| return sol | |
| def _get_cama_or_404(db: Client, cama_id: int) -> Cama: | |
| c = cama_crud.get_by_id(db, cama_id) | |
| if not c: | |
| raise HTTPException( | |
| status_code=404, | |
| detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": f"Cama {cama_id} no encontrada"}, | |
| ) | |
| return c | |
| 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", | |
| }, | |
| ) | |
| # βββ Recibir solicitud desde HCE (M1) βββββββββββββββββββββββββββββββββββββ | |
| def recibir_solicitud(db: Client, data: SolicitudHceWebhook) -> Solicitud: | |
| logger.info( | |
| "Recibiendo solicitud HCE β solicitud_hce_id=%s tipo=%s paciente_id=%s", | |
| data.solicitud_hce_id, data.tipo, data.paciente_id, | |
| ) | |
| existing = solicitud_crud.get_by_hce_id(db, data.solicitud_hce_id) | |
| if existing: | |
| logger.info("Solicitud duplicada (idempotente) β solicitud_hce_id=%s id=%s", data.solicitud_hce_id, existing.solicitud_id) | |
| return existing | |
| sol = solicitud_crud.create(db, data) | |
| logger.info("Solicitud creada β id=%s tipo=%s paciente_id=%s", sol.solicitud_id, sol.tipo, sol.paciente_id) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.SOLICITUD.value, | |
| entidad_id=sol.solicitud_id, | |
| cama_id=sol.cama_solicitada_id, | |
| evento=TipoEventoAuditoriaEnum.SOLICITUD_RECIBIDA.value, | |
| estado_nuevo=sol.estado, | |
| paciente_id=sol.paciente_id, | |
| origen=OrigenAuditoriaEnum.WEBHOOK.value, | |
| descripcion=f"Solicitud {sol.solicitud_id} ({sol.tipo}) recibida desde HCE", | |
| detalle={"solicitud_hce_id": sol.solicitud_hce_id, "tipo": sol.tipo}, | |
| hospital_id=sol.hospital_id, | |
| ) | |
| return sol | |
| # βββ Listar / obtener solicitudes ββββββββββββββββββββββββββββββββββββββββββ | |
| def get_solicitudes( | |
| db: Client, | |
| estado: str | None = None, | |
| tipo: str | None = None, | |
| hospital_id: str | None = None, | |
| ) -> list[Solicitud]: | |
| return solicitud_crud.get_all(db, estado, tipo, hospital_id) | |
| def get_solicitud(db: Client, solicitud_id: str) -> Solicitud: | |
| return _get_solicitud_or_404(db, solicitud_id) | |
| # βββ Resolver solicitud ββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def resolver_solicitud( | |
| db: Client, | |
| solicitud_id: str, | |
| data: SolicitudResolucionRequest, | |
| resuelto_por: int, | |
| actor: dict | None = None, | |
| ) -> Solicitud: | |
| logger.info( | |
| "Resolviendo solicitud id=%s accion=%s resuelto_por=%s", | |
| solicitud_id, data.accion, resuelto_por, | |
| ) | |
| sol = _get_solicitud_or_404(db, solicitud_id) | |
| if sol.estado != "PENDIENTE": | |
| logger.warning( | |
| "Solicitud id=%s no resoluble β estado_actual=%s accion_intentada=%s", | |
| solicitud_id, sol.estado, data.accion, | |
| ) | |
| raise HTTPException( | |
| status_code=409, | |
| detail={ | |
| "codigo": "SOLICITUD_YA_RESUELTA", | |
| "mensaje": "La solicitud ya fue resuelta", | |
| "detalle": f"La solicitud {solicitud_id} fue {sol.estado}", | |
| }, | |
| ) | |
| accion = data.accion.value | |
| logger.info("Solicitud id=%s en estado PENDIENTE β procesando accion=%s", solicitud_id, accion) | |
| if accion == "RECHAZAR": | |
| _rechazar(db, sol, data.motivo, resuelto_por, actor) | |
| elif accion in ("APROBAR", "APROBAR_CON_CAMBIO"): | |
| cama_id = data.cama_asignada_id if accion == "APROBAR_CON_CAMBIO" else sol.cama_solicitada_id | |
| if cama_id is None and sol.tipo == "INTERNACION": | |
| raise HTTPException( | |
| status_code=400, | |
| detail={"codigo": "ERROR_VALIDACION", "mensaje": "Se requiere cama_asignada_id"}, | |
| ) | |
| # M1 crea el episodio_id al crear la solicitud (no en el alta) β para INTERNACION | |
| # es la ΓΊnica fuente del dato que viaja a M7 en el cierre de facturaciΓ³n, asΓ que | |
| # se exige acΓ‘ en vez de dejar que el evento salga con idEpisodioExterno: null. | |
| if sol.episodio_id is None and sol.tipo == "INTERNACION": | |
| raise HTTPException( | |
| status_code=400, | |
| detail={"codigo": "ERROR_VALIDACION", "mensaje": "La solicitud no tiene episodio_id (requerido para INTERNACION)"}, | |
| ) | |
| if sol.tipo == "INTERNACION": | |
| _aprobar_internacion(db, sol, cama_id, data.motivo, resuelto_por, accion, actor) | |
| else: | |
| _aprobar_traslado(db, sol, cama_id, data.motivo, resuelto_por, accion, actor) | |
| else: | |
| raise HTTPException(status_code=400, detail={"codigo": "ERROR_VALIDACION", "mensaje": "AcciΓ³n invΓ‘lida"}) | |
| return solicitud_crud.save(db, sol) | |
| def _rechazar( | |
| db: Client, sol: Solicitud, motivo: str | None, resuelto_por: int, actor: dict | None = None | |
| ) -> None: | |
| logger.info("Rechazando solicitud id=%s motivo=%s", sol.solicitud_id, motivo) | |
| sol.estado = "RECHAZADA" | |
| sol.accion = "RECHAZAR" | |
| sol.motivo = motivo | |
| sol.resuelto_por = resuelto_por | |
| sol.timestamp_resolucion = datetime.now(timezone.utc) | |
| hce.notify_resultado_solicitud(sol.solicitud_hce_id, "RECHAZADA", motivo) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.SOLICITUD.value, | |
| entidad_id=sol.solicitud_id, | |
| cama_id=sol.cama_solicitada_id, | |
| evento=TipoEventoAuditoriaEnum.SOLICITUD_RECHAZADA.value, | |
| estado_anterior="PENDIENTE", | |
| estado_nuevo=sol.estado, | |
| paciente_id=sol.paciente_id, | |
| actor=actor, | |
| descripcion=f"Solicitud {sol.solicitud_id} rechazada", | |
| detalle={"motivo": motivo}, | |
| hospital_id=sol.hospital_id, | |
| ) | |
| def _aprobar_internacion( | |
| db: Client, sol: Solicitud, cama_id: int, motivo: str | None, resuelto_por: int, | |
| accion: str, actor: dict | None = None, | |
| ) -> None: | |
| logger.info( | |
| "Aprobando internaciΓ³n β solicitud_id=%s paciente_id=%s cama_id=%s", | |
| sol.solicitud_id, sol.paciente_id, cama_id, | |
| ) | |
| validar_paciente_o_502(sol.paciente_id) | |
| cama = _get_cama_or_404(db, cama_id) | |
| if cama.estado != EstadoCamaEnum.DISPONIBLE.value: | |
| logger.warning( | |
| "Cama id=%s no disponible para internaciΓ³n β estado_actual=%s", | |
| cama_id, cama.estado, | |
| ) | |
| raise HTTPException( | |
| status_code=409, | |
| detail={"codigo": "CAMA_NO_DISPONIBLE", "mensaje": f"La cama {cama_id} no estΓ‘ disponible"}, | |
| ) | |
| _verificar_contraindicaciones(sol.paciente_id, cama) | |
| cama.estado = EstadoCamaEnum.OCUPADA.value | |
| cama.paciente_id = sol.paciente_id | |
| # Datos del episodio en curso (ver app/models/cama.py) β necesarios mΓ‘s adelante | |
| # para el payload rico que pide M7 al cerrarse la internaciΓ³n (notify_cama_lista). | |
| cama.solicitud_hce_id = sol.solicitud_hce_id | |
| cama.fecha_ingreso = datetime.now(timezone.utc) | |
| # El episodio lo crea M1 al crear la solicitud (no en el alta) β se arrastra desde acΓ‘ | |
| # hasta que la cama se libere (ver `cama_service.update_cama`). | |
| cama.episodio_id = sol.episodio_id | |
| cama.ultima_actualizacion = datetime.now(timezone.utc) | |
| cama_crud.save(db, cama) | |
| sol.estado = "APROBADA" | |
| sol.accion = accion | |
| sol.motivo = motivo | |
| sol.cama_asignada_id = cama_id | |
| sol.resuelto_por = resuelto_por | |
| sol.timestamp_resolucion = datetime.now(timezone.utc) | |
| hce.notify_movimiento(cama, sol.paciente_id, actor) | |
| hce.notify_resultado_solicitud(sol.solicitud_hce_id, "APROBADA") | |
| monitoreo.notify_alta(sol.paciente_id, cama_id) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.SOLICITUD.value, | |
| entidad_id=sol.solicitud_id, | |
| cama_id=cama_id, | |
| evento=TipoEventoAuditoriaEnum.SOLICITUD_APROBADA.value, | |
| estado_anterior="PENDIENTE", | |
| estado_nuevo=sol.estado, | |
| paciente_id=sol.paciente_id, | |
| actor=actor, | |
| descripcion=f"Solicitud {sol.solicitud_id} aprobada ({accion}) β internaciΓ³n", | |
| detalle={"accion": accion, "cama_asignada_id": cama_id}, | |
| hospital_id=sol.hospital_id, | |
| ) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.CAMA.value, | |
| entidad_id=cama_id, | |
| cama_id=cama_id, | |
| evento=TipoEventoAuditoriaEnum.CAMA_ASIGNADA.value, | |
| estado_anterior=EstadoCamaEnum.DISPONIBLE.value, | |
| estado_nuevo=cama.estado, | |
| paciente_id=sol.paciente_id, | |
| actor=actor, | |
| descripcion=f"Paciente {sol.paciente_id} ingresado a la cama {cama_id} (solicitud {sol.solicitud_id})", | |
| hospital_id=cama.hospital_id, | |
| ) | |
| def _aprobar_traslado( | |
| db: Client, sol: Solicitud, cama_destino_id: int | None, motivo: str | None, resuelto_por: int, | |
| accion: str, actor: dict | None = None, | |
| ) -> None: | |
| dest_id = cama_destino_id or sol.cama_destino_solicitada_id | |
| if not dest_id: | |
| raise HTTPException( | |
| status_code=400, | |
| detail={"codigo": "ERROR_VALIDACION", "mensaje": "Se requiere cama destino"}, | |
| ) | |
| validar_paciente_o_502(sol.paciente_id) | |
| cama_destino = _get_cama_or_404(db, dest_id) | |
| if cama_destino.estado != EstadoCamaEnum.DISPONIBLE.value: | |
| raise HTTPException( | |
| status_code=409, | |
| detail={"codigo": "CAMA_NO_DISPONIBLE", "mensaje": f"La cama destino {dest_id} no estΓ‘ disponible"}, | |
| ) | |
| _verificar_contraindicaciones(sol.paciente_id, cama_destino) | |
| origen_en_codigo_rojo = False | |
| if sol.cama_origen_id: | |
| cama_origen = _get_cama_or_404(db, sol.cama_origen_id) | |
| origen_en_codigo_rojo = cama_origen.estado == EstadoCamaEnum.CODIGO_ROJO.value | |
| # El episodio (fecha de ingreso, id de la internaciΓ³n original) es continuo a | |
| # travΓ©s de un traslado β se hereda de la cama origen, no de esta solicitud de | |
| # traslado, para no perder el dato real de cuΓ‘ndo empezΓ³ la internaciΓ³n. | |
| cama_destino.solicitud_hce_id = cama_origen.solicitud_hce_id | |
| cama_destino.fecha_ingreso = cama_origen.fecha_ingreso | |
| # El episodio es del paciente, no de la cama: se hereda igual que solicitud_hce_id/ | |
| # fecha_ingreso. La cama origen lo pierde reciΓ©n cuando se libere de verdad (ver | |
| # `cama_service.update_cama` β no acΓ‘, para no dejarla sin dato mientras estΓ‘ | |
| # EN_LIMPIEZA y todavΓa puede haber consultas en curso sobre ese episodio). | |
| 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) | |
| else: | |
| # Traslado sin cama origen registrada (caso atΓpico) β se trata como un ingreso | |
| # nuevo a los fines del episodio. | |
| cama_destino.solicitud_hce_id = sol.solicitud_hce_id | |
| cama_destino.fecha_ingreso = datetime.now(timezone.utc) | |
| cama_destino.episodio_id = sol.episodio_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 = sol.paciente_id | |
| cama_destino.ultima_actualizacion = datetime.now(timezone.utc) | |
| cama_crud.save(db, cama_destino) | |
| sol.estado = "APROBADA" | |
| sol.accion = accion | |
| sol.motivo = motivo | |
| sol.cama_asignada_id = dest_id | |
| sol.resuelto_por = resuelto_por | |
| sol.timestamp_resolucion = datetime.now(timezone.utc) | |
| hce.notify_movimiento(cama_destino, sol.paciente_id, actor) | |
| hce.notify_resultado_solicitud(sol.solicitud_hce_id, "APROBADA") | |
| monitoreo.notify_baja(sol.paciente_id, sol.cama_origen_id) | |
| monitoreo.notify_alta(sol.paciente_id, dest_id) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.SOLICITUD.value, | |
| entidad_id=sol.solicitud_id, | |
| cama_id=dest_id, | |
| evento=TipoEventoAuditoriaEnum.SOLICITUD_APROBADA.value, | |
| estado_anterior="PENDIENTE", | |
| estado_nuevo=sol.estado, | |
| paciente_id=sol.paciente_id, | |
| actor=actor, | |
| descripcion=f"Solicitud {sol.solicitud_id} aprobada ({accion}) β traslado", | |
| detalle={"accion": accion, "cama_asignada_id": dest_id, "cama_origen_id": sol.cama_origen_id}, | |
| hospital_id=sol.hospital_id, | |
| ) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.CAMA.value, | |
| entidad_id=dest_id, | |
| cama_id=dest_id, | |
| evento=TipoEventoAuditoriaEnum.CAMA_TRASLADO.value, | |
| estado_anterior=EstadoCamaEnum.DISPONIBLE.value, | |
| estado_nuevo=cama_destino.estado, | |
| paciente_id=sol.paciente_id, | |
| actor=actor, | |
| descripcion=f"Paciente {sol.paciente_id} trasladado a la cama {dest_id} (solicitud {sol.solicitud_id})", | |
| detalle={"cama_origen_id": sol.cama_origen_id}, | |
| hospital_id=cama_destino.hospital_id, | |
| ) | |
| # βββ Alta mΓ©dica (desde HCE M1) ββββββββββββββββββββββββββββββββββββββββββββ | |
| def procesar_alta_medica(db: Client, data: AltaMedicaWebhook) -> Cama: | |
| paciente_id = data.paciente_id | |
| cama = cama_crud.get_by_paciente(db, paciente_id, ["OCUPADA", "CODIGO_ROJO"]) | |
| if not cama: | |
| raise HTTPException( | |
| status_code=404, | |
| detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontrΓ³ cama asignada al paciente"}, | |
| ) | |
| # NotificaciΓ³n asincrΓ³nica (fire-and-forget, M6_DISEΓO.md Β§2): M6 informa a M9 que | |
| # el paciente sale de monitoreo, pero que M9 estΓ© caΓdo no debe revertir el alta. | |
| # La notificaciΓ³n real a M7 (CAMA_LISTA) ocurre mΓ‘s adelante, al completar la | |
| # limpieza (cama_service.py), tambiΓ©n fire-and-forget. | |
| monitoreo.notify_baja(paciente_id, cama.id) | |
| estado_previo = cama.estado | |
| cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value | |
| cama.ultimo_movimiento_tipo = "ALTA" | |
| cama.alta_tipo = data.tipo_alta.value | |
| cama.alta_timestamp = data.timestamp | |
| # episodio_id NO se toca acΓ‘: ya viene poblado desde la internaciΓ³n/traslado | |
| # (`_aprobar_internacion`/`_aprobar_traslado`), que es donde M1 lo provee de verdad (al | |
| # crear la solicitud). AltaMedicaWebhook nunca lo tuvo como fuente real β pisarlo acΓ‘ | |
| # con un dato del webhook de alta hacΓa que el evento a M7 saliera con | |
| # idEpisodioExterno: null, porque notify_cama_lista se dispara con la cama ya pisada. | |
| cama.ultima_actualizacion = datetime.now(timezone.utc) | |
| cama_crud.save(db, cama) | |
| # Fire-and-forget: notificaciΓ³n a M7 para cerrar la internaciΓ³n del lado de | |
| # facturaciΓ³n. Se dispara aquΓ (alta mΓ©dica) porque el cierre de facturaciΓ³n | |
| # ocurre con el alta del paciente, no con la limpieza de la cama. cama.episodio_id ya | |
| # trae el valor real (poblado mΓ‘s arriba en la cadena) β no se pisa en este webhook. | |
| facturacion.notify_cama_lista(cama, db) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.CAMA.value, | |
| entidad_id=cama.id, | |
| cama_id=cama.id, | |
| evento=TipoEventoAuditoriaEnum.CAMA_ALTA.value, | |
| estado_anterior=estado_previo, | |
| estado_nuevo=cama.estado, | |
| paciente_id=paciente_id, | |
| origen=OrigenAuditoriaEnum.WEBHOOK.value, | |
| descripcion=f"Alta mΓ©dica del paciente {paciente_id}; cama {cama.numero} en limpieza", | |
| hospital_id=cama.hospital_id, | |
| ) | |
| return cama | |
| # βββ Alertas de emergencia (desde M9) ββββββββββββββββββββββββββββββββββββββ | |
| def procesar_alerta_emergencia(db: Client, paciente_id: int) -> Cama: | |
| cama = cama_crud.get_by_paciente(db, paciente_id, ["OCUPADA"]) | |
| if not cama: | |
| raise HTTPException( | |
| status_code=404, | |
| detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Paciente sin cama asignada"}, | |
| ) | |
| estado_previo = cama.estado | |
| cama.estado = EstadoCamaEnum.CODIGO_ROJO.value | |
| cama.ultima_actualizacion = datetime.now(timezone.utc) | |
| cama_crud.save(db, cama) | |
| hce.notify_evento_episodio(0, "CODIGO_ROJO", f"Alerta de emergencia detectada para paciente {paciente_id}") | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.CAMA.value, | |
| entidad_id=cama.id, | |
| cama_id=cama.id, | |
| evento=TipoEventoAuditoriaEnum.CAMA_CODIGO_ROJO.value, | |
| estado_anterior=estado_previo, | |
| estado_nuevo=cama.estado, | |
| paciente_id=paciente_id, | |
| origen=OrigenAuditoriaEnum.WEBHOOK.value, | |
| descripcion=f"Alerta de emergencia: cama {cama.numero} en CODIGO_ROJO", | |
| hospital_id=cama.hospital_id, | |
| ) | |
| return cama | |
| def procesar_alerta_resuelta(db: Client, paciente_id: int) -> Cama: | |
| cama = cama_crud.get_by_paciente(db, paciente_id, ["CODIGO_ROJO"]) | |
| if not cama: | |
| raise HTTPException( | |
| status_code=404, | |
| detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontrΓ³ cama en CODIGO_ROJO para el paciente"}, | |
| ) | |
| estado_previo = cama.estado | |
| cama.estado = EstadoCamaEnum.OCUPADA.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_ALERTA_RESUELTA.value, | |
| estado_anterior=estado_previo, | |
| estado_nuevo=cama.estado, | |
| paciente_id=paciente_id, | |
| origen=OrigenAuditoriaEnum.WEBHOOK.value, | |
| descripcion=f"Alerta resuelta: cama {cama.numero} vuelve a OCUPADA", | |
| hospital_id=cama.hospital_id, | |
| ) | |
| return cama | |
| # βββ Cancelar reserva por turno (desde M2) βββββββββββββββββββββββββββββββββ | |
| def cancelar_reserva_por_turno(db: Client, turno_id: int, motivo: str) -> ReservaQuirofano: | |
| reserva = reserva_crud.get_by_turno(db, turno_id) | |
| if not reserva: | |
| raise HTTPException( | |
| status_code=404, | |
| detail={ | |
| "codigo": "RESERVA_NO_ENCONTRADA", | |
| "mensaje": f"No existe reserva activa para el turno {turno_id}", | |
| }, | |
| ) | |
| if reserva.estado == EstadoReservaEnum.CANCELADA.value: | |
| return reserva | |
| if reserva.estado in (EstadoReservaEnum.EN_CURSO.value, EstadoReservaEnum.COMPLETADA.value): | |
| raise HTTPException( | |
| status_code=409, | |
| detail={ | |
| "codigo": "RESERVA_NO_CANCELABLE", | |
| "mensaje": "La reserva no puede cancelarse en su estado actual", | |
| "detalle": f"Estado: {reserva.estado}", | |
| }, | |
| ) | |
| estado_previo = reserva.estado | |
| reserva.estado = EstadoReservaEnum.CANCELADA.value | |
| reserva = reserva_crud.save(db, reserva) | |
| auditoria_crud.registrar( | |
| db, | |
| entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value, | |
| entidad_id=reserva.id, | |
| cama_id=reserva.cama_id, | |
| evento=TipoEventoAuditoriaEnum.RESERVA_CANCELADA.value, | |
| estado_anterior=estado_previo, | |
| estado_nuevo=reserva.estado, | |
| paciente_id=reserva.paciente_id, | |
| origen=OrigenAuditoriaEnum.WEBHOOK.value, | |
| descripcion=f"Reserva {reserva.id} cancelada por turno {turno_id}", | |
| detalle={"turno_id": turno_id, "motivo": motivo}, | |
| ) | |
| return reserva | |