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