api / app /services /solicitud_service.py
juampisor's picture
Fix alerta roja
c03d875
Raw History Blame Contribute Delete
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