File size: 10,180 Bytes
e6a43c8 624c7c9 01e0bb5 624c7c9 e6a43c8 624c7c9 e6a43c8 624c7c9 e6a43c8 624c7c9 e6a43c8 15c2525 624c7c9 e6a43c8 624c7c9 e6a43c8 624c7c9 58e4c2a e6a43c8 624c7c9 58e4c2a 624c7c9 e6a43c8 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 e6a43c8 58e4c2a e6a43c8 15c2525 e6a43c8 624c7c9 e6a43c8 624c7c9 e6a43c8 624c7c9 e6a43c8 01e0bb5 624c7c9 e6a43c8 01e0bb5 e6a43c8 73c7f92 e6a43c8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | """
M10 Core — integración de autenticación real: canje de ticket SSO y cuenta
de servicio de M6.
La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
`create_access_token`/`decode_token`). El Core se toca en estos puntos:
(a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
(b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7, y
(c) el fallback de roles (`resolve_user_roles`, vía `GET /roles`) cuando el
canje no trae `user.roles[]` poblado — el Core desplegado no siempre lo
puebla, pese a que el schema lo permite. No hay verificación de JWT del Core
por-request: el rol se resuelve una sola vez, en el canje (ver
`app/routers/auth.py`).
"""
import logging
import time
import httpx
from jose import JWTError, jwt
from app.config import settings
logger = logging.getLogger(__name__)
# ─── Canje de ticket SSO ────────────────────────────────────────────────────
class SSOTicketInvalid(Exception):
"""Ticket ausente/inválido/ya usado/expirado (el Core respondió 400/401)."""
class SSOExchangeError(Exception):
"""Fallo al comunicarse con el Core (red, timeout, 5xx, etc.)."""
class CoreTokenInvalid(Exception):
"""El JWT del Core embebido en la sesión de M6 venció o el Core lo rechaza (401)."""
def exchange_sso_ticket(ticket: str) -> dict:
"""
Canjea un ticket SSO de un solo uso contra el Core por `{user, token}`
(`POST /auth/sso-exchange`, `models.AuthResponse`). `user.roles[]` trae
el/los rol(es) del usuario en el Core — de ahí sale la autorización de
M6, sin necesidad de un lookup aparte.
"""
url = f"{settings.m10_core_url}/auth/sso-exchange"
logger.info("Enviando canje SSO al Core — url=%s", url)
try:
r = httpx.post(url, json={"ticket": ticket}, timeout=settings.http_timeout_seconds)
except httpx.HTTPError as e:
logger.error("Error de red al contactar Core para canje SSO: %s", e)
raise SSOExchangeError("No se pudo contactar al Core para el canje SSO") from e
logger.info("Core respondió al canje SSO — status=%d", r.status_code)
if r.status_code == 401:
logger.warning("Core rechazó el ticket SSO (401) — body: %s", r.text[:500])
raise SSOTicketInvalid("Ticket inválido, ya usado o expirado")
if r.status_code == 400:
logger.warning("Core rechazó el request SSO (400) — body: %s", r.text[:500])
raise SSOTicketInvalid("Falta el ticket en el request")
if r.status_code >= 400:
logger.error("Core respondió error %d al canjear ticket SSO — body: %s", r.status_code, r.text[:500])
raise SSOExchangeError(f"El Core respondió {r.status_code} al canjear el ticket SSO")
data = r.json()
core_user = data.get("user") or {}
role_names = [role.get("name") for role in (core_user.get("roles") or []) if role.get("name")]
logger.debug("Respuesta Core SSO — user_id=%s roles=%s", core_user.get("id"), role_names)
return data
def request_sso_ticket(core_token: str) -> dict:
"""
Pide al Core un ticket SSO saliente en nombre del usuario (`POST /auth/sso-ticket`,
`models.SSOTicketResponse` — `{ticket, expires_in}`), usando el JWT del Core que
quedó embebido en la sesión de M6 al canjear (`app/routers/auth.py::sso_exchange`).
Es el lado inverso de `exchange_sso_ticket`: ahí M6 es el módulo destino y recibe un
ticket; acá M6 es el origen y pide uno para que el usuario navegue hacia otro módulo.
"""
url = f"{settings.m10_core_url}/auth/sso-ticket"
headers = {"Authorization": f"Bearer {core_token}"}
try:
r = httpx.post(url, headers=headers, timeout=settings.http_timeout_seconds)
except httpx.HTTPError as e:
raise SSOExchangeError("No se pudo contactar al Core para pedir el ticket SSO") from e
if r.status_code == 401:
raise CoreTokenInvalid("El Core rechazó el core_token embebido en la sesión")
if r.status_code >= 400:
raise SSOExchangeError(f"El Core respondió {r.status_code} al pedir el ticket SSO")
return r.json()
# ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
# Token de la cuenta de servicio de M6 en el Core. Se usa para firmar las
# llamadas salientes a M1/M2/M7/M10 (adjuntado automáticamente por
# `app/integrations/_base.py`), incluidas las disparadas por webhooks
# entrantes donde no hay un usuario humano autenticado.
_service_token_cache: dict = {"token": None, "expires_at": 0.0}
# Margen de expiración: se renueva el token antes de que venza de verdad,
# para no arriesgar un 401 a mitad de una llamada saliente.
_SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS = 30
def get_service_token() -> str | None:
"""
Devuelve un token válido de la cuenta de servicio de M6, refrescándolo si
expiró o no se pidió todavía. `None` si faltan las credenciales de
servicio (`CORE_SERVICE_EMAIL`/`_PASSWORD`) — el llamador debe seguir sin
el header `Authorization` en ese caso.
"""
if not settings.core_service_email or not settings.core_service_password:
logger.warning(
"CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD no están configurados"
)
return None
cached = _service_token_cache["token"]
if cached and time.time() < _service_token_cache["expires_at"]:
return cached
return _login_service_account()
def _login_service_account() -> str | None:
url = f"{settings.m10_core_url}/auth/login"
payload = {"email": settings.core_service_email, "password": settings.core_service_password}
try:
r = httpx.post(url, json=payload, timeout=settings.http_timeout_seconds)
r.raise_for_status()
token = r.json().get("token")
except Exception as e:
logger.warning("No se pudo autenticar la cuenta de servicio de M6 en el Core: %s", e)
return None
if not token:
return None
try:
exp = jwt.get_unverified_claims(token).get("exp")
except JWTError:
exp = None
_service_token_cache["token"] = token
_service_token_cache["expires_at"] = (
exp - _SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS if exp else time.time() + 60
)
return token
# ─── Resolución de rol (fallback: lookup de GET /roles) ────────────────────
# El rol del usuario se intenta primero desde `user.roles[].name` de la
# respuesta de `/auth/sso-exchange` (`models.AuthResponse` → `models.User` →
# `models.Role`, ver `documentation/M10_openapi.yaml`). En la práctica el Core
# desplegado no puebla ese campo en el canje SSO, así que `app/routers/auth.py`
# cae a `resolve_user_roles` cuando viene vacío. Reintroducido — existió antes
# y se había retirado asumiendo (incorrectamente, contra el Core real) que
# `roles[]` siempre venía en el canje.
#
# `GET /users/{id}` sería lo obvio para resolver roles por id de usuario, pero
# exige permiso `users:read` que la cuenta de servicio de M6 no tiene. Tampoco
# hay un endpoint user-id→roles (`/roles/{id}` toma un **role** id;
# `/users/{id}/roles` sólo expone POST/DELETE). Lo único legible por la cuenta
# de servicio es `GET /roles` (permiso `roles:read`), que devuelve cada rol
# con su `users[]` embebido — de ahí se arma un índice `user_id → [roles]`.
_roles_index_cache: dict = {"user_id_to_roles": {}, "fetched_at": 0.0}
def _fetch_roles_index() -> dict[int, list[str]]:
"""Índice `user_id -> [nombres de rol]` armado desde `GET /roles` (paginado
en una sola página grande), autenticado con la cuenta de servicio de M6."""
token = get_service_token()
headers = {"Authorization": f"Bearer {token}"} if token else {}
url = f"{settings.m10_core_url}/roles"
r = httpx.get(
url, headers=headers, params={"pageSize": 200}, timeout=settings.http_timeout_seconds
)
r.raise_for_status()
data = r.json()
index: dict[int, list[str]] = {}
for role in data.get("data", []):
name = role.get("name")
for user in role.get("users") or []:
uid = user.get("id")
if uid is None or name is None:
continue
index.setdefault(uid, []).append(name)
return index
def resolve_user_roles(user_id: int) -> list[str]:
"""
Nombres de rol de Core asignados a `user_id`, vía `GET /roles` (fallback
cuando el canje SSO no trae `user.roles[]`). Sin cache: se llama sólo
cuando falta el dato en el canje, que ya de por sí ocurre una vez por
login — no vale la pena la complejidad de un TTL para esta frecuencia.
Propaga la excepción de red/HTTP al llamador (`app/routers/auth.py`),
que la traduce a `502`.
"""
return _fetch_roles_index().get(user_id, [])
# ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
# Este mapeo es la única fuente de la verdad de qué rol de Core habilita qué
# rol interno de M6; ajustar acá si cambian los nombres en el Core compartido.
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
"admin_internacion": "ADMINISTRATIVO",
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
"app": "ADMINISTRATIVO", # rol de la cuenta de servicio de M6 en el Core
"Medico": "MEDICO",
"limpieza": "LIMPIEZA",
}
# Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
_ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
def map_core_roles_to_internal(role_names: list[str]) -> str | None:
"""
Traduce roles de Core al rol interno de M6, con precedencia si el
usuario tiene más de uno mapeado. `None` si ninguno mapea (sin acceso).
"""
mapped = {CORE_ROLE_TO_INTERNAL[name] for name in role_names if name in CORE_ROLE_TO_INTERNAL}
for rol in _ROLE_PRECEDENCE:
if rol in mapped:
return rol
return None
|