Implementacion core SSO
Browse files- .DS_Store +0 -0
- .claude/.DS_Store +0 -0
- .claude/settings.local.json +0 -29
- .env.example +9 -12
- .gitignore +1 -0
- app/.DS_Store +0 -0
- app/config.py +13 -13
- app/dependencies.py +6 -30
- app/integrations/_base.py +3 -3
- app/integrations/core_auth.py +48 -115
- app/main.py +8 -8
- app/routers/auth.py +68 -0
- app/schemas/auth.py +18 -0
- docs/.DS_Store +0 -0
- docs/superpowers/.DS_Store +0 -0
- documentation/.DS_Store +0 -0
- documentation/M10_SSO_INTEGRATION_GUIDE.md +380 -0
- documentation/M6_AUTH_SSO.md +227 -0
- documentation/M6_DISEÑO.md +16 -8
- documentation/M6_openapi.json +174 -0
- documentation/roles.md +8 -8
- tests/test_core_auth.py +8 -229
- tests/test_sso.py +111 -0
.DS_Store
DELETED
|
Binary file (8.2 kB)
|
|
|
.claude/.DS_Store
DELETED
|
Binary file (6.15 kB)
|
|
|
.claude/settings.local.json
DELETED
|
@@ -1,29 +0,0 @@
|
|
| 1 |
-
{
|
| 2 |
-
"permissions": {
|
| 3 |
-
"allow": [
|
| 4 |
-
"Bash(Get-ChildItem -Recurse \"C:\\\\Users\\\\mateo\\\\OneDrive\\\\Documentos\\\\modulo6\" -Name)",
|
| 5 |
-
"Bash(Get-ChildItem -Path \"c:\\\\Users\\\\mateo\\\\OneDrive\\\\Documentos\\\\Modulo-6-backend\" -Force)",
|
| 6 |
-
"Bash(Select-Object Name, Mode)",
|
| 7 |
-
"Bash(python -m py_compile app/schemas/enums.py app/schemas/cama.py app/crud/solicitud.py app/services/cama_service.py app/services/solicitud_service.py app/integrations/hce.py app/routers/webhooks.py app/main.py)",
|
| 8 |
-
"Bash(python3 -m py_compile app/schemas/enums.py app/schemas/cama.py app/crud/solicitud.py app/services/cama_service.py app/services/solicitud_service.py app/integrations/hce.py app/routers/webhooks.py app/main.py)",
|
| 9 |
-
"Bash(git fetch *)",
|
| 10 |
-
"Bash(git stash *)",
|
| 11 |
-
"Bash(git pull *)",
|
| 12 |
-
"Bash(python3 -m py_compile app/main.py app/crud/solicitud.py app/integrations/hce.py app/routers/webhooks.py app/schemas/cama.py app/schemas/enums.py app/services/cama_service.py app/services/solicitud_service.py)",
|
| 13 |
-
"Bash(docker exec *)",
|
| 14 |
-
"Bash(docker run *)",
|
| 15 |
-
"Bash(xargs cat)",
|
| 16 |
-
"Bash(python3 *)",
|
| 17 |
-
"Bash(pip3 list *)",
|
| 18 |
-
"Bash(/tmp/m6venv/bin/pip install *)",
|
| 19 |
-
"Bash(pip3 install *)",
|
| 20 |
-
"Bash(curl -s -m 20 -o /dev/null -w \"%{http_code}\\\\n\" https://modulo-6-api.hf.space/health)",
|
| 21 |
-
"Bash(curl -s -m 20 \"https://modulo-6-api.hf.space/api/v1/auth/token?usuario=ADMINISTRATIVO&password=x\" -w \"\\\\nHTTP %{http_code}\\\\n\")",
|
| 22 |
-
"Bash(grep -iE '\\\\.\\(sql|md\\)$|schema|migration|seed')",
|
| 23 |
-
"Bash(python *)",
|
| 24 |
-
"Bash(pytest /mnt/mac/Projects/Modulo-6-backend/tests/test_quirofanos.py -v)",
|
| 25 |
-
"Read(//usr/local/bin/**)",
|
| 26 |
-
"Bash(find / -name \"pytest\" -type f)"
|
| 27 |
-
]
|
| 28 |
-
}
|
| 29 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
.env.example
CHANGED
|
@@ -9,21 +9,18 @@ JWT_SECRET=CAMBIAR_POR_SECRET_ALEATORIO_DE_64_CARACTERES
|
|
| 9 |
JWT_ALGORITHM=HS256
|
| 10 |
JWT_EXPIRE_MINUTES=60
|
| 11 |
|
| 12 |
-
# ─── Auth:
|
| 13 |
-
#
|
| 14 |
-
#
|
| 15 |
-
#
|
| 16 |
-
|
| 17 |
-
|
| 18 |
-
|
| 19 |
-
#
|
|
|
|
| 20 |
CORE_SERVICE_EMAIL=
|
| 21 |
CORE_SERVICE_PASSWORD=
|
| 22 |
|
| 23 |
-
# TTL de los caches de integración con Core (segundos)
|
| 24 |
-
JWKS_CACHE_TTL_SECONDS=300
|
| 25 |
-
CORE_ROLES_CACHE_TTL_SECONDS=300
|
| 26 |
-
|
| 27 |
# ─── Entorno ───────────────────────────────────────────────────────────────
|
| 28 |
# Valores válidos: development | staging | production
|
| 29 |
# En 'production', el endpoint /auth/token queda deshabilitado
|
|
|
|
| 9 |
JWT_ALGORITHM=HS256
|
| 10 |
JWT_EXPIRE_MINUTES=60
|
| 11 |
|
| 12 |
+
# ─── Auth: SSO del Core (M10) ───────────────────────────────────────────────
|
| 13 |
+
# La sesión de M6 es siempre un JWT HS256 propio (requiere JWT_SECRET arriba).
|
| 14 |
+
# SSO_ENABLED habilita POST /api/v1/auth/sso-exchange, que canjea un ticket
|
| 15 |
+
# del Core real (requiere M10_CORE_URL) por ese JWT propio, con el rol ya
|
| 16 |
+
# resuelto desde user.roles[] de la respuesta del canje.
|
| 17 |
+
SSO_ENABLED=false
|
| 18 |
+
|
| 19 |
+
# Cuenta de servicio de M6 en el Core: autentica las llamadas salientes a
|
| 20 |
+
# M1/M2/M7/M10.
|
| 21 |
CORE_SERVICE_EMAIL=
|
| 22 |
CORE_SERVICE_PASSWORD=
|
| 23 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 24 |
# ─── Entorno ───────────────────────────────────────────────────────────────
|
| 25 |
# Valores válidos: development | staging | production
|
| 26 |
# En 'production', el endpoint /auth/token queda deshabilitado
|
.gitignore
CHANGED
|
@@ -217,6 +217,7 @@ __marimo__/
|
|
| 217 |
# Streamlit
|
| 218 |
.streamlit/secrets.toml
|
| 219 |
|
|
|
|
| 220 |
|
| 221 |
.claude/
|
| 222 |
.claude-flow/
|
|
|
|
| 217 |
# Streamlit
|
| 218 |
.streamlit/secrets.toml
|
| 219 |
|
| 220 |
+
.DS_Store
|
| 221 |
|
| 222 |
.claude/
|
| 223 |
.claude-flow/
|
app/.DS_Store
DELETED
|
Binary file (6.15 kB)
|
|
|
app/config.py
CHANGED
|
@@ -1,5 +1,3 @@
|
|
| 1 |
-
from typing import Literal
|
| 2 |
-
|
| 3 |
from pydantic_settings import BaseSettings, SettingsConfigDict
|
| 4 |
|
| 5 |
|
|
@@ -19,20 +17,22 @@ class Settings(BaseSettings):
|
|
| 19 |
jwt_algorithm: str = "HS256"
|
| 20 |
jwt_expire_minutes: int = 60
|
| 21 |
|
| 22 |
-
# ─── Auth:
|
| 23 |
-
#
|
| 24 |
-
#
|
| 25 |
-
|
| 26 |
-
|
| 27 |
-
#
|
| 28 |
-
#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 29 |
core_service_email: str = ""
|
| 30 |
core_service_password: str = ""
|
| 31 |
|
| 32 |
-
# TTL de los caches de integración con Core (segundos)
|
| 33 |
-
jwks_cache_ttl_seconds: int = 300
|
| 34 |
-
core_roles_cache_ttl_seconds: int = 300
|
| 35 |
-
|
| 36 |
# Entorno — controla comportamiento de endpoints de desarrollo
|
| 37 |
environment: str = "development"
|
| 38 |
|
|
|
|
|
|
|
|
|
|
| 1 |
from pydantic_settings import BaseSettings, SettingsConfigDict
|
| 2 |
|
| 3 |
|
|
|
|
| 17 |
jwt_algorithm: str = "HS256"
|
| 18 |
jwt_expire_minutes: int = 60
|
| 19 |
|
| 20 |
+
# ─── Auth: SSO del Core (M10) ───────────────────────────────────────────
|
| 21 |
+
# La sesión de M6 es siempre un JWT HS256 propio (jwt_secret). El SSO no
|
| 22 |
+
# cambia esa validación por-request: solo agrega una forma de *adquirir*
|
| 23 |
+
# el token — `POST /auth/sso-exchange` canjea un ticket del Core contra
|
| 24 |
+
# `app.integrations.core_auth.exchange_sso_ticket` y M6 emite su propio
|
| 25 |
+
# JWT con el rol ya resuelto (`app/routers/auth.py`).
|
| 26 |
+
#
|
| 27 |
+
# `sso_enabled=False` (default) 404ea el endpoint de canje — para correr
|
| 28 |
+
# sin depender de que el Core real esté arriba (dev/tests).
|
| 29 |
+
sso_enabled: bool = False
|
| 30 |
+
|
| 31 |
+
# Cuenta de servicio de M6 en el Core: usada para autenticar las
|
| 32 |
+
# llamadas salientes a M1/M2/M7/M10.
|
| 33 |
core_service_email: str = ""
|
| 34 |
core_service_password: str = ""
|
| 35 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 36 |
# Entorno — controla comportamiento de endpoints de desarrollo
|
| 37 |
environment: str = "development"
|
| 38 |
|
app/dependencies.py
CHANGED
|
@@ -60,12 +60,15 @@ _ERROR_403 = {"codigo": "NO_AUTORIZADO", "mensaje": "No tiene permisos para esta
|
|
| 60 |
def get_current_user(
|
| 61 |
credentials: HTTPAuthorizationCredentials | None = Depends(_security),
|
| 62 |
) -> dict:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 63 |
if credentials is None:
|
| 64 |
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
|
| 65 |
|
| 66 |
-
if settings.auth_mode == "core":
|
| 67 |
-
return _get_current_user_core(credentials.credentials)
|
| 68 |
-
|
| 69 |
try:
|
| 70 |
payload = decode_token(credentials.credentials)
|
| 71 |
except ValueError:
|
|
@@ -77,33 +80,6 @@ def get_current_user(
|
|
| 77 |
return payload
|
| 78 |
|
| 79 |
|
| 80 |
-
def _get_current_user_core(token: str) -> dict:
|
| 81 |
-
"""
|
| 82 |
-
Rama `auth_mode="core"`: verifica el JWT del Core vía JWKS, resuelve el
|
| 83 |
-
rol del usuario contra el Core (el token no lo transporta — ver
|
| 84 |
-
`app/integrations/core_auth.py`) y lo traduce al rol interno de M6.
|
| 85 |
-
Devuelve la misma forma que el modo mock (`{"sub", "rol"}`) para que
|
| 86 |
-
`require_roles`, la auditoría y los routers no necesiten distinguir modo.
|
| 87 |
-
"""
|
| 88 |
-
from app.integrations import core_auth
|
| 89 |
-
|
| 90 |
-
try:
|
| 91 |
-
payload = core_auth.verify_core_token(token)
|
| 92 |
-
except ValueError:
|
| 93 |
-
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
|
| 94 |
-
|
| 95 |
-
user_id = payload.get("user_id")
|
| 96 |
-
if user_id is None:
|
| 97 |
-
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
|
| 98 |
-
|
| 99 |
-
role_names = core_auth.resolve_user_roles(user_id)
|
| 100 |
-
rol = core_auth.map_core_roles_to_internal(role_names)
|
| 101 |
-
if rol is None:
|
| 102 |
-
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403)
|
| 103 |
-
|
| 104 |
-
return {"sub": str(user_id), "rol": rol, "core_roles": role_names}
|
| 105 |
-
|
| 106 |
-
|
| 107 |
def require_roles(*roles: str):
|
| 108 |
"""
|
| 109 |
Uso: Depends(require_roles("ADMINISTRATIVO", "MEDICO"))
|
|
|
|
| 60 |
def get_current_user(
|
| 61 |
credentials: HTTPAuthorizationCredentials | None = Depends(_security),
|
| 62 |
) -> dict:
|
| 63 |
+
"""
|
| 64 |
+
Valida la sesión de M6: siempre un JWT HS256 propio (`jwt_secret`),
|
| 65 |
+
emitido al hacer login o al canjear un ticket SSO del Core
|
| 66 |
+
(`app/routers/auth.py`). El rol ya viaja en el token — no hay
|
| 67 |
+
verificación contra el Core ni lookup de roles en cada request.
|
| 68 |
+
"""
|
| 69 |
if credentials is None:
|
| 70 |
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
|
| 71 |
|
|
|
|
|
|
|
|
|
|
| 72 |
try:
|
| 73 |
payload = decode_token(credentials.credentials)
|
| 74 |
except ValueError:
|
|
|
|
| 80 |
return payload
|
| 81 |
|
| 82 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 83 |
def require_roles(*roles: str):
|
| 84 |
"""
|
| 85 |
Uso: Depends(require_roles("ADMINISTRATIVO", "MEDICO"))
|
app/integrations/_base.py
CHANGED
|
@@ -13,9 +13,9 @@ def _headers(token: str | None = None) -> dict:
|
|
| 13 |
h = {"Content-Type": "application/json"}
|
| 14 |
# Si no se pasó un token explícito (ej. propagar el del usuario), usar
|
| 15 |
# la cuenta de servicio de M6 — necesaria para llamadas disparadas por
|
| 16 |
-
# webhooks entrantes, donde no hay usuario humano autenticado.
|
| 17 |
-
#
|
| 18 |
-
#
|
| 19 |
effective_token = token or core_auth.get_service_token()
|
| 20 |
if effective_token:
|
| 21 |
h["Authorization"] = f"Bearer {effective_token}"
|
|
|
|
| 13 |
h = {"Content-Type": "application/json"}
|
| 14 |
# Si no se pasó un token explícito (ej. propagar el del usuario), usar
|
| 15 |
# la cuenta de servicio de M6 — necesaria para llamadas disparadas por
|
| 16 |
+
# webhooks entrantes, donde no hay usuario humano autenticado. Sin
|
| 17 |
+
# CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD configurados, devuelve None y
|
| 18 |
+
# el request sale sin header Authorization.
|
| 19 |
effective_token = token or core_auth.get_service_token()
|
| 20 |
if effective_token:
|
| 21 |
h["Authorization"] = f"Bearer {effective_token}"
|
app/integrations/core_auth.py
CHANGED
|
@@ -1,9 +1,14 @@
|
|
| 1 |
"""
|
| 2 |
-
M10 Core — integración de autenticación real:
|
| 3 |
-
|
| 4 |
-
|
| 5 |
-
|
| 6 |
-
`
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 7 |
"""
|
| 8 |
import logging
|
| 9 |
import time
|
|
@@ -16,72 +21,45 @@ from app.config import settings
|
|
| 16 |
logger = logging.getLogger(__name__)
|
| 17 |
|
| 18 |
|
| 19 |
-
# ───
|
| 20 |
-
|
| 21 |
-
# Cache en memoria del JWKS del Core, indexado por `kid`. Un único proceso
|
| 22 |
-
# uvicorn (igual que el resto de la app, ver M6_DISEÑO §3) — no hay estado
|
| 23 |
-
# compartido entre workers que resolver acá.
|
| 24 |
-
_jwks_cache: dict = {"keys_by_kid": {}, "fetched_at": 0.0}
|
| 25 |
-
|
| 26 |
|
| 27 |
-
def _fetch_jwks() -> dict:
|
| 28 |
-
url = f"{settings.m10_core_url}/.well-known/jwks.json"
|
| 29 |
-
r = httpx.get(url, timeout=settings.http_timeout_seconds)
|
| 30 |
-
r.raise_for_status()
|
| 31 |
-
return r.json()
|
| 32 |
|
|
|
|
|
|
|
| 33 |
|
| 34 |
-
def get_signing_key(kid: str) -> dict:
|
| 35 |
-
"""
|
| 36 |
-
Devuelve la JWK (dict) del Core que matchea el `kid` del header de un
|
| 37 |
-
token. Refresca el cache si expiró (TTL `jwks_cache_ttl_seconds`) o si el
|
| 38 |
-
`kid` pedido no está — cubre la rotación de claves del Core sin reiniciar
|
| 39 |
-
M6.
|
| 40 |
-
"""
|
| 41 |
-
now = time.monotonic()
|
| 42 |
-
stale = (now - _jwks_cache["fetched_at"]) > settings.jwks_cache_ttl_seconds
|
| 43 |
-
if stale or kid not in _jwks_cache["keys_by_kid"]:
|
| 44 |
-
jwks = _fetch_jwks()
|
| 45 |
-
_jwks_cache["keys_by_kid"] = {k["kid"]: k for k in jwks.get("keys", []) if "kid" in k}
|
| 46 |
-
_jwks_cache["fetched_at"] = now
|
| 47 |
|
| 48 |
-
|
| 49 |
-
|
| 50 |
-
raise ValueError(f"No se encontró una clave JWKS del Core con kid={kid!r}")
|
| 51 |
-
return key
|
| 52 |
|
| 53 |
|
| 54 |
-
def
|
| 55 |
"""
|
| 56 |
-
|
| 57 |
-
|
| 58 |
-
|
| 59 |
-
|
| 60 |
-
el token no lleva `iss` ni `aud`, así que no se validan acá — solo firma
|
| 61 |
-
y expiración (`jwt.decode` valida `exp` por default).
|
| 62 |
"""
|
|
|
|
| 63 |
try:
|
| 64 |
-
|
| 65 |
-
except
|
| 66 |
-
raise
|
| 67 |
|
| 68 |
-
|
| 69 |
-
|
| 70 |
-
|
|
|
|
|
|
|
|
|
|
| 71 |
|
| 72 |
-
|
| 73 |
-
try:
|
| 74 |
-
return jwt.decode(token, key, algorithms=[key.get("alg", "RS256")])
|
| 75 |
-
except JWTError as e:
|
| 76 |
-
raise ValueError("Token del Core inválido o expirado") from e
|
| 77 |
|
| 78 |
|
| 79 |
# ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
|
| 80 |
|
| 81 |
-
# Token de la cuenta de servicio de M6 en el Core. Se usa para
|
| 82 |
-
#
|
| 83 |
-
# `app/integrations/_base.py`),
|
| 84 |
-
# (`resolve_user_roles`), incluidas las llamadas disparadas por webhooks
|
| 85 |
# entrantes donde no hay un usuario humano autenticado.
|
| 86 |
_service_token_cache: dict = {"token": None, "expires_at": 0.0}
|
| 87 |
|
|
@@ -92,17 +70,14 @@ _SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS = 30
|
|
| 92 |
|
| 93 |
def get_service_token() -> str | None:
|
| 94 |
"""
|
| 95 |
-
Devuelve un token válido de la cuenta de servicio de M6, refrescándolo
|
| 96 |
-
|
| 97 |
-
|
| 98 |
-
|
| 99 |
-
igual que el comportamiento actual en modo mock.
|
| 100 |
"""
|
| 101 |
-
if settings.auth_mode != "core":
|
| 102 |
-
return None
|
| 103 |
if not settings.core_service_email or not settings.core_service_password:
|
| 104 |
logger.warning(
|
| 105 |
-
"
|
| 106 |
)
|
| 107 |
return None
|
| 108 |
|
|
@@ -139,12 +114,16 @@ def _login_service_account() -> str | None:
|
|
| 139 |
return token
|
| 140 |
|
| 141 |
|
| 142 |
-
# ───
|
| 143 |
|
| 144 |
-
# El
|
| 145 |
-
# `
|
| 146 |
-
#
|
| 147 |
-
#
|
|
|
|
|
|
|
|
|
|
|
|
|
| 148 |
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
|
| 149 |
"admin_internacion": "ADMINISTRATIVO",
|
| 150 |
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
|
|
@@ -155,52 +134,6 @@ CORE_ROLE_TO_INTERNAL: dict[str, str] = {
|
|
| 155 |
# Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
|
| 156 |
_ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
|
| 157 |
|
| 158 |
-
# Índice inverso `user_id -> [nombres de rol]`, cacheado con TTL
|
| 159 |
-
# (`core_roles_cache_ttl_seconds`). Trae el padrón completo en cada refresh
|
| 160 |
-
# porque `GET /roles` es lo único que la cuenta de servicio puede leer hoy
|
| 161 |
-
# (`GET /users/{id}` requiere `users:read`, no disponible — ver S2-B en el
|
| 162 |
-
# plan). Aceptable al tamaño actual del Core compartido; un usuario recién
|
| 163 |
-
# asignado a un rol puede tardar hasta el TTL en reflejarse.
|
| 164 |
-
_roles_index_cache: dict = {"user_id_to_roles": {}, "fetched_at": 0.0}
|
| 165 |
-
|
| 166 |
-
|
| 167 |
-
def _fetch_roles_index() -> dict[int, list[str]]:
|
| 168 |
-
token = get_service_token()
|
| 169 |
-
headers = {"Authorization": f"Bearer {token}"} if token else {}
|
| 170 |
-
url = f"{settings.m10_core_url}/roles"
|
| 171 |
-
r = httpx.get(
|
| 172 |
-
url, headers=headers, params={"pageSize": 200}, timeout=settings.http_timeout_seconds
|
| 173 |
-
)
|
| 174 |
-
r.raise_for_status()
|
| 175 |
-
data = r.json()
|
| 176 |
-
|
| 177 |
-
index: dict[int, list[str]] = {}
|
| 178 |
-
for role in data.get("data", []):
|
| 179 |
-
name = role.get("name")
|
| 180 |
-
for user in role.get("users") or []:
|
| 181 |
-
uid = user.get("id")
|
| 182 |
-
if uid is None or name is None:
|
| 183 |
-
continue
|
| 184 |
-
index.setdefault(uid, []).append(name)
|
| 185 |
-
return index
|
| 186 |
-
|
| 187 |
-
|
| 188 |
-
def resolve_user_roles(user_id: int) -> list[str]:
|
| 189 |
-
"""Nombres de rol de Core asignados a `user_id` (S2-A: vía GET /roles)."""
|
| 190 |
-
now = time.monotonic()
|
| 191 |
-
stale = (now - _roles_index_cache["fetched_at"]) > settings.core_roles_cache_ttl_seconds
|
| 192 |
-
if stale:
|
| 193 |
-
try:
|
| 194 |
-
_roles_index_cache["user_id_to_roles"] = _fetch_roles_index()
|
| 195 |
-
_roles_index_cache["fetched_at"] = now
|
| 196 |
-
except Exception as e:
|
| 197 |
-
logger.warning("No se pudo refrescar el índice de roles del Core: %s", e)
|
| 198 |
-
# Sin índice previo, no hay de dónde resolver — se propaga.
|
| 199 |
-
if not _roles_index_cache["user_id_to_roles"]:
|
| 200 |
-
raise
|
| 201 |
-
|
| 202 |
-
return _roles_index_cache["user_id_to_roles"].get(user_id, [])
|
| 203 |
-
|
| 204 |
|
| 205 |
def map_core_roles_to_internal(role_names: list[str]) -> str | None:
|
| 206 |
"""
|
|
|
|
| 1 |
"""
|
| 2 |
+
M10 Core — integración de autenticación real: canje de ticket SSO y cuenta
|
| 3 |
+
de servicio de M6.
|
| 4 |
+
|
| 5 |
+
La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
|
| 6 |
+
`create_access_token`/`decode_token`). El Core se toca en dos puntos nada
|
| 7 |
+
más: (a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
|
| 8 |
+
y (b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7.
|
| 9 |
+
No hay verificación de JWT del Core por-request ni lookup de roles — el rol
|
| 10 |
+
se resuelve una sola vez, en el canje, a partir de `user.roles[]` (ver
|
| 11 |
+
`app/routers/auth.py`).
|
| 12 |
"""
|
| 13 |
import logging
|
| 14 |
import time
|
|
|
|
| 21 |
logger = logging.getLogger(__name__)
|
| 22 |
|
| 23 |
|
| 24 |
+
# ─── Canje de ticket SSO ────────────────────────────────────────────────────
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 25 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 26 |
|
| 27 |
+
class SSOTicketInvalid(Exception):
|
| 28 |
+
"""Ticket ausente/inválido/ya usado/expirado (el Core respondió 400/401)."""
|
| 29 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 30 |
|
| 31 |
+
class SSOExchangeError(Exception):
|
| 32 |
+
"""Fallo al comunicarse con el Core (red, timeout, 5xx, etc.)."""
|
|
|
|
|
|
|
| 33 |
|
| 34 |
|
| 35 |
+
def exchange_sso_ticket(ticket: str) -> dict:
|
| 36 |
"""
|
| 37 |
+
Canjea un ticket SSO de un solo uso contra el Core por `{user, token}`
|
| 38 |
+
(`POST /auth/sso-exchange`, `models.AuthResponse`). `user.roles[]` trae
|
| 39 |
+
el/los rol(es) del usuario en el Core — de ahí sale la autorización de
|
| 40 |
+
M6, sin necesidad de un lookup aparte.
|
|
|
|
|
|
|
| 41 |
"""
|
| 42 |
+
url = f"{settings.m10_core_url}/auth/sso-exchange"
|
| 43 |
try:
|
| 44 |
+
r = httpx.post(url, json={"ticket": ticket}, timeout=settings.http_timeout_seconds)
|
| 45 |
+
except httpx.HTTPError as e:
|
| 46 |
+
raise SSOExchangeError("No se pudo contactar al Core para el canje SSO") from e
|
| 47 |
|
| 48 |
+
if r.status_code == 401:
|
| 49 |
+
raise SSOTicketInvalid("Ticket inválido, ya usado o expirado")
|
| 50 |
+
if r.status_code == 400:
|
| 51 |
+
raise SSOTicketInvalid("Falta el ticket en el request")
|
| 52 |
+
if r.status_code >= 400:
|
| 53 |
+
raise SSOExchangeError(f"El Core respondió {r.status_code} al canjear el ticket SSO")
|
| 54 |
|
| 55 |
+
return r.json()
|
|
|
|
|
|
|
|
|
|
|
|
|
| 56 |
|
| 57 |
|
| 58 |
# ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
|
| 59 |
|
| 60 |
+
# Token de la cuenta de servicio de M6 en el Core. Se usa para firmar las
|
| 61 |
+
# llamadas salientes a M1/M2/M7/M10 (adjuntado automáticamente por
|
| 62 |
+
# `app/integrations/_base.py`), incluidas las disparadas por webhooks
|
|
|
|
| 63 |
# entrantes donde no hay un usuario humano autenticado.
|
| 64 |
_service_token_cache: dict = {"token": None, "expires_at": 0.0}
|
| 65 |
|
|
|
|
| 70 |
|
| 71 |
def get_service_token() -> str | None:
|
| 72 |
"""
|
| 73 |
+
Devuelve un token válido de la cuenta de servicio de M6, refrescándolo si
|
| 74 |
+
expiró o no se pidió todavía. `None` si faltan las credenciales de
|
| 75 |
+
servicio (`CORE_SERVICE_EMAIL`/`_PASSWORD`) — el llamador debe seguir sin
|
| 76 |
+
el header `Authorization` en ese caso.
|
|
|
|
| 77 |
"""
|
|
|
|
|
|
|
| 78 |
if not settings.core_service_email or not settings.core_service_password:
|
| 79 |
logger.warning(
|
| 80 |
+
"CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD no están configurados"
|
| 81 |
)
|
| 82 |
return None
|
| 83 |
|
|
|
|
| 114 |
return token
|
| 115 |
|
| 116 |
|
| 117 |
+
# ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
|
| 118 |
|
| 119 |
+
# El rol del usuario se obtiene una única vez, en el canje SSO
|
| 120 |
+
# (`user.roles[].name` de la respuesta de `/auth/sso-exchange` —
|
| 121 |
+
# `models.AuthResponse` → `models.User` → `models.Role`, ver
|
| 122 |
+
# `documentation/M10_openapi.yaml`). No hay lookup aparte (`GET /roles`) ni
|
| 123 |
+
# verificación de JWT del Core por-request: la sesión de M6 es siempre el
|
| 124 |
+
# JWT HS256 propio emitido en `app/routers/auth.py`. Este mapeo es la única
|
| 125 |
+
# fuente de la verdad de qué rol de Core habilita qué rol interno de M6;
|
| 126 |
+
# ajustar acá si cambian los nombres en el Core compartido.
|
| 127 |
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
|
| 128 |
"admin_internacion": "ADMINISTRATIVO",
|
| 129 |
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
|
|
|
|
| 134 |
# Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
|
| 135 |
_ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
|
| 136 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 137 |
|
| 138 |
def map_core_roles_to_internal(role_names: list[str]) -> str | None:
|
| 139 |
"""
|
app/main.py
CHANGED
|
@@ -12,7 +12,7 @@ from fastapi.responses import JSONResponse
|
|
| 12 |
from app.config import settings
|
| 13 |
from app.dependencies import create_access_token
|
| 14 |
|
| 15 |
-
from app.routers import camas, quirofanos, solicitudes, webhooks, auditoria
|
| 16 |
from app.routers.webhooks import router_turnos
|
| 17 |
|
| 18 |
logger = logging.getLogger(__name__)
|
|
@@ -56,6 +56,7 @@ app.add_middleware(
|
|
| 56 |
|
| 57 |
PREFIX = "/api/v1"
|
| 58 |
|
|
|
|
| 59 |
app.include_router(camas.router, prefix=PREFIX)
|
| 60 |
app.include_router(quirofanos.router, prefix=PREFIX)
|
| 61 |
app.include_router(solicitudes.router, prefix=PREFIX)
|
|
@@ -75,15 +76,14 @@ app.include_router(auditoria.router, prefix=PREFIX)
|
|
| 75 |
)
|
| 76 |
def get_dev_token(usuario: str, password: str):
|
| 77 |
"""
|
| 78 |
-
Solo habilitado si ENVIRONMENT=development
|
| 79 |
-
Genera un JWT de prueba
|
|
|
|
| 80 |
|
| 81 |
-
|
| 82 |
-
|
| 83 |
-
RS256 vía JWKS que usa `get_current_user` en ese modo. Loguearse contra
|
| 84 |
-
el Core real: `POST /auth/login` en `settings.m10_core_url`.
|
| 85 |
"""
|
| 86 |
-
if settings.environment != "development"
|
| 87 |
return JSONResponse(
|
| 88 |
status_code=404,
|
| 89 |
content={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"},
|
|
|
|
| 12 |
from app.config import settings
|
| 13 |
from app.dependencies import create_access_token
|
| 14 |
|
| 15 |
+
from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
|
| 16 |
from app.routers.webhooks import router_turnos
|
| 17 |
|
| 18 |
logger = logging.getLogger(__name__)
|
|
|
|
| 56 |
|
| 57 |
PREFIX = "/api/v1"
|
| 58 |
|
| 59 |
+
app.include_router(auth.router, prefix=PREFIX)
|
| 60 |
app.include_router(camas.router, prefix=PREFIX)
|
| 61 |
app.include_router(quirofanos.router, prefix=PREFIX)
|
| 62 |
app.include_router(solicitudes.router, prefix=PREFIX)
|
|
|
|
| 76 |
)
|
| 77 |
def get_dev_token(usuario: str, password: str):
|
| 78 |
"""
|
| 79 |
+
Solo habilitado si ENVIRONMENT=development.
|
| 80 |
+
Genera un JWT de prueba (el mismo formato HS256 que emite el canje SSO,
|
| 81 |
+
ver `app/routers/auth.py`). Roles válidos: ADMINISTRATIVO | MEDICO | LIMPIEZA
|
| 82 |
|
| 83 |
+
Alternativa con el Core real (M10): loguearse ahí, obtener un ticket SSO
|
| 84 |
+
(`POST /auth/sso-ticket`) y canjearlo en `POST /api/v1/auth/sso-exchange`.
|
|
|
|
|
|
|
| 85 |
"""
|
| 86 |
+
if settings.environment != "development":
|
| 87 |
return JSONResponse(
|
| 88 |
status_code=404,
|
| 89 |
content={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"},
|
app/routers/auth.py
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
SSO del Core (M10): canje de ticket por una sesión propia de M6.
|
| 3 |
+
|
| 4 |
+
M6 no maneja el callback del browser (`/auth/sso?ticket=…`, responsabilidad
|
| 5 |
+
del frontend) — este router expone solo el canje server-to-server: recibe el
|
| 6 |
+
ticket, lo intercambia contra el Core por `{user, token}` y emite su propio
|
| 7 |
+
JWT HS256 con el rol ya resuelto a partir de `user.roles[]`. Ver
|
| 8 |
+
`app/integrations/core_auth.py` y `documentation/M6_DISEÑO.md` §11.
|
| 9 |
+
"""
|
| 10 |
+
import logging
|
| 11 |
+
|
| 12 |
+
from fastapi import APIRouter, HTTPException, status
|
| 13 |
+
|
| 14 |
+
from app.config import settings
|
| 15 |
+
from app.dependencies import create_access_token
|
| 16 |
+
from app.integrations import core_auth
|
| 17 |
+
from app.schemas.auth import SSOExchangeRequest, SSOExchangeResponse, SSOUser
|
| 18 |
+
|
| 19 |
+
logger = logging.getLogger(__name__)
|
| 20 |
+
|
| 21 |
+
router = APIRouter(prefix="/auth", tags=["Auth"])
|
| 22 |
+
|
| 23 |
+
_ERROR_404 = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"}
|
| 24 |
+
_ERROR_401_TICKET = {"codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado"}
|
| 25 |
+
_ERROR_403_ROL = {"codigo": "NO_AUTORIZADO", "mensaje": "El usuario no tiene un rol habilitado en M6"}
|
| 26 |
+
_ERROR_502 = {"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo canjear el ticket contra el Core (M10)"}
|
| 27 |
+
|
| 28 |
+
|
| 29 |
+
@router.post(
|
| 30 |
+
"/sso-exchange",
|
| 31 |
+
response_model=SSOExchangeResponse,
|
| 32 |
+
summary="Canjear un ticket SSO del Core por una sesión de M6",
|
| 33 |
+
responses={
|
| 34 |
+
401: {"description": "Ticket inválido, ya usado o expirado"},
|
| 35 |
+
403: {"description": "El usuario no tiene un rol habilitado en M6"},
|
| 36 |
+
404: {"description": "SSO no habilitado"},
|
| 37 |
+
502: {"description": "El Core no respondió al canje"},
|
| 38 |
+
},
|
| 39 |
+
)
|
| 40 |
+
def sso_exchange(data: SSOExchangeRequest):
|
| 41 |
+
if not settings.sso_enabled:
|
| 42 |
+
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404)
|
| 43 |
+
|
| 44 |
+
try:
|
| 45 |
+
resp = core_auth.exchange_sso_ticket(data.ticket)
|
| 46 |
+
except core_auth.SSOTicketInvalid:
|
| 47 |
+
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_TICKET)
|
| 48 |
+
except core_auth.SSOExchangeError as e:
|
| 49 |
+
logger.warning("Fallo al canjear ticket SSO contra el Core: %s", e)
|
| 50 |
+
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)
|
| 51 |
+
|
| 52 |
+
core_user = resp.get("user") or {}
|
| 53 |
+
role_names = [r["name"] for r in (core_user.get("roles") or []) if r.get("name")]
|
| 54 |
+
rol = core_auth.map_core_roles_to_internal(role_names)
|
| 55 |
+
if rol is None:
|
| 56 |
+
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403_ROL)
|
| 57 |
+
|
| 58 |
+
token = create_access_token(sub=str(core_user["id"]), rol=rol)
|
| 59 |
+
return SSOExchangeResponse(
|
| 60 |
+
token=token,
|
| 61 |
+
user=SSOUser(
|
| 62 |
+
id=core_user["id"],
|
| 63 |
+
first_name=core_user.get("first_name", ""),
|
| 64 |
+
last_name=core_user.get("last_name", ""),
|
| 65 |
+
email=core_user.get("email", ""),
|
| 66 |
+
),
|
| 67 |
+
rol=rol,
|
| 68 |
+
)
|
app/schemas/auth.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from pydantic import BaseModel, Field
|
| 2 |
+
|
| 3 |
+
|
| 4 |
+
class SSOExchangeRequest(BaseModel):
|
| 5 |
+
ticket: str = Field(..., min_length=1)
|
| 6 |
+
|
| 7 |
+
|
| 8 |
+
class SSOUser(BaseModel):
|
| 9 |
+
id: int
|
| 10 |
+
first_name: str
|
| 11 |
+
last_name: str
|
| 12 |
+
email: str
|
| 13 |
+
|
| 14 |
+
|
| 15 |
+
class SSOExchangeResponse(BaseModel):
|
| 16 |
+
token: str
|
| 17 |
+
user: SSOUser
|
| 18 |
+
rol: str
|
docs/.DS_Store
DELETED
|
Binary file (6.15 kB)
|
|
|
docs/superpowers/.DS_Store
DELETED
|
Binary file (6.15 kB)
|
|
|
documentation/.DS_Store
DELETED
|
Binary file (6.15 kB)
|
|
|
documentation/M10_SSO_INTEGRATION_GUIDE.md
ADDED
|
@@ -0,0 +1,380 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Guía de integración SSO — para módulos de Health Grid
|
| 2 |
+
|
| 3 |
+
Esta guía es para los equipos que implementan **otros módulos** de Health Grid y necesitan que un usuario que ya está logueado en otro módulo (o en el core) **llegue ya autenticado** a su aplicación, aunque estén en **dominios distintos** (no comparten cookies).
|
| 4 |
+
|
| 5 |
+
Sos el **módulo destino**: recibís al usuario por un redirect y tenés que dejarlo logueado en tu app. Esta guía cubre solo tu parte.
|
| 6 |
+
|
| 7 |
+
> **API del core:** `https://api.healthcare.cantero.ar` — emite y valida los JWT.
|
| 8 |
+
> **Ruta de callback del módulo:** `/auth/sso` — el usuario aterriza ahí con el ticket, p. ej.
|
| 9 |
+
> `https://healthgrid.cantero.ar/auth/sso?ticket=…`. Cada módulo se sirve en su propio host;
|
| 10 |
+
> el path `/auth/sso` es la convención común. Los ejemplos usan `healthgrid.cantero.ar`.
|
| 11 |
+
|
| 12 |
+
---
|
| 13 |
+
|
| 14 |
+
## Qué te da el core
|
| 15 |
+
|
| 16 |
+
- Un **JWT firmado con RS256** (válido 24 h) que identifica al usuario y trae sus permisos.
|
| 17 |
+
- La clave pública para validar ese JWT, publicada en
|
| 18 |
+
`https://api.healthcare.cantero.ar/.well-known/jwks.json` (JWKS).
|
| 19 |
+
**No necesitás ninguna clave secreta compartida.**
|
| 20 |
+
|
| 21 |
+
## Qué tenés que construir
|
| 22 |
+
|
| 23 |
+
1. Una ruta de **callback** `/auth/sso` que reciba el redirect con un `ticket`.
|
| 24 |
+
2. Una llamada al core para canjear ese ticket por un JWT (servidor-a-servidor si tenés
|
| 25 |
+
backend; desde el navegador si sos una SPA — ver [Variante SPA](#variante-módulo-spa-sin-backend-angular--react)).
|
| 26 |
+
3. Tu **propia sesión** en tu dominio (cookie / `localStorage`) con ese JWT.
|
| 27 |
+
4. **Validación** del JWT en cada request siguiente, usando el JWKS.
|
| 28 |
+
|
| 29 |
+
---
|
| 30 |
+
|
| 31 |
+
## El flujo, de tu lado
|
| 32 |
+
|
| 33 |
+
```mermaid
|
| 34 |
+
sequenceDiagram
|
| 35 |
+
participant U as Usuario (navegador)
|
| 36 |
+
participant B as Tu backend (módulo)
|
| 37 |
+
participant C as Core API<br/>(api.healthcare.cantero.ar)
|
| 38 |
+
|
| 39 |
+
U->>B: 1) redirect a /auth/sso?ticket=…&redirect=/x
|
| 40 |
+
B->>C: 2) POST /auth/sso-exchange<br/>{ "ticket": "…" }
|
| 41 |
+
C-->>B: { user, token } (JWT)
|
| 42 |
+
B-->>U: 3) set cookie de sesión + redirect
|
| 43 |
+
Note over U: ya logueado en tu módulo
|
| 44 |
+
```
|
| 45 |
+
|
| 46 |
+
1. El navegador llega a tu app con una URL tipo:
|
| 47 |
+
`https://healthgrid.cantero.ar/auth/sso?ticket=<opaco>&redirect=/dashboard`
|
| 48 |
+
2. Tu backend toma el `ticket` y lo **canjea** contra el core (paso servidor-a-servidor;
|
| 49 |
+
el ticket no se vuelve a exponer al navegador).
|
| 50 |
+
3. Recibís `{ user, token }`. Guardás el `token` en tu propia sesión y redirigís al usuario
|
| 51 |
+
a `redirect`.
|
| 52 |
+
|
| 53 |
+
**Importante:** el `ticket` es de **un solo uso** y **expira en ~60 segundos**. Canjealo apenas lo recibís, desde el backend. No lo guardes ni lo reenvíes al frontend.
|
| 54 |
+
|
| 55 |
+
---
|
| 56 |
+
|
| 57 |
+
## Paso a paso
|
| 58 |
+
|
| 59 |
+
### 1) Endpoint de callback + canje del ticket
|
| 60 |
+
|
| 61 |
+
`POST https://api.healthcare.cantero.ar/auth/sso-exchange`
|
| 62 |
+
|
| 63 |
+
Request:
|
| 64 |
+
|
| 65 |
+
```json
|
| 66 |
+
{ "ticket": "9f2c1b7a…e04" }
|
| 67 |
+
```
|
| 68 |
+
|
| 69 |
+
Respuesta `200`:
|
| 70 |
+
|
| 71 |
+
```json
|
| 72 |
+
{
|
| 73 |
+
"user": {
|
| 74 |
+
"id": 42,
|
| 75 |
+
"first_name": "Ana",
|
| 76 |
+
"last_name": "Pérez",
|
| 77 |
+
"email": "ana@example.com"
|
| 78 |
+
},
|
| 79 |
+
"token": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ij…"
|
| 80 |
+
}
|
| 81 |
+
```
|
| 82 |
+
|
| 83 |
+
Errores:
|
| 84 |
+
|
| 85 |
+
| Código | Significado | Qué hacer |
|
| 86 |
+
| ------ | ------------------------------------ | -------------------------------------------------------- |
|
| 87 |
+
| `400` | Falta el `ticket` en el body | Revisar tu request |
|
| 88 |
+
| `401` | Ticket inválido, ya usado o expirado | Redirigir al login; el usuario reintenta desde el origen |
|
| 89 |
+
|
| 90 |
+
### 2) Establecer tu propia sesión
|
| 91 |
+
|
| 92 |
+
El `token` es el JWT del core. Guardalo **en tu dominio** — el core no maneja tu sesión:
|
| 93 |
+
|
| 94 |
+
- **Recomendado:** cookie propia `HttpOnly` + `Secure` + `SameSite=Lax`, con el dominio de tu módulo.
|
| 95 |
+
- Alternativa (SPA): `localStorage` y mandarlo como `Authorization: Bearer <token>` en tus llamadas.
|
| 96 |
+
|
| 97 |
+
Ese JWT dura 24 h. Cuando vence, el usuario tiene que volver a pasar por el SSO (o, si tu módulo también habla con el core, podés usar `POST /auth/refresh` mientras siga vigente).
|
| 98 |
+
|
| 99 |
+
### 3) Validar el JWT en cada request
|
| 100 |
+
|
| 101 |
+
En cada request protegido de tu módulo, validá el JWT **localmente** contra el JWKS del core. No hace falta llamar al core en cada request.
|
| 102 |
+
|
| 103 |
+
Endpoint del JWKS: `GET https://api.healthcare.cantero.ar/.well-known/jwks.json`
|
| 104 |
+
|
| 105 |
+
Pasos:
|
| 106 |
+
|
| 107 |
+
1. Descargá y **cacheá** el JWKS (respetá rotación de claves vía el `kid` del header del
|
| 108 |
+
token).
|
| 109 |
+
2. Verificá la firma con la clave pública correspondiente (**algoritmo RS256, y solo RS256**).
|
| 110 |
+
3. Validá `exp` (expiración).
|
| 111 |
+
4. Leé los claims de negocio (`user_id`, `permissions`).
|
| 112 |
+
|
| 113 |
+
Detalle completo y ejemplos en [`JWKS_VALIDATION.md`](JWKS_VALIDATION.md).
|
| 114 |
+
|
| 115 |
+
---
|
| 116 |
+
|
| 117 |
+
## Estructura del JWT que vas a recibir
|
| 118 |
+
|
| 119 |
+
Header:
|
| 120 |
+
|
| 121 |
+
```json
|
| 122 |
+
{ "alg": "RS256", "typ": "JWT", "kid": "a1b2c3d4e5f6a7b8" }
|
| 123 |
+
```
|
| 124 |
+
|
| 125 |
+
Claims (payload):
|
| 126 |
+
|
| 127 |
+
```json
|
| 128 |
+
{
|
| 129 |
+
"user_id": 42,
|
| 130 |
+
"permissions": ["users:read", "locations:read", "…"],
|
| 131 |
+
"iat": 1751846400,
|
| 132 |
+
"exp": 1751932800
|
| 133 |
+
}
|
| 134 |
+
```
|
| 135 |
+
|
| 136 |
+
- `user_id` — id del usuario en el core.
|
| 137 |
+
- `permissions` — lista plana de permisos (`recurso:accion`). Usala para tu autorización.
|
| 138 |
+
- `exp` — expiración (24 h desde la emisión). **Validala siempre.**
|
| 139 |
+
|
| 140 |
+
> Nota: hoy el token **no** trae `iss`/`aud`. Validá firma + `exp` + los claims de negocio.
|
| 141 |
+
|
| 142 |
+
---
|
| 143 |
+
|
| 144 |
+
## Ejemplos de código
|
| 145 |
+
|
| 146 |
+
### Node.js / Express (canje + validación con JWKS)
|
| 147 |
+
|
| 148 |
+
```js
|
| 149 |
+
import express from "express";
|
| 150 |
+
import fetch from "node-fetch";
|
| 151 |
+
import { createRemoteJWKSet, jwtVerify } from "jose";
|
| 152 |
+
|
| 153 |
+
const CORE = "https://api.healthcare.cantero.ar";
|
| 154 |
+
const JWKS = createRemoteJWKSet(new URL(`${CORE}/.well-known/jwks.json`)); // cachea solo
|
| 155 |
+
|
| 156 |
+
const app = express();
|
| 157 |
+
|
| 158 |
+
// 1) Callback: recibe el ticket y lo canjea
|
| 159 |
+
app.get("/auth/sso", async (req, res) => {
|
| 160 |
+
const { ticket, redirect = "/" } = req.query;
|
| 161 |
+
try {
|
| 162 |
+
const r = await fetch(`${CORE}/auth/sso-exchange`, {
|
| 163 |
+
method: "POST",
|
| 164 |
+
headers: { "Content-Type": "application/json" },
|
| 165 |
+
body: JSON.stringify({ ticket }),
|
| 166 |
+
});
|
| 167 |
+
if (!r.ok) return res.redirect("/login");
|
| 168 |
+
const { token } = await r.json();
|
| 169 |
+
|
| 170 |
+
// 2) Sesión propia, en tu dominio
|
| 171 |
+
res.cookie("session", token, {
|
| 172 |
+
httpOnly: true,
|
| 173 |
+
secure: true,
|
| 174 |
+
sameSite: "lax",
|
| 175 |
+
maxAge: 24 * 3600 * 1000,
|
| 176 |
+
});
|
| 177 |
+
res.redirect(redirect);
|
| 178 |
+
} catch {
|
| 179 |
+
res.redirect("/login");
|
| 180 |
+
}
|
| 181 |
+
});
|
| 182 |
+
|
| 183 |
+
// 3) Middleware: valida el JWT del core en cada request
|
| 184 |
+
async function requireAuth(req, res, next) {
|
| 185 |
+
const token = req.cookies.session;
|
| 186 |
+
if (!token) return res.status(401).json({ error: "no session" });
|
| 187 |
+
try {
|
| 188 |
+
const { payload } = await jwtVerify(token, JWKS, { algorithms: ["RS256"] });
|
| 189 |
+
req.user = { id: payload.user_id, permissions: payload.permissions || [] };
|
| 190 |
+
next();
|
| 191 |
+
} catch {
|
| 192 |
+
res.status(401).json({ error: "invalid token" });
|
| 193 |
+
}
|
| 194 |
+
}
|
| 195 |
+
```
|
| 196 |
+
|
| 197 |
+
### Go / Gin (canje del ticket)
|
| 198 |
+
|
| 199 |
+
```go
|
| 200 |
+
// GET /auth/sso?ticket=…&redirect=…
|
| 201 |
+
const coreBaseURL = "https://api.healthcare.cantero.ar"
|
| 202 |
+
|
| 203 |
+
func SSOCallbackHandler(c *gin.Context) {
|
| 204 |
+
ticket := c.Query("ticket")
|
| 205 |
+
redirect := c.DefaultQuery("redirect", "/")
|
| 206 |
+
|
| 207 |
+
body, _ := json.Marshal(map[string]string{"ticket": ticket})
|
| 208 |
+
client := &http.Client{Timeout: 5 * time.Second}
|
| 209 |
+
resp, err := client.Post(coreBaseURL+"/auth/sso-exchange",
|
| 210 |
+
"application/json", bytes.NewReader(body))
|
| 211 |
+
if err != nil || resp.StatusCode != http.StatusOK {
|
| 212 |
+
c.Redirect(http.StatusFound, "/login")
|
| 213 |
+
return
|
| 214 |
+
}
|
| 215 |
+
defer resp.Body.Close()
|
| 216 |
+
|
| 217 |
+
var out struct{ Token string `json:"token"` }
|
| 218 |
+
json.NewDecoder(resp.Body).Decode(&out)
|
| 219 |
+
|
| 220 |
+
// Cookie de sesión en TU dominio.
|
| 221 |
+
c.SetCookie("session", out.Token, 86400, "/", "healthgrid.cantero.ar", true, true)
|
| 222 |
+
c.Redirect(http.StatusFound, redirect)
|
| 223 |
+
}
|
| 224 |
+
```
|
| 225 |
+
|
| 226 |
+
Para la validación del JWT en Go, ver el ejemplo con `github.com/MicahParks/keyfunc` en
|
| 227 |
+
[`JWKS_VALIDATION.md`](JWKS_VALIDATION.md).
|
| 228 |
+
|
| 229 |
+
### Prueba rápida con curl
|
| 230 |
+
|
| 231 |
+
```bash
|
| 232 |
+
# Canje del ticket (lo que hace tu backend)
|
| 233 |
+
curl -sS -X POST https://api.healthcare.cantero.ar/auth/sso-exchange \
|
| 234 |
+
-H 'Content-Type: application/json' \
|
| 235 |
+
-d '{"ticket":"PEGA_ACA_EL_TICKET"}'
|
| 236 |
+
# → { "user": {...}, "token": "eyJ…" }
|
| 237 |
+
|
| 238 |
+
# El JWKS que usás para validar los JWT
|
| 239 |
+
curl -sS https://api.healthcare.cantero.ar/.well-known/jwks.json
|
| 240 |
+
```
|
| 241 |
+
|
| 242 |
+
---
|
| 243 |
+
|
| 244 |
+
## Variante: módulo SPA sin backend (Angular / React)
|
| 245 |
+
|
| 246 |
+
Si tu módulo es una **SPA sin backend propio** (Angular, React, etc.), no tenés un
|
| 247 |
+
servidor donde hacer el canje back-channel. En ese caso el canje se hace **desde el
|
| 248 |
+
navegador**, directo contra el endpoint público `POST /auth/sso-exchange`.
|
| 249 |
+
|
| 250 |
+
Es un patrón **aceptable** para SPAs porque:
|
| 251 |
+
|
| 252 |
+
- El `ticket` es de **un solo uso** y expira en **~60 s**: aunque quede un instante en la
|
| 253 |
+
URL, es de bajo valor y no se puede reusar.
|
| 254 |
+
- Se canjea **de inmediato** sobre HTTPS por el JWT, que se guarda en tu propio
|
| 255 |
+
almacenamiento (igual que harías tras un login normal).
|
| 256 |
+
- Después de canjear, limpiás el `ticket` de la URL (`replaceState` / `replaceUrl`) para que
|
| 257 |
+
no quede en el historial.
|
| 258 |
+
|
| 259 |
+
> Si tu módulo **sí** tiene backend, preferí el canje servidor-a-servidor de las secciones
|
| 260 |
+
> anteriores: el ticket nunca llega a exponerse al navegador.
|
| 261 |
+
|
| 262 |
+
### El flujo, para una SPA
|
| 263 |
+
|
| 264 |
+
```mermaid
|
| 265 |
+
sequenceDiagram
|
| 266 |
+
participant O as Otro módulo
|
| 267 |
+
participant S as Tu SPA (navegador)
|
| 268 |
+
participant C as Core API<br/>(api.healthcare.cantero.ar)
|
| 269 |
+
|
| 270 |
+
O->>S: 1) redirect a /auth/sso?ticket=…&redirect=/x
|
| 271 |
+
S->>C: 2) POST /auth/sso-exchange<br/>{ "ticket": "…" }
|
| 272 |
+
C-->>S: { user, token } (JWT)
|
| 273 |
+
Note over S: 3) guarda el JWT, limpia la URL<br/>y navega a /x
|
| 274 |
+
```
|
| 275 |
+
|
| 276 |
+
La ruta de callback es una **ruta del router** de tu SPA (`/auth/sso`), no un endpoint de
|
| 277 |
+
servidor. El usuario llega ahí con `?ticket=…&redirect=/ruta-interna`.
|
| 278 |
+
|
| 279 |
+
### Ejemplo: Angular
|
| 280 |
+
|
| 281 |
+
Ruta pública en tu `app.routes.ts`:
|
| 282 |
+
|
| 283 |
+
```ts
|
| 284 |
+
{
|
| 285 |
+
path: 'auth/sso',
|
| 286 |
+
loadComponent: () =>
|
| 287 |
+
import('./features/auth/sso/sso.component').then((m) => m.SsoComponent),
|
| 288 |
+
},
|
| 289 |
+
```
|
| 290 |
+
|
| 291 |
+
Servicio: canje del código por una sesión (reutiliza tu misma lógica de login):
|
| 292 |
+
|
| 293 |
+
```ts
|
| 294 |
+
// AuthService
|
| 295 |
+
establishSessionFromTicket(ticket: string): Observable<SessionUser> {
|
| 296 |
+
return this.http
|
| 297 |
+
.post<ApiAuthResponse>(`${this.baseUrl}/sso-exchange`, { ticket })
|
| 298 |
+
.pipe(
|
| 299 |
+
map((res) => this.persistSession(res)), // guarda el JWT (localStorage/cookie)
|
| 300 |
+
catchError((err) => throwError(() => toError(err))),
|
| 301 |
+
);
|
| 302 |
+
}
|
| 303 |
+
```
|
| 304 |
+
|
| 305 |
+
Componente de callback: lee el `ticket`, lo canjea y navega:
|
| 306 |
+
|
| 307 |
+
```ts
|
| 308 |
+
ngOnInit(): void {
|
| 309 |
+
// Acepta el ticket en query (?ticket=) o en fragment (#ticket=), y un redirect interno.
|
| 310 |
+
const snap = this.route.snapshot;
|
| 311 |
+
const frag = snap.fragment ? new URLSearchParams(snap.fragment) : null;
|
| 312 |
+
const ticket = frag?.get('ticket') ?? snap.queryParamMap.get('ticket');
|
| 313 |
+
const redirect = frag?.get('redirect') ?? snap.queryParamMap.get('redirect');
|
| 314 |
+
|
| 315 |
+
if (!ticket) {
|
| 316 |
+
this.error.set('El enlace de acceso no incluye un ticket SSO.');
|
| 317 |
+
return;
|
| 318 |
+
}
|
| 319 |
+
|
| 320 |
+
this.auth.establishSessionFromTicket(ticket).subscribe({
|
| 321 |
+
next: () => {
|
| 322 |
+
const target = this.safeRedirect(redirect) ?? '/';
|
| 323 |
+
// replaceUrl: el código no queda en el historial de navegación.
|
| 324 |
+
void this.router.navigateByUrl(target, { replaceUrl: true });
|
| 325 |
+
},
|
| 326 |
+
error: (err: Error) => this.error.set(err.message),
|
| 327 |
+
});
|
| 328 |
+
}
|
| 329 |
+
|
| 330 |
+
/** Sólo rutas internas absolutas; descarta URLs externas (open redirect). */
|
| 331 |
+
private safeRedirect(path: string | null): string | null {
|
| 332 |
+
if (!path) return null;
|
| 333 |
+
if (!path.startsWith('/') || path.startsWith('//') || path.startsWith('/\\')) return null;
|
| 334 |
+
return path;
|
| 335 |
+
}
|
| 336 |
+
```
|
| 337 |
+
|
| 338 |
+
El mismo esquema aplica a React: una ruta `/auth/sso` que, al montarse, lee el `ticket`, hace
|
| 339 |
+
el `POST /auth/sso-exchange`, guarda el JWT y hace `navigate(redirect, { replace: true })`.
|
| 340 |
+
|
| 341 |
+
### Consideraciones de seguridad para SPAs
|
| 342 |
+
|
| 343 |
+
- **Canjeá apenas montás la ruta** y limpiá el `ticket` de la URL (`replaceUrl` / `replaceState`).
|
| 344 |
+
- **Validá el `redirect`**: sólo rutas internas absolutas (`/algo`), nunca URLs externas ni
|
| 345 |
+
`//host` (open redirect).
|
| 346 |
+
- El JWT queda en el navegador (localStorage o cookie). Es el mismo modelo de riesgo que tu
|
| 347 |
+
login normal; no lo empeora respecto de lo que ya hacés hoy.
|
| 348 |
+
- Serví tu SPA **siempre por HTTPS**.
|
| 349 |
+
|
| 350 |
+
---
|
| 351 |
+
|
| 352 |
+
## Checklist de implementación
|
| 353 |
+
|
| 354 |
+
- [ ] Ruta de callback (`/auth/sso?ticket=…&redirect=…`) en tu módulo.
|
| 355 |
+
- [ ] Canje del ticket **desde el backend** si tenés uno (server-to-server); si sos una SPA
|
| 356 |
+
sin backend, canjealo desde el navegador (ver [Variante SPA](#variante-módulo-spa-sin-backend-angular--react)).
|
| 357 |
+
- [ ] Canjear **apenas** llega (el ticket expira en ~60 s y es de un solo uso).
|
| 358 |
+
- [ ] Guardar el JWT en tu propia sesión (cookie `HttpOnly`+`Secure` recomendado).
|
| 359 |
+
- [ ] Validar el `redirect` para evitar **open redirect** (permití solo rutas internas / una
|
| 360 |
+
allowlist).
|
| 361 |
+
- [ ] Cachear el JWKS y validar firma **RS256** + `exp` en cada request.
|
| 362 |
+
- [ ] Manejar `401` del canje redirigiendo al login.
|
| 363 |
+
- [ ] Usar **HTTPS** en tu callback (el JWT viaja en la respuesta del canje).
|
| 364 |
+
|
| 365 |
+
## Preguntas frecuentes
|
| 366 |
+
|
| 367 |
+
**¿Necesito una clave secreta del core?**
|
| 368 |
+
No. Validás los JWT con la clave **pública** del JWKS. Nada secreto se comparte.
|
| 369 |
+
|
| 370 |
+
**¿Qué pasa si el ticket expiró o ya se usó?**
|
| 371 |
+
El canje devuelve `401`. Mandá al usuario al login; reinicia el flujo desde el módulo origen y obtiene un ticket nuevo.
|
| 372 |
+
|
| 373 |
+
**¿Puedo canjear el ticket desde el frontend (SPA sin backend)?**
|
| 374 |
+
Sí. Si tu módulo es una SPA sin backend (Angular, React, etc.), el canje se hace desde el navegador contra el endpoint público. Es un patrón válido porque el ticket es de un solo uso y de vida corta. Seguí la sección [Variante: módulo SPA sin backend](#variante-módulo-spa-sin-backend-angular--react). Si tenés backend, preferí el canje servidor-a-servidor.
|
| 375 |
+
|
| 376 |
+
**El JWT vence a las 24 h. ¿Cómo lo renuevo?**
|
| 377 |
+
Si tu módulo se comunica con el core, podés usar `POST /auth/refresh` con el token todavía vigente. Si no, el usuario vuelve a pasar por el SSO.
|
| 378 |
+
|
| 379 |
+
**¿Cómo autorizo acciones?**
|
| 380 |
+
Con el claim `permissions` del JWT (formato `recurso:accion`, ej. `users:read`).
|
documentation/M6_AUTH_SSO.md
ADDED
|
@@ -0,0 +1,227 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Autenticación de M6: SSO del Core — guía para backend y frontend
|
| 2 |
+
|
| 3 |
+
**Health Grid · Módulo 6 (Internación y Gestión de Camas)**
|
| 4 |
+
|
| 5 |
+
> Este documento explica cómo se loguea un usuario en M6 y cómo persiste su sesión, y sirve de guía de implementación para el equipo de frontend. Es específico de M6; el contrato genérico del SSO del Core está en [`M10_SSO_INTEGRATION_GUIDE.md`](M10_SSO_INTEGRATION_GUIDE.md). El detalle de la integración vive en [`M6_DISEÑO.md`](M6_DISEÑO.md) §11 y el mapeo de roles en [`roles.md`](roles.md) §6.
|
| 6 |
+
|
| 7 |
+
---
|
| 8 |
+
|
| 9 |
+
## 1. Resumen
|
| 10 |
+
|
| 11 |
+
**M6 no tiene login propio.** No hay pantalla de usuario/contraseña contra este backend. El usuario se loguea en el Core (M10) — ya sea directamente o porque llega logueado desde otro módulo — y M6 lo recibe **ya autenticado** vía SSO: canjea un ticket de un solo uso por los datos del usuario, y a partir de ahí **emite su propia sesión**, independiente del Core.
|
| 12 |
+
|
| 13 |
+
Dos tokens distintos entran en juego y no hay que confundirlos:
|
| 14 |
+
|
| 15 |
+
| Token | Quién lo emite | Algoritmo | Vigencia | Dónde se usa |
|
| 16 |
+
|---|---|---|---|---|
|
| 17 |
+
| Token del Core | M10 | RS256 | 24 h | Solo dentro del canje (`sso-exchange`). M6 nunca lo guarda ni lo reenvía. |
|
| 18 |
+
| Token de M6 | M6 (`create_access_token`) | HS256 | `JWT_EXPIRE_MINUTES` (hoy 60 min) | Es la sesión real: el frontend lo guarda y lo manda como `Authorization: Bearer` en cada request a M6. |
|
| 19 |
+
|
| 20 |
+
---
|
| 21 |
+
|
| 22 |
+
## 2. Flujo completo
|
| 23 |
+
|
| 24 |
+
```mermaid
|
| 25 |
+
sequenceDiagram
|
| 26 |
+
participant U as Usuario (navegador)
|
| 27 |
+
participant Core as Core API (M10)
|
| 28 |
+
participant F as Frontend M6
|
| 29 |
+
participant M6 as Backend M6
|
| 30 |
+
|
| 31 |
+
U->>Core: 1) Login (u otro módulo ya logueado)
|
| 32 |
+
F->>Core: 2) POST /auth/sso-ticket (Bearer del Core)
|
| 33 |
+
Core-->>F: { ticket, expires_in }
|
| 34 |
+
Note over U,F: 3) Redirect a /auth/sso?ticket=…&redirect=/mapa
|
| 35 |
+
F->>M6: 4) POST /api/v1/auth/sso-exchange { ticket }
|
| 36 |
+
M6->>Core: 5) POST /auth/sso-exchange { ticket }
|
| 37 |
+
Core-->>M6: { user (con roles[]), token (RS256, descartado) }
|
| 38 |
+
M6-->>F: { token (HS256 propio), user, rol }
|
| 39 |
+
Note over F: 6) Guarda el token, navega a redirect
|
| 40 |
+
F->>M6: 7) GET /api/v1/camas (Authorization: Bearer <token M6>)
|
| 41 |
+
```
|
| 42 |
+
|
| 43 |
+
1. El usuario ya está autenticado en el Core (o en otro módulo que comparte el Core).
|
| 44 |
+
2. Alguien pide un ticket de un solo uso: `POST /auth/sso-ticket` en el Core (vida ~60 s, ver `M10_SSO_INTEGRATION_GUIDE.md`).
|
| 45 |
+
3. El navegador llega al frontend de M6 con `?ticket=…&redirect=…`.
|
| 46 |
+
4. El **frontend de M6** canjea ese ticket contra **el backend de M6** — no contra el Core directamente. Esto es lo que distingue a M6 de la guía genérica del Core: M6 actúa de proxy del canje.
|
| 47 |
+
5. El backend de M6 hace el canje real contra el Core, server-to-server.
|
| 48 |
+
6. El backend de M6 resuelve el rol y emite su propio JWT.
|
| 49 |
+
7. El frontend guarda ese JWT y lo usa en todas las llamadas siguientes.
|
| 50 |
+
|
| 51 |
+
---
|
| 52 |
+
|
| 53 |
+
## 3. Contrato: `POST /api/v1/auth/sso-exchange`
|
| 54 |
+
|
| 55 |
+
Implementado en `app/routers/auth.py`. Habilitado solo si `SSO_ENABLED=true` en el backend.
|
| 56 |
+
|
| 57 |
+
**Request**
|
| 58 |
+
|
| 59 |
+
```json
|
| 60 |
+
{ "ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b" }
|
| 61 |
+
```
|
| 62 |
+
|
| 63 |
+
`ticket`: string no vacío. Es el mismo ticket recibido en la query del callback.
|
| 64 |
+
|
| 65 |
+
**Response `200`**
|
| 66 |
+
|
| 67 |
+
```json
|
| 68 |
+
{
|
| 69 |
+
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
|
| 70 |
+
"user": {
|
| 71 |
+
"id": 42,
|
| 72 |
+
"first_name": "Ana",
|
| 73 |
+
"last_name": "Pérez",
|
| 74 |
+
"email": "ana@example.com"
|
| 75 |
+
},
|
| 76 |
+
"rol": "ADMINISTRATIVO"
|
| 77 |
+
}
|
| 78 |
+
```
|
| 79 |
+
|
| 80 |
+
- `token`: JWT **HS256 de M6** (no el del Core). Es lo único que el frontend necesita guardar y reenviar.
|
| 81 |
+
- `user`: subconjunto de datos del usuario, para mostrar en la UI (no hace falta pedir nada más al Core).
|
| 82 |
+
- `rol`: uno de `ADMINISTRATIVO` | `MEDICO` | `LIMPIEZA` — el rol interno de M6 ya resuelto (ver §5).
|
| 83 |
+
|
| 84 |
+
**Errores**
|
| 85 |
+
|
| 86 |
+
| Código | Cuándo | Qué hacer en el frontend |
|
| 87 |
+
|---|---|---|
|
| 88 |
+
| `401` | Ticket inválido, ya usado o expirado (`NO_AUTENTICADO`) | Volver a iniciar el flujo desde el módulo de origen (pedir un ticket nuevo) |
|
| 89 |
+
| `403` | El usuario no tiene ningún rol de Core mapeado a M6 (`NO_AUTORIZADO`) | Mostrar "sin acceso a este módulo"; no reintentar |
|
| 90 |
+
| `404` | SSO deshabilitado en este backend (`SSO_ENABLED=false`) | Error de configuración/entorno, no del usuario |
|
| 91 |
+
| `502` | El Core no respondió al canje (`SERVICIO_EXTERNO_NO_DISPONIBLE`) | Reintentar más tarde / mostrar error de servicio |
|
| 92 |
+
|
| 93 |
+
El body de error va anidado bajo `detail` (comportamiento por defecto de FastAPI ante un `HTTPException`):
|
| 94 |
+
|
| 95 |
+
```json
|
| 96 |
+
{ "detail": { "codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado" } }
|
| 97 |
+
```
|
| 98 |
+
|
| 99 |
+
---
|
| 100 |
+
|
| 101 |
+
## 4. Cómo persiste la sesión
|
| 102 |
+
|
| 103 |
+
**M6 es completamente stateless.** No hay tabla de sesiones, no hay store en memoria ni en base de datos, no hay cookie que el backend administre. La "sesión" es, literalmente, el JWT que tiene el cliente.
|
| 104 |
+
|
| 105 |
+
- **Dónde vive:** en el cliente. El backend no lo sabe ni le importa — puede ser `localStorage` o una cookie propia del frontend, a criterio de ese equipo (igual que recomienda `M10_SSO_INTEGRATION_GUIDE.md` para SPAs).
|
| 106 |
+
- **Cómo se valida cada request:** `get_current_user` (`app/dependencies.py`) hace `decode_token` — verifica la firma HS256 contra `jwt_secret` y lee `sub` + `rol` directo del payload. **Cero llamadas al Core, cero lookups, cero estado compartido.** Por eso el rol tiene que viajar embebido en el token (ver §5): si hubiera que resolverlo aparte, dejaría de ser stateless.
|
| 107 |
+
- **Vigencia:** `JWT_EXPIRE_MINUTES` (hoy 60 min en `.env`). Ojo: el token del Core dura 24 h, pero eso es irrelevante una vez canjeado — la sesión de M6 dura lo que este valor diga.
|
| 108 |
+
- **Al vencer:** no hay endpoint de refresh en M6 hoy. El frontend debe manejar el `401` de un request cualquiera repitiendo el flujo SSO desde cero (nuevo ticket → nuevo canje). Si se necesita sesión más larga, es cuestión de subir `JWT_EXPIRE_MINUTES`; un refresh sin volver a pasar por SSO sería trabajo nuevo (no implementado).
|
| 109 |
+
|
| 110 |
+
---
|
| 111 |
+
|
| 112 |
+
## 5. De dónde sale el rol
|
| 113 |
+
|
| 114 |
+
El JWT del Core **no** trae el nombre del rol — sus claims son `{user_id, permissions[], iat, exp}`, y esos `permissions[]` son de recursos propios del Core, no de M6.
|
| 115 |
+
|
| 116 |
+
El rol se resuelve **una sola vez, en el canje**, a partir de `user.roles[]` de la respuesta de `/auth/sso-exchange` del Core (cada rol con su `name`). `app/integrations/core_auth.py::map_core_roles_to_internal` lo traduce con esta tabla:
|
| 117 |
+
|
| 118 |
+
| Rol en el Core | Rol interno de M6 |
|
| 119 |
+
|---|---|
|
| 120 |
+
| `admin_internacion` | `ADMINISTRATIVO` |
|
| 121 |
+
| `Medico` | `MEDICO` |
|
| 122 |
+
| `limpieza` | `LIMPIEZA` |
|
| 123 |
+
| `admin` (super-admin del Core) | `ADMINISTRATIVO` |
|
| 124 |
+
| cualquier otro / ninguno | sin acceso → `403` en el canje |
|
| 125 |
+
|
| 126 |
+
Una vez resuelto, el rol queda embebido en el JWT de M6 (`create_access_token(sub, rol)`) y no se vuelve a consultar. `require_roles(*roles)` (`app/dependencies.py`) es lo que cada endpoint usa para autorizar, comparando ese campo — ver matriz completa en `roles.md`.
|
| 127 |
+
|
| 128 |
+
---
|
| 129 |
+
|
| 130 |
+
## 6. Guía de implementación para el frontend
|
| 131 |
+
|
| 132 |
+
Lo que el equipo de frontend tiene que construir, en orden:
|
| 133 |
+
|
| 134 |
+
### 6.1 Ruta de callback `/auth/sso`
|
| 135 |
+
|
| 136 |
+
Una ruta pública del router del SPA (no protegida) que reciba `ticket` y `redirect` por query string:
|
| 137 |
+
|
| 138 |
+
```
|
| 139 |
+
https://<host-frontend-m6>/auth/sso?ticket=<opaco>&redirect=/mapa-camas
|
| 140 |
+
```
|
| 141 |
+
|
| 142 |
+
### 6.2 Validar el `redirect` (anti-open-redirect)
|
| 143 |
+
|
| 144 |
+
Antes de navegar ahí, aceptar **solo** rutas internas absolutas. Mismo criterio que `M10_SSO_INTEGRATION_GUIDE.md`:
|
| 145 |
+
|
| 146 |
+
```ts
|
| 147 |
+
function safeRedirect(path: string | null): string | null {
|
| 148 |
+
if (!path) return null;
|
| 149 |
+
if (!path.startsWith('/') || path.startsWith('//') || path.startsWith('/\\')) return null;
|
| 150 |
+
return path;
|
| 151 |
+
}
|
| 152 |
+
```
|
| 153 |
+
|
| 154 |
+
### 6.3 Canjear el ticket contra **M6**, no contra el Core
|
| 155 |
+
|
| 156 |
+
Esta es la diferencia clave frente a la guía genérica: el canje va al backend de M6, que a su vez habla con el Core.
|
| 157 |
+
|
| 158 |
+
```ts
|
| 159 |
+
async function exchangeSSOTicket(ticket: string) {
|
| 160 |
+
const res = await fetch(`${M6_API_BASE}/api/v1/auth/sso-exchange`, {
|
| 161 |
+
method: 'POST',
|
| 162 |
+
headers: { 'Content-Type': 'application/json' },
|
| 163 |
+
body: JSON.stringify({ ticket }),
|
| 164 |
+
});
|
| 165 |
+
|
| 166 |
+
if (!res.ok) {
|
| 167 |
+
if (res.status === 401) throw new Error('Ticket inválido o expirado — reiniciar el login');
|
| 168 |
+
if (res.status === 403) throw new Error('El usuario no tiene acceso a este módulo');
|
| 169 |
+
throw new Error('No se pudo iniciar sesión en M6');
|
| 170 |
+
}
|
| 171 |
+
|
| 172 |
+
return res.json(); // { token, user, rol }
|
| 173 |
+
}
|
| 174 |
+
```
|
| 175 |
+
|
| 176 |
+
### 6.4 Guardar la sesión y limpiar la URL
|
| 177 |
+
|
| 178 |
+
```ts
|
| 179 |
+
const { token, user, rol } = await exchangeSSOTicket(ticket);
|
| 180 |
+
saveSession({ token, user, rol }); // localStorage o cookie propia
|
| 181 |
+
history.replaceState(null, '', location.pathname); // el ticket no debe quedar en el historial
|
| 182 |
+
navigate(safeRedirect(redirect) ?? '/');
|
| 183 |
+
```
|
| 184 |
+
|
| 185 |
+
### 6.5 Mandar el token en cada request a M6
|
| 186 |
+
|
| 187 |
+
```ts
|
| 188 |
+
fetch(`${M6_API_BASE}/api/v1/camas`, {
|
| 189 |
+
headers: { Authorization: `Bearer ${getSessionToken()}` },
|
| 190 |
+
});
|
| 191 |
+
```
|
| 192 |
+
|
| 193 |
+
### 6.6 Manejar el vencimiento
|
| 194 |
+
|
| 195 |
+
Un interceptor de respuesta que, ante cualquier `401` de M6, limpie la sesión local y redirija a iniciar el flujo SSO de nuevo (no hay refresh):
|
| 196 |
+
|
| 197 |
+
```ts
|
| 198 |
+
if (response.status === 401) {
|
| 199 |
+
clearSession();
|
| 200 |
+
redirectToLogin(); // vuelve a pedir ticket desde el origen
|
| 201 |
+
}
|
| 202 |
+
```
|
| 203 |
+
|
| 204 |
+
### 6.7 Checklist
|
| 205 |
+
|
| 206 |
+
- [ ] Ruta `/auth/sso?ticket=&redirect=` en el router del SPA.
|
| 207 |
+
- [ ] `redirect` validado como ruta interna antes de navegar.
|
| 208 |
+
- [ ] Canje contra `POST {M6_API_BASE}/api/v1/auth/sso-exchange` (no contra el Core).
|
| 209 |
+
- [ ] Ticket limpiado de la URL después del canje (`replaceState`/`replaceUrl`).
|
| 210 |
+
- [ ] Token guardado y enviado como `Authorization: Bearer` en toda llamada a M6.
|
| 211 |
+
- [ ] Manejo de `401`/`403`/`404`/`502` de la respuesta del canje.
|
| 212 |
+
- [ ] Interceptor de `401` en requests posteriores → reinicia SSO.
|
| 213 |
+
|
| 214 |
+
---
|
| 215 |
+
|
| 216 |
+
## 7. Desarrollo local sin el Core real
|
| 217 |
+
|
| 218 |
+
Para no depender de que el Core esté arriba, M6 expone `GET /api/v1/auth/token?usuario=&password=` (habilitado solo con `ENVIRONMENT=development`), que devuelve un JWT de M6 del mismo formato que emite el canje SSO — mismo `decode_token`, misma validación. `usuario` es en realidad el rol deseado (`ADMINISTRATIVO` | `MEDICO` | `LIMPIEZA`); `password` no se valida. Útil para levantar y probar el frontend contra M6 sin tocar el Core.
|
| 219 |
+
|
| 220 |
+
---
|
| 221 |
+
|
| 222 |
+
## 8. Referencias
|
| 223 |
+
|
| 224 |
+
- [`M10_SSO_INTEGRATION_GUIDE.md`](M10_SSO_INTEGRATION_GUIDE.md) — contrato genérico del SSO del Core (ticket, JWKS, ejemplos Angular/React/Go/Node).
|
| 225 |
+
- [`M6_DISEÑO.md`](M6_DISEÑO.md) §11 — detalle técnico de la integración de auth en M6.
|
| 226 |
+
- [`roles.md`](roles.md) §6 — mapeo de roles del Core a roles internos de M6 y matriz de permisos por endpoint.
|
| 227 |
+
- [`M6_openapi.json`](M6_openapi.json) — contrato exacto de `/auth/sso-exchange` (schemas `SSOExchangeRequest`/`SSOExchangeResponse`).
|
documentation/M6_DISEÑO.md
CHANGED
|
@@ -330,12 +330,13 @@ Tablas principales en PostgreSQL (Supabase): `camas` (incluye quirófanos), `res
|
|
| 330 |
|
| 331 |
## 11. Seguridad
|
| 332 |
|
| 333 |
-
|
| 334 |
|
| 335 |
-
-
|
| 336 |
-
-
|
|
|
|
| 337 |
|
| 338 |
-
**Resolución de rol (el
|
| 339 |
|
| 340 |
| Rol Core | Rol interno M6 |
|
| 341 |
|---|---|
|
|
@@ -343,15 +344,16 @@ Autenticación centralizada en Core (M10), integrada (no mockeada). `app/config.
|
|
| 343 |
| `Medico` | `MEDICO` |
|
| 344 |
| `limpieza` | `LIMPIEZA` |
|
| 345 |
| `admin` | `ADMINISTRATIVO` (super-admin del Core) |
|
| 346 |
-
| cualquier otro | sin acceso a M6 → `403` |
|
| 347 |
|
| 348 |
-
|
| 349 |
|
| 350 |
-
**Llamadas salientes:**
|
| 351 |
|
| 352 |
**Fuera de alcance de esta integración:**
|
| 353 |
-
- Permisos granulares (`camas:read`, etc.) — el Core no expone `permissions:manage` a la cuenta de servicio hoy; migrar `require_roles` a permisos cuando eso cambie.
|
| 354 |
- Autenticación de webhooks entrantes (`/webhooks/*` sigue exigiendo JWT de usuario) — pendiente acordar secreto compartido/firma con el Bus de Eventos.
|
|
|
|
| 355 |
|
| 356 |
---
|
| 357 |
|
|
@@ -426,3 +428,9 @@ Este mecanismo (lookup de `/roles` cacheado, no `GET /users/{id}`) se eligió po
|
|
| 426 |
23. **Filtro de quirófanos por hospital y por estado operable.** El algoritmo original no filtraba por `hospital_id` (podía asignar una urgencia a un quirófano de otra sede) ni excluía quirófanos `EN_LIMPIEZA` (además de los ya excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`). Corregido en `crear_reserva_urgente`.
|
| 427 |
24. **Bug de persistencia corregido.** `reserva_crud.save` solo persistía `estado`/`observaciones`/`desplazada_por_reserva_id`; el nuevo horario de una reserva reprogramada nunca se guardaba en la tabla `reservas_quirofano` de M6 (solo se notificaba a M2). Ahora `save` también persiste `fecha_hora_inicio`/`fecha_hora_fin_estimada`.
|
| 428 |
25. **Seam `reprogramar()`.** Se introdujo `cama_service.reprogramar(db, reserva, no_antes_de, motivo)` como interfaz estable que consume el algoritmo de urgencia para reubicar una reserva desplazada. La implementación actual es mínima (evita solapar horarios en el mismo quirófano) — el diseño completo (cascada, cambio de quirófano) queda pendiente como tarea siguiente.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 330 |
|
| 331 |
## 11. Seguridad
|
| 332 |
|
| 333 |
+
Login centralizado en el Core (M10) vía **SSO**, integrado (no mockeado). La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`), con un claim `rol` directo — no hay un modo de validación distinto por-request. Lo que agrega el Core es la forma de *adquirir* ese token:
|
| 334 |
|
| 335 |
+
- El frontend obtiene del Core un **ticket** de un solo uso (`POST /auth/sso-ticket`, requiere que el usuario ya esté logueado en el Core) y llega a M6 con ese ticket.
|
| 336 |
+
- M6 lo canjea server-to-server: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, habilitado con `settings.sso_enabled`) llama a `core_auth.exchange_sso_ticket`, que hace `POST /auth/sso-exchange` contra el Core (`https://api.healthcare.cantero.ar` en el entorno compartido) y recibe `{user, token}` (`models.AuthResponse`). El `token` del Core (RS256, `{exp, iat, permissions[], user_id}`) **no se reenvía ni se guarda** — solo se usa `user` para resolver el rol.
|
| 337 |
+
- El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend** — fuera de este backend.
|
| 338 |
|
| 339 |
+
**Resolución de rol (viene en el canje, no en el JWT):** `user.roles[]` de la respuesta (`models.User.roles`, cada uno con `name`) trae el/los rol(es) del usuario en el Core. `core_auth.map_core_roles_to_internal` los traduce al rol interno de M6 vía la tabla `CORE_ROLE_TO_INTERNAL`:
|
| 340 |
|
| 341 |
| Rol Core | Rol interno M6 |
|
| 342 |
|---|---|
|
|
|
|
| 344 |
| `Medico` | `MEDICO` |
|
| 345 |
| `limpieza` | `LIMPIEZA` |
|
| 346 |
| `admin` | `ADMINISTRATIVO` (super-admin del Core) |
|
| 347 |
+
| cualquier otro / ninguno | sin acceso a M6 → `403` en el canje |
|
| 348 |
|
| 349 |
+
No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT del Core por-request: todo se resuelve **una sola vez**, en el canje. M6 emite entonces su propio JWT HS256 (`create_access_token(sub=str(user_id), rol=rol)`) y lo devuelve junto con el rol y los datos básicos del usuario. `get_current_user` (`app/dependencies.py`) valida ese token localmente en cada request — misma forma `{"sub", "rol"}` de siempre; `require_roles`, la auditoría y los routers no cambiaron.
|
| 350 |
|
| 351 |
+
**Llamadas salientes:** una cuenta de servicio propia (`core_auth.get_service_token`, login contra `POST /auth/login` del Core) autentica las llamadas de M6 a M1/M2/M7/M10 (adjuntado automático en `app/integrations/_base.py::_headers`), incluidas las disparadas por webhooks entrantes donde no hay usuario humano. Es independiente del flujo SSO — se habilita con `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`.
|
| 352 |
|
| 353 |
**Fuera de alcance de esta integración:**
|
| 354 |
+
- Permisos granulares (`camas:read`, etc.) — el Core no expone `permissions:manage` a la cuenta de servicio hoy, ni tiene permisos de dominio M6 en su catálogo; migrar `require_roles` a permisos cuando eso cambie.
|
| 355 |
- Autenticación de webhooks entrantes (`/webhooks/*` sigue exigiendo JWT de usuario) — pendiente acordar secreto compartido/firma con el Bus de Eventos.
|
| 356 |
+
- Refresh de sesión: al vencer el JWT de M6, el usuario vuelve a pasar por SSO.
|
| 357 |
|
| 358 |
---
|
| 359 |
|
|
|
|
| 428 |
23. **Filtro de quirófanos por hospital y por estado operable.** El algoritmo original no filtraba por `hospital_id` (podía asignar una urgencia a un quirófano de otra sede) ni excluía quirófanos `EN_LIMPIEZA` (además de los ya excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`). Corregido en `crear_reserva_urgente`.
|
| 429 |
24. **Bug de persistencia corregido.** `reserva_crud.save` solo persistía `estado`/`observaciones`/`desplazada_por_reserva_id`; el nuevo horario de una reserva reprogramada nunca se guardaba en la tabla `reservas_quirofano` de M6 (solo se notificaba a M2). Ahora `save` también persiste `fecha_hora_inicio`/`fecha_hora_fin_estimada`.
|
| 430 |
25. **Seam `reprogramar()`.** Se introdujo `cama_service.reprogramar(db, reserva, no_antes_de, motivo)` como interfaz estable que consume el algoritmo de urgencia para reubicar una reserva desplazada. La implementación actual es mínima (evita solapar horarios en el mismo quirófano) — el diseño completo (cascada, cambio de quirófano) queda pendiente como tarea siguiente.
|
| 431 |
+
|
| 432 |
+
### 14.5 SSO del Core y eliminación del lookup de roles (2026-07)
|
| 433 |
+
|
| 434 |
+
26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
|
| 435 |
+
27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
|
| 436 |
+
28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
|
documentation/M6_openapi.json
CHANGED
|
@@ -12,6 +12,9 @@
|
|
| 12 |
}
|
| 13 |
},
|
| 14 |
"tags": [
|
|
|
|
|
|
|
|
|
|
| 15 |
{
|
| 16 |
"name": "Camas"
|
| 17 |
},
|
|
@@ -4747,6 +4750,109 @@
|
|
| 4747 |
},
|
| 4748 |
"security": []
|
| 4749 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 4750 |
}
|
| 4751 |
},
|
| 4752 |
"components": {
|
|
@@ -6104,6 +6210,74 @@
|
|
| 6104 |
}
|
| 6105 |
}
|
| 6106 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 6107 |
}
|
| 6108 |
},
|
| 6109 |
"responses": {
|
|
|
|
| 12 |
}
|
| 13 |
},
|
| 14 |
"tags": [
|
| 15 |
+
{
|
| 16 |
+
"name": "Auth"
|
| 17 |
+
},
|
| 18 |
{
|
| 19 |
"name": "Camas"
|
| 20 |
},
|
|
|
|
| 4750 |
},
|
| 4751 |
"security": []
|
| 4752 |
}
|
| 4753 |
+
},
|
| 4754 |
+
"/auth/sso-exchange": {
|
| 4755 |
+
"post": {
|
| 4756 |
+
"summary": "Canjear un ticket SSO del Core por una sesión de M6",
|
| 4757 |
+
"deprecated": false,
|
| 4758 |
+
"description": "Canjea, servidor-a-servidor, un ticket SSO de un solo uso emitido por el Core (M10) contra `POST /auth/sso-exchange` del Core, y devuelve una sesión propia de M6: un JWT HS256 con el rol ya resuelto a partir de `user.roles[]` de la respuesta del Core — no el JWT del Core.\n\nEl rol se traduce con la tabla `CORE_ROLE_TO_INTERNAL` (`admin_internacion`→`ADMINISTRATIVO`, `Medico`→`MEDICO`, `limpieza`→`LIMPIEZA`, `admin`→`ADMINISTRATIVO`). Si ninguno de los roles del usuario mapea, devuelve `403` — el canje no otorga acceso a un usuario sin rol habilitado en M6.\n\nDeshabilitado (`404`) si `SSO_ENABLED=false`.\n\n> El callback del navegador (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del frontend, no de este endpoint.",
|
| 4759 |
+
"operationId": "ssoExchange",
|
| 4760 |
+
"tags": [
|
| 4761 |
+
"Auth"
|
| 4762 |
+
],
|
| 4763 |
+
"requestBody": {
|
| 4764 |
+
"content": {
|
| 4765 |
+
"application/json": {
|
| 4766 |
+
"schema": {
|
| 4767 |
+
"$ref": "#/components/schemas/SSOExchangeRequest"
|
| 4768 |
+
},
|
| 4769 |
+
"example": {
|
| 4770 |
+
"ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b"
|
| 4771 |
+
}
|
| 4772 |
+
}
|
| 4773 |
+
},
|
| 4774 |
+
"required": true
|
| 4775 |
+
},
|
| 4776 |
+
"responses": {
|
| 4777 |
+
"200": {
|
| 4778 |
+
"description": "Ticket canjeado; sesión de M6 emitida",
|
| 4779 |
+
"content": {
|
| 4780 |
+
"application/json": {
|
| 4781 |
+
"schema": {
|
| 4782 |
+
"$ref": "#/components/schemas/SSOExchangeResponse"
|
| 4783 |
+
},
|
| 4784 |
+
"example": {
|
| 4785 |
+
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
|
| 4786 |
+
"user": {
|
| 4787 |
+
"id": 42,
|
| 4788 |
+
"first_name": "Ana",
|
| 4789 |
+
"last_name": "Pérez",
|
| 4790 |
+
"email": "ana@example.com"
|
| 4791 |
+
},
|
| 4792 |
+
"rol": "ADMINISTRATIVO"
|
| 4793 |
+
}
|
| 4794 |
+
}
|
| 4795 |
+
}
|
| 4796 |
+
},
|
| 4797 |
+
"401": {
|
| 4798 |
+
"description": "Ticket inválido, ya usado o expirado",
|
| 4799 |
+
"content": {
|
| 4800 |
+
"application/json": {
|
| 4801 |
+
"schema": {
|
| 4802 |
+
"$ref": "#/components/schemas/Error"
|
| 4803 |
+
},
|
| 4804 |
+
"example": {
|
| 4805 |
+
"codigo": "NO_AUTENTICADO",
|
| 4806 |
+
"mensaje": "Ticket inválido, ya usado o expirado"
|
| 4807 |
+
}
|
| 4808 |
+
}
|
| 4809 |
+
}
|
| 4810 |
+
},
|
| 4811 |
+
"403": {
|
| 4812 |
+
"description": "Los roles del usuario en el Core no mapean a ningún rol de M6",
|
| 4813 |
+
"content": {
|
| 4814 |
+
"application/json": {
|
| 4815 |
+
"schema": {
|
| 4816 |
+
"$ref": "#/components/schemas/Error"
|
| 4817 |
+
},
|
| 4818 |
+
"example": {
|
| 4819 |
+
"codigo": "NO_AUTORIZADO",
|
| 4820 |
+
"mensaje": "El usuario no tiene un rol habilitado en M6"
|
| 4821 |
+
}
|
| 4822 |
+
}
|
| 4823 |
+
}
|
| 4824 |
+
},
|
| 4825 |
+
"404": {
|
| 4826 |
+
"description": "SSO deshabilitado (SSO_ENABLED=false)",
|
| 4827 |
+
"content": {
|
| 4828 |
+
"application/json": {
|
| 4829 |
+
"schema": {
|
| 4830 |
+
"$ref": "#/components/schemas/Error"
|
| 4831 |
+
},
|
| 4832 |
+
"example": {
|
| 4833 |
+
"codigo": "RECURSO_NO_ENCONTRADO",
|
| 4834 |
+
"mensaje": "Not Found"
|
| 4835 |
+
}
|
| 4836 |
+
}
|
| 4837 |
+
}
|
| 4838 |
+
},
|
| 4839 |
+
"502": {
|
| 4840 |
+
"description": "El Core no respondió al canje",
|
| 4841 |
+
"content": {
|
| 4842 |
+
"application/json": {
|
| 4843 |
+
"schema": {
|
| 4844 |
+
"$ref": "#/components/schemas/Error"
|
| 4845 |
+
},
|
| 4846 |
+
"example": {
|
| 4847 |
+
"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE",
|
| 4848 |
+
"mensaje": "No se pudo canjear el ticket contra el Core (M10)"
|
| 4849 |
+
}
|
| 4850 |
+
}
|
| 4851 |
+
}
|
| 4852 |
+
}
|
| 4853 |
+
},
|
| 4854 |
+
"security": []
|
| 4855 |
+
}
|
| 4856 |
}
|
| 4857 |
},
|
| 4858 |
"components": {
|
|
|
|
| 6210 |
}
|
| 6211 |
}
|
| 6212 |
}
|
| 6213 |
+
},
|
| 6214 |
+
"SSOExchangeRequest": {
|
| 6215 |
+
"type": "object",
|
| 6216 |
+
"required": [
|
| 6217 |
+
"ticket"
|
| 6218 |
+
],
|
| 6219 |
+
"properties": {
|
| 6220 |
+
"ticket": {
|
| 6221 |
+
"type": "string",
|
| 6222 |
+
"description": "Ticket SSO de un solo uso emitido por el Core (POST /auth/sso-ticket).",
|
| 6223 |
+
"example": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b"
|
| 6224 |
+
}
|
| 6225 |
+
}
|
| 6226 |
+
},
|
| 6227 |
+
"SSOUser": {
|
| 6228 |
+
"type": "object",
|
| 6229 |
+
"required": [
|
| 6230 |
+
"id",
|
| 6231 |
+
"first_name",
|
| 6232 |
+
"last_name",
|
| 6233 |
+
"email"
|
| 6234 |
+
],
|
| 6235 |
+
"properties": {
|
| 6236 |
+
"id": {
|
| 6237 |
+
"type": "integer",
|
| 6238 |
+
"example": 42
|
| 6239 |
+
},
|
| 6240 |
+
"first_name": {
|
| 6241 |
+
"type": "string",
|
| 6242 |
+
"example": "Ana"
|
| 6243 |
+
},
|
| 6244 |
+
"last_name": {
|
| 6245 |
+
"type": "string",
|
| 6246 |
+
"example": "Pérez"
|
| 6247 |
+
},
|
| 6248 |
+
"email": {
|
| 6249 |
+
"type": "string",
|
| 6250 |
+
"example": "ana@example.com"
|
| 6251 |
+
}
|
| 6252 |
+
}
|
| 6253 |
+
},
|
| 6254 |
+
"SSOExchangeResponse": {
|
| 6255 |
+
"type": "object",
|
| 6256 |
+
"required": [
|
| 6257 |
+
"token",
|
| 6258 |
+
"user",
|
| 6259 |
+
"rol"
|
| 6260 |
+
],
|
| 6261 |
+
"properties": {
|
| 6262 |
+
"token": {
|
| 6263 |
+
"type": "string",
|
| 6264 |
+
"description": "JWT HS256 propio de M6 (no el JWT del Core). Usar en Authorization: Bearer.",
|
| 6265 |
+
"example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
|
| 6266 |
+
},
|
| 6267 |
+
"user": {
|
| 6268 |
+
"$ref": "#/components/schemas/SSOUser"
|
| 6269 |
+
},
|
| 6270 |
+
"rol": {
|
| 6271 |
+
"type": "string",
|
| 6272 |
+
"enum": [
|
| 6273 |
+
"ADMINISTRATIVO",
|
| 6274 |
+
"MEDICO",
|
| 6275 |
+
"LIMPIEZA"
|
| 6276 |
+
],
|
| 6277 |
+
"description": "Rol interno de M6, resuelto a partir de los roles del usuario en el Core.",
|
| 6278 |
+
"example": "ADMINISTRATIVO"
|
| 6279 |
+
}
|
| 6280 |
+
}
|
| 6281 |
}
|
| 6282 |
},
|
| 6283 |
"responses": {
|
documentation/roles.md
CHANGED
|
@@ -104,20 +104,20 @@ Los endpoints bajo `/webhooks/*` (recepción de eventos de M1 HCE, M9 Monitoreo,
|
|
| 104 |
|
| 105 |
## 5. Testing
|
| 106 |
|
| 107 |
-
Los tests de autorización por rol viven junto a los tests de cada router (`tests/test_camas.py`, `tests/test_quirofanos.py`, `tests/test_solicitudes.py`, `tests/test_auditoria.py`), usando los fixtures `admin_headers`, `medico_headers`, `limpieza_headers` de `tests/conftest.py`
|
| 108 |
|
| 109 |
---
|
| 110 |
|
| 111 |
-
## 6. Integración con el Core (M10)
|
| 112 |
|
| 113 |
-
La integración con el Core
|
| 114 |
|
| 115 |
-
-
|
| 116 |
-
- Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`.
|
| 117 |
-
- `require_roles`, la capa de servicio y la auditoría no cambiaron — `
|
|
|
|
| 118 |
|
| 119 |
### Fuera de alcance / pendiente
|
| 120 |
|
| 121 |
-
- **Permisos granulares vía Core.** El Core no expone `permissions:manage` a la cuenta de servicio de M6 hoy
|
| 122 |
-
- **Lookup de rol más fresco (`GET /users/{id}`).** El mecanismo actual (`GET /roles` cacheado, TTL `core_roles_cache_ttl_seconds`) trae el padrón completo y un usuario recién asignado a un rol tarda hasta el TTL en verse. `GET /users/{id}` sería más directo pero requiere el permiso `users:read`, no otorgado hoy a la cuenta de servicio.
|
| 123 |
- **Autenticación de webhooks entrantes.** Hoy no hay verificación de origen en `/webhooks/*` más allá de lo que ya documente cada integración puntual — siguen exigiendo un JWT de usuario, que los emisores reales (M1/M9/M2) no tienen. Pendiente acordar mecanismo (secreto compartido o firma) con el Bus de Eventos de Core.
|
|
|
|
| 104 |
|
| 105 |
## 5. Testing
|
| 106 |
|
| 107 |
+
Los tests de autorización por rol viven junto a los tests de cada router (`tests/test_camas.py`, `tests/test_quirofanos.py`, `tests/test_solicitudes.py`, `tests/test_auditoria.py`), usando los fixtures `admin_headers`, `medico_headers`, `limpieza_headers` de `tests/conftest.py`. El mapeo de rol de Core → M6 tiene su propia suite en `tests/test_core_auth.py`; el flujo completo de canje SSO, en `tests/test_sso.py`. Cada endpoint restringido tiene al menos un test que verifica `403` para el/los rol(es) sin permiso, y un test de happy path para el rol permitido.
|
| 108 |
|
| 109 |
---
|
| 110 |
|
| 111 |
+
## 6. Integración con el Core (M10): SSO
|
| 112 |
|
| 113 |
+
La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`). Lo que agrega la integración con el Core es una forma de *adquirirlo*: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) canjea un ticket de un solo uso emitido por el Core (`POST /auth/sso-ticket` en el Core) contra `POST /auth/sso-exchange` del Core, y devuelve un JWT de M6 con el rol ya resuelto. No hay verificación de JWT del Core por-request ni lookup aparte de roles — el Core se toca una sola vez, en el canje. Detalle técnico completo en `M6_DISEÑO.md §11`; resumen:
|
| 114 |
|
| 115 |
+
- La respuesta del canje (`models.AuthResponse` del Core) trae `user.roles[]` — cada rol con su `name`. De ahí sale el rol del usuario, **sin** `GET /roles` ni `GET /users/{id}`.
|
| 116 |
+
- Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py::map_core_roles_to_internal`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`. Si ninguno de los roles del usuario mapea, el canje devuelve `403` (no entra a M6).
|
| 117 |
+
- `require_roles`, la capa de servicio y la auditoría no cambiaron — siguen leyendo `payload["rol"]` del JWT de M6, sin distinguir si la sesión se originó por SSO o por el endpoint de desarrollo (`/api/v1/auth/token`).
|
| 118 |
+
- El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend**, no de este backend.
|
| 119 |
|
| 120 |
### Fuera de alcance / pendiente
|
| 121 |
|
| 122 |
+
- **Permisos granulares vía Core.** El Core no expone `permissions:manage` a la cuenta de servicio de M6 hoy, y no tiene permisos de dominio M6 (`camas:read`, etc.) en su catálogo. Migrar `require_roles` a un modelo de permisos queda pendiente de esa habilitación.
|
|
|
|
| 123 |
- **Autenticación de webhooks entrantes.** Hoy no hay verificación de origen en `/webhooks/*` más allá de lo que ya documente cada integración puntual — siguen exigiendo un JWT de usuario, que los emisores reales (M1/M9/M2) no tienen. Pendiente acordar mecanismo (secreto compartido o firma) con el Bus de Eventos de Core.
|
tests/test_core_auth.py
CHANGED
|
@@ -1,156 +1,17 @@
|
|
| 1 |
"""
|
| 2 |
-
Tests de
|
| 3 |
-
|
| 4 |
-
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
|
| 8 |
-
|
| 9 |
-
|
| 10 |
-
Los tests de modo mock (`admin_headers`/`medico_headers`/`limpieza_headers`
|
| 11 |
-
en `conftest.py`) siguen intactos y cubren el comportamiento HS256 actual;
|
| 12 |
-
este módulo cubre exclusivamente el camino nuevo introducido por la
|
| 13 |
-
integración con Core.
|
| 14 |
"""
|
| 15 |
-
import time
|
| 16 |
-
|
| 17 |
import pytest
|
| 18 |
-
from cryptography.hazmat.primitives import serialization
|
| 19 |
-
from cryptography.hazmat.primitives.asymmetric import rsa
|
| 20 |
-
from fastapi import HTTPException
|
| 21 |
-
from jose import jwk
|
| 22 |
-
from jose import jwt as jose_jwt
|
| 23 |
|
| 24 |
-
from app.config import settings
|
| 25 |
-
from app.dependencies import _get_current_user_core
|
| 26 |
from app.integrations import core_auth
|
| 27 |
|
| 28 |
-
_TEST_KID = "test-kid-1"
|
| 29 |
-
|
| 30 |
-
|
| 31 |
-
@pytest.fixture(scope="module")
|
| 32 |
-
def rsa_keypair():
|
| 33 |
-
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
|
| 34 |
-
private_pem = private_key.private_bytes(
|
| 35 |
-
encoding=serialization.Encoding.PEM,
|
| 36 |
-
format=serialization.PrivateFormat.PKCS8,
|
| 37 |
-
encryption_algorithm=serialization.NoEncryption(),
|
| 38 |
-
).decode()
|
| 39 |
-
public_pem = (
|
| 40 |
-
private_key.public_key()
|
| 41 |
-
.public_bytes(
|
| 42 |
-
encoding=serialization.Encoding.PEM,
|
| 43 |
-
format=serialization.PublicFormat.SubjectPublicKeyInfo,
|
| 44 |
-
)
|
| 45 |
-
.decode()
|
| 46 |
-
)
|
| 47 |
-
return private_pem, public_pem
|
| 48 |
-
|
| 49 |
-
|
| 50 |
-
def _make_token(private_pem: str, user_id: int, permissions=None, exp_delta=3600, kid=_TEST_KID):
|
| 51 |
-
now = int(time.time())
|
| 52 |
-
payload = {
|
| 53 |
-
"user_id": user_id,
|
| 54 |
-
"iat": now,
|
| 55 |
-
"exp": now + exp_delta,
|
| 56 |
-
"permissions": permissions or [],
|
| 57 |
-
}
|
| 58 |
-
return jose_jwt.encode(payload, private_pem, algorithm="RS256", headers={"kid": kid})
|
| 59 |
-
|
| 60 |
-
|
| 61 |
-
def _stub_jwks(monkeypatch, public_pem, kid=_TEST_KID):
|
| 62 |
-
jwk_dict = jwk.construct(public_pem, algorithm="RS256").to_dict()
|
| 63 |
-
jwk_dict["kid"] = kid
|
| 64 |
-
monkeypatch.setattr(core_auth, "_fetch_jwks", lambda: {"keys": [jwk_dict]})
|
| 65 |
-
|
| 66 |
-
|
| 67 |
-
def _stub_roles(monkeypatch, mapping: dict):
|
| 68 |
-
monkeypatch.setattr(core_auth, "_fetch_roles_index", lambda: mapping)
|
| 69 |
-
|
| 70 |
-
|
| 71 |
-
@pytest.fixture(autouse=True)
|
| 72 |
-
def _reset_core_caches():
|
| 73 |
-
"""Evita que el cache de un test contamine al siguiente."""
|
| 74 |
-
core_auth._jwks_cache["keys_by_kid"] = {}
|
| 75 |
-
core_auth._jwks_cache["fetched_at"] = 0.0
|
| 76 |
-
core_auth._roles_index_cache["user_id_to_roles"] = {}
|
| 77 |
-
core_auth._roles_index_cache["fetched_at"] = 0.0
|
| 78 |
-
yield
|
| 79 |
-
|
| 80 |
-
|
| 81 |
-
@pytest.fixture
|
| 82 |
-
def core_mode(monkeypatch):
|
| 83 |
-
monkeypatch.setattr(settings, "auth_mode", "core")
|
| 84 |
-
|
| 85 |
-
|
| 86 |
-
# ─── verify_core_token ──────────────────────────────────────────────────────
|
| 87 |
-
|
| 88 |
-
|
| 89 |
-
def test_verify_core_token_ok(rsa_keypair, monkeypatch):
|
| 90 |
-
private_pem, public_pem = rsa_keypair
|
| 91 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 92 |
-
token = _make_token(private_pem, user_id=42)
|
| 93 |
-
|
| 94 |
-
payload = core_auth.verify_core_token(token)
|
| 95 |
-
|
| 96 |
-
assert payload["user_id"] == 42
|
| 97 |
-
|
| 98 |
-
|
| 99 |
-
def test_verify_core_token_firma_invalida(rsa_keypair, monkeypatch):
|
| 100 |
-
_, public_pem = rsa_keypair
|
| 101 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 102 |
-
# Firmado con una clave distinta a la publicada en el JWKS stubeado.
|
| 103 |
-
otra_private_pem, _ = _make_other_keypair()
|
| 104 |
-
token = _make_token(otra_private_pem, user_id=42)
|
| 105 |
-
|
| 106 |
-
with pytest.raises(ValueError):
|
| 107 |
-
core_auth.verify_core_token(token)
|
| 108 |
-
|
| 109 |
-
|
| 110 |
-
def _make_other_keypair():
|
| 111 |
-
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
|
| 112 |
-
private_pem = private_key.private_bytes(
|
| 113 |
-
encoding=serialization.Encoding.PEM,
|
| 114 |
-
format=serialization.PrivateFormat.PKCS8,
|
| 115 |
-
encryption_algorithm=serialization.NoEncryption(),
|
| 116 |
-
).decode()
|
| 117 |
-
public_pem = (
|
| 118 |
-
private_key.public_key()
|
| 119 |
-
.public_bytes(
|
| 120 |
-
encoding=serialization.Encoding.PEM,
|
| 121 |
-
format=serialization.PublicFormat.SubjectPublicKeyInfo,
|
| 122 |
-
)
|
| 123 |
-
.decode()
|
| 124 |
-
)
|
| 125 |
-
return private_pem, public_pem
|
| 126 |
-
|
| 127 |
-
|
| 128 |
-
def test_verify_core_token_expirado(rsa_keypair, monkeypatch):
|
| 129 |
-
private_pem, public_pem = rsa_keypair
|
| 130 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 131 |
-
token = _make_token(private_pem, user_id=42, exp_delta=-10)
|
| 132 |
-
|
| 133 |
-
with pytest.raises(ValueError):
|
| 134 |
-
core_auth.verify_core_token(token)
|
| 135 |
-
|
| 136 |
-
|
| 137 |
-
def test_verify_core_token_kid_desconocido(rsa_keypair, monkeypatch):
|
| 138 |
-
_, public_pem = rsa_keypair
|
| 139 |
-
_stub_jwks(monkeypatch, public_pem, kid="otro-kid-publicado")
|
| 140 |
-
private_pem, _ = rsa_keypair
|
| 141 |
-
token = _make_token(private_pem, user_id=42, kid=_TEST_KID)
|
| 142 |
-
|
| 143 |
-
with pytest.raises(ValueError):
|
| 144 |
-
core_auth.verify_core_token(token)
|
| 145 |
-
|
| 146 |
-
|
| 147 |
-
def test_verify_core_token_malformado():
|
| 148 |
-
with pytest.raises(ValueError):
|
| 149 |
-
core_auth.verify_core_token("esto-no-es-un-jwt")
|
| 150 |
-
|
| 151 |
-
|
| 152 |
-
# ─── map_core_roles_to_internal ─────────────────────────────────────────────
|
| 153 |
-
|
| 154 |
|
| 155 |
@pytest.mark.parametrize(
|
| 156 |
"role_names,expected",
|
|
@@ -168,85 +29,3 @@ def test_verify_core_token_malformado():
|
|
| 168 |
)
|
| 169 |
def test_map_core_roles_to_internal(role_names, expected):
|
| 170 |
assert core_auth.map_core_roles_to_internal(role_names) == expected
|
| 171 |
-
|
| 172 |
-
|
| 173 |
-
# ─── get_current_user (flujo completo, auth_mode="core") ───────────────────
|
| 174 |
-
|
| 175 |
-
|
| 176 |
-
def test_get_current_user_core_administrativo(rsa_keypair, monkeypatch, core_mode):
|
| 177 |
-
private_pem, public_pem = rsa_keypair
|
| 178 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 179 |
-
_stub_roles(monkeypatch, {7: ["admin_internacion"]})
|
| 180 |
-
token = _make_token(private_pem, user_id=7)
|
| 181 |
-
|
| 182 |
-
user = _get_current_user_core(token)
|
| 183 |
-
|
| 184 |
-
assert user["sub"] == "7"
|
| 185 |
-
assert user["rol"] == "ADMINISTRATIVO"
|
| 186 |
-
|
| 187 |
-
|
| 188 |
-
def test_get_current_user_core_medico(rsa_keypair, monkeypatch, core_mode):
|
| 189 |
-
private_pem, public_pem = rsa_keypair
|
| 190 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 191 |
-
_stub_roles(monkeypatch, {9: ["Medico"]})
|
| 192 |
-
token = _make_token(private_pem, user_id=9)
|
| 193 |
-
|
| 194 |
-
user = _get_current_user_core(token)
|
| 195 |
-
|
| 196 |
-
assert user["rol"] == "MEDICO"
|
| 197 |
-
|
| 198 |
-
|
| 199 |
-
def test_get_current_user_core_limpieza(rsa_keypair, monkeypatch, core_mode):
|
| 200 |
-
private_pem, public_pem = rsa_keypair
|
| 201 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 202 |
-
_stub_roles(monkeypatch, {8: ["limpieza"]})
|
| 203 |
-
token = _make_token(private_pem, user_id=8)
|
| 204 |
-
|
| 205 |
-
user = _get_current_user_core(token)
|
| 206 |
-
|
| 207 |
-
assert user["rol"] == "LIMPIEZA"
|
| 208 |
-
|
| 209 |
-
|
| 210 |
-
def test_get_current_user_core_rol_no_mapeado_403(rsa_keypair, monkeypatch, core_mode):
|
| 211 |
-
private_pem, public_pem = rsa_keypair
|
| 212 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 213 |
-
_stub_roles(monkeypatch, {10: ["Enfermero"]})
|
| 214 |
-
token = _make_token(private_pem, user_id=10)
|
| 215 |
-
|
| 216 |
-
with pytest.raises(HTTPException) as exc_info:
|
| 217 |
-
_get_current_user_core(token)
|
| 218 |
-
|
| 219 |
-
assert exc_info.value.status_code == 403
|
| 220 |
-
|
| 221 |
-
|
| 222 |
-
def test_get_current_user_core_sin_rol_403(rsa_keypair, monkeypatch, core_mode):
|
| 223 |
-
private_pem, public_pem = rsa_keypair
|
| 224 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 225 |
-
_stub_roles(monkeypatch, {}) # usuario sin roles asignados en el Core
|
| 226 |
-
token = _make_token(private_pem, user_id=11)
|
| 227 |
-
|
| 228 |
-
with pytest.raises(HTTPException) as exc_info:
|
| 229 |
-
_get_current_user_core(token)
|
| 230 |
-
|
| 231 |
-
assert exc_info.value.status_code == 403
|
| 232 |
-
|
| 233 |
-
|
| 234 |
-
def test_get_current_user_core_token_invalido_401(rsa_keypair, monkeypatch, core_mode):
|
| 235 |
-
_, public_pem = rsa_keypair
|
| 236 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 237 |
-
|
| 238 |
-
with pytest.raises(HTTPException) as exc_info:
|
| 239 |
-
_get_current_user_core("token-basura")
|
| 240 |
-
|
| 241 |
-
assert exc_info.value.status_code == 401
|
| 242 |
-
|
| 243 |
-
|
| 244 |
-
def test_get_current_user_core_expirado_401(rsa_keypair, monkeypatch, core_mode):
|
| 245 |
-
private_pem, public_pem = rsa_keypair
|
| 246 |
-
_stub_jwks(monkeypatch, public_pem)
|
| 247 |
-
token = _make_token(private_pem, user_id=12, exp_delta=-10)
|
| 248 |
-
|
| 249 |
-
with pytest.raises(HTTPException) as exc_info:
|
| 250 |
-
_get_current_user_core(token)
|
| 251 |
-
|
| 252 |
-
assert exc_info.value.status_code == 401
|
|
|
|
| 1 |
"""
|
| 2 |
+
Tests de `app/integrations/core_auth.py`: mapeo de roles del Core al rol
|
| 3 |
+
interno de M6.
|
| 4 |
+
|
| 5 |
+
La verificación de JWT del Core vía JWKS y el lookup de roles (`GET /roles`)
|
| 6 |
+
se eliminaron: la sesión de M6 es siempre un JWT HS256 propio, y el rol se
|
| 7 |
+
resuelve una única vez en el canje SSO (ver `tests/test_sso.py`), a partir
|
| 8 |
+
de `user.roles[]`. Este módulo cubre exclusivamente lo que sigue vigente:
|
| 9 |
+
la traducción de nombres de rol de Core a rol interno de M6.
|
|
|
|
|
|
|
|
|
|
|
|
|
| 10 |
"""
|
|
|
|
|
|
|
| 11 |
import pytest
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 12 |
|
|
|
|
|
|
|
| 13 |
from app.integrations import core_auth
|
| 14 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 15 |
|
| 16 |
@pytest.mark.parametrize(
|
| 17 |
"role_names,expected",
|
|
|
|
| 29 |
)
|
| 30 |
def test_map_core_roles_to_internal(role_names, expected):
|
| 31 |
assert core_auth.map_core_roles_to_internal(role_names) == expected
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
tests/test_sso.py
ADDED
|
@@ -0,0 +1,111 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Tests de `POST /api/v1/auth/sso-exchange`: canje de ticket SSO del Core por
|
| 3 |
+
una sesión propia de M6 (JWT HS256 con el rol resuelto desde `user.roles[]`
|
| 4 |
+
de la respuesta del canje — ver `app/routers/auth.py`).
|
| 5 |
+
|
| 6 |
+
No golpean el Core real: se stubea `core_auth.exchange_sso_ticket`.
|
| 7 |
+
"""
|
| 8 |
+
import pytest
|
| 9 |
+
|
| 10 |
+
from app.config import settings
|
| 11 |
+
from app.dependencies import decode_token
|
| 12 |
+
from app.integrations import core_auth
|
| 13 |
+
|
| 14 |
+
|
| 15 |
+
def _core_user(roles: list[str], user_id: int = 42) -> dict:
|
| 16 |
+
return {
|
| 17 |
+
"id": user_id,
|
| 18 |
+
"first_name": "Ana",
|
| 19 |
+
"last_name": "Pérez",
|
| 20 |
+
"email": "ana@example.com",
|
| 21 |
+
"roles": [{"id": i, "name": name} for i, name in enumerate(roles)],
|
| 22 |
+
}
|
| 23 |
+
|
| 24 |
+
|
| 25 |
+
@pytest.fixture
|
| 26 |
+
def sso_enabled(monkeypatch):
|
| 27 |
+
monkeypatch.setattr(settings, "sso_enabled", True)
|
| 28 |
+
|
| 29 |
+
|
| 30 |
+
def test_sso_exchange_ok(client, monkeypatch, sso_enabled):
|
| 31 |
+
monkeypatch.setattr(
|
| 32 |
+
core_auth,
|
| 33 |
+
"exchange_sso_ticket",
|
| 34 |
+
lambda ticket: {"user": _core_user(["admin_internacion"]), "token": "core-jwt"},
|
| 35 |
+
)
|
| 36 |
+
|
| 37 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket-valido"})
|
| 38 |
+
|
| 39 |
+
assert resp.status_code == 200
|
| 40 |
+
body = resp.json()
|
| 41 |
+
assert body["rol"] == "ADMINISTRATIVO"
|
| 42 |
+
assert body["user"]["id"] == 42
|
| 43 |
+
assert body["user"]["email"] == "ana@example.com"
|
| 44 |
+
|
| 45 |
+
payload = decode_token(body["token"])
|
| 46 |
+
assert payload["sub"] == "42"
|
| 47 |
+
assert payload["rol"] == "ADMINISTRATIVO"
|
| 48 |
+
|
| 49 |
+
|
| 50 |
+
def test_sso_exchange_medico(client, monkeypatch, sso_enabled):
|
| 51 |
+
monkeypatch.setattr(
|
| 52 |
+
core_auth,
|
| 53 |
+
"exchange_sso_ticket",
|
| 54 |
+
lambda ticket: {"user": _core_user(["Medico"], user_id=9), "token": "core-jwt"},
|
| 55 |
+
)
|
| 56 |
+
|
| 57 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "otro-ticket"})
|
| 58 |
+
|
| 59 |
+
assert resp.status_code == 200
|
| 60 |
+
assert resp.json()["rol"] == "MEDICO"
|
| 61 |
+
|
| 62 |
+
|
| 63 |
+
def test_sso_exchange_ticket_invalido_401(client, monkeypatch, sso_enabled):
|
| 64 |
+
def _raise(ticket):
|
| 65 |
+
raise core_auth.SSOTicketInvalid("expirado")
|
| 66 |
+
|
| 67 |
+
monkeypatch.setattr(core_auth, "exchange_sso_ticket", _raise)
|
| 68 |
+
|
| 69 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "usado-o-expirado"})
|
| 70 |
+
|
| 71 |
+
assert resp.status_code == 401
|
| 72 |
+
assert resp.json()["detail"]["codigo"] == "NO_AUTENTICADO"
|
| 73 |
+
|
| 74 |
+
|
| 75 |
+
def test_sso_exchange_core_inalcanzable_502(client, monkeypatch, sso_enabled):
|
| 76 |
+
def _raise(ticket):
|
| 77 |
+
raise core_auth.SSOExchangeError("timeout")
|
| 78 |
+
|
| 79 |
+
monkeypatch.setattr(core_auth, "exchange_sso_ticket", _raise)
|
| 80 |
+
|
| 81 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
|
| 82 |
+
|
| 83 |
+
assert resp.status_code == 502
|
| 84 |
+
assert resp.json()["detail"]["codigo"] == "SERVICIO_EXTERNO_NO_DISPONIBLE"
|
| 85 |
+
|
| 86 |
+
|
| 87 |
+
def test_sso_exchange_rol_no_mapeado_403(client, monkeypatch, sso_enabled):
|
| 88 |
+
monkeypatch.setattr(
|
| 89 |
+
core_auth,
|
| 90 |
+
"exchange_sso_ticket",
|
| 91 |
+
lambda ticket: {"user": _core_user(["Enfermero"], user_id=10), "token": "core-jwt"},
|
| 92 |
+
)
|
| 93 |
+
|
| 94 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
|
| 95 |
+
|
| 96 |
+
assert resp.status_code == 403
|
| 97 |
+
assert resp.json()["detail"]["codigo"] == "NO_AUTORIZADO"
|
| 98 |
+
|
| 99 |
+
|
| 100 |
+
def test_sso_exchange_ticket_vacio_422(client, sso_enabled):
|
| 101 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": ""})
|
| 102 |
+
|
| 103 |
+
assert resp.status_code == 422
|
| 104 |
+
|
| 105 |
+
|
| 106 |
+
def test_sso_exchange_deshabilitado_404(client, monkeypatch):
|
| 107 |
+
monkeypatch.setattr(settings, "sso_enabled", False)
|
| 108 |
+
|
| 109 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
|
| 110 |
+
|
| 111 |
+
assert resp.status_code == 404
|