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