feat(auth): add persistent login session for tablets and PWA (double-channel cookie + bearer token, 30 days remember-me, credential autofill)

This commit is contained in:
Carlos Tello
2026-10-30 22:30:40 -03:00
parent 8620a0e71f
commit e596ca87a4
9 changed files with 180 additions and 30 deletions
+33 -17
View File
@@ -1,6 +1,8 @@
# ============================================================================== # ==============================================================================
# Endpoints de Autenticación (/api/v1/auth) # Endpoints de Autenticación (/api/v1/auth)
# Soporte de persistencia extendida para PWA/Tablets y Doble Canal (Cookie + Bearer)
# ============================================================================== # ==============================================================================
from datetime import timedelta
from typing import Optional from typing import Optional
from fastapi import APIRouter, Response, Request, HTTPException, status, Depends from fastapi import APIRouter, Response, Request, HTTPException, status, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
@@ -16,23 +18,24 @@ def get_current_user_payload(
request: Request, request: Request,
bearer: Optional[HTTPAuthorizationCredentials] = Depends(security_bearer), bearer: Optional[HTTPAuthorizationCredentials] = Depends(security_bearer),
) -> dict: ) -> dict:
"""Extrae el token JWT desde la cookie HttpOnly o el header Bearer.""" """
Extrae y valida el token JWT desde la cookie HttpOnly o el header Bearer.
Si la cookie expiró o no está presente, intenta validar el token Bearer (crítico para PWA/tablets).
"""
token = request.cookies.get("access_token") token = request.cookies.get("access_token")
if not token and bearer: payload = decodificar_access_token(token) if token else None
token = bearer.credentials
if not token: # Fallback transparente a Authorization: Bearer
if not payload and bearer and bearer.credentials:
token = bearer.credentials
payload = decodificar_access_token(token)
if not payload:
raise HTTPException( raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED, status_code=status.HTTP_401_UNAUTHORIZED,
detail="No se encontró una sesión activa o token válido", detail="No se encontró una sesión activa o token válido",
) )
payload = decodificar_access_token(token)
if not payload:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Token inválido o expirado",
)
return payload return payload
@@ -41,21 +44,33 @@ obtener_usuario_actual = get_current_user_payload
@router.post("/login", response_model=LoginResponse, summary="Iniciar sesión de operador") @router.post("/login", response_model=LoginResponse, summary="Iniciar sesión de operador")
async def login(login_req: LoginRequest, response: Response): async def login(login_req: LoginRequest, response: Response):
"""Autentica al guardia o supervisor y emite una cookie HttpOnly con JWT.""" """
Autentica al guardia o supervisor. Emite cookie persistente y token JWT en el body
para que la sesión permanezca conectada en tablets, navegadores y PWAs.
"""
if login_req.remember_me:
delta = timedelta(days=30)
max_age_seg = 30 * 24 * 3600 # 30 días
else:
delta = timedelta(hours=12)
max_age_seg = 12 * 3600 # 12 horas (turno guardia)
res_dto, token = AuthService.autenticar_usuario( res_dto, token = AuthService.autenticar_usuario(
username=login_req.username, username=login_req.username,
password_raw=login_req.password, password_raw=login_req.password,
workstation_name=login_req.workstation_name, workstation_name=login_req.workstation_name,
expires_delta=delta,
) )
# Cookie HttpOnly segura # Cookie HttpOnly persistente
response.set_cookie( response.set_cookie(
key="access_token", key="access_token",
value=token, value=token,
httponly=True, httponly=True,
samesite="lax", samesite="lax",
secure=False, # En LAN sin HTTPS directo se permite False; en Nginx SSL pasará a True secure=False, # Permite HTTP en LAN y HTTPS en PWA
max_age=1800, # 30 minutos max_age=max_age_seg,
path="/",
) )
return res_dto return res_dto
@@ -64,15 +79,16 @@ async def login(login_req: LoginRequest, response: Response):
@router.post("/logout", summary="Cerrar sesión") @router.post("/logout", summary="Cerrar sesión")
async def logout(response: Response): async def logout(response: Response):
"""Elimina la cookie de sesión activa.""" """Elimina la cookie de sesión activa."""
response.delete_cookie(key="access_token") response.delete_cookie(key="access_token", path="/")
return {"status": "ok", "message": "Sesión cerrada exitosamente"} return {"status": "ok", "message": "Sesión cerrada exitosamente"}
@router.get("/me", response_model=UserSessionDTO, summary="Obtener usuario actual en sesión") @router.get("/me", response_model=UserSessionDTO, summary="Obtener usuario actual en sesión")
async def get_current_user(payload: dict = Depends(get_current_user_payload)): async def get_current_user(payload: dict = Depends(get_current_user_payload)):
"""Retorna la información del usuario autenticado.""" """Retorna la información del usuario autenticado preservando rol y parámetros."""
return UserSessionDTO( return UserSessionDTO(
user_id=int(payload["sub"]), user_id=int(payload["sub"]),
username=payload["username"], username=payload["username"],
role="OPERADOR", role=payload.get("role", "OPERADOR"),
system_parameter=payload.get("system_parameter"),
) )
+2 -2
View File
@@ -46,8 +46,8 @@ class Settings(BaseSettings):
# Seguridad JWT # Seguridad JWT
SECRET_KEY: str = "dev_secret_key_change_in_production_min_32_chars_1234567890" SECRET_KEY: str = "dev_secret_key_change_in_production_min_32_chars_1234567890"
ACCESS_TOKEN_EXPIRE_MINUTES: int = 30 ACCESS_TOKEN_EXPIRE_MINUTES: int = 43200 # 30 días para puestos de control / tablets persistentes
REFRESH_TOKEN_EXPIRE_DAYS: int = 7 REFRESH_TOKEN_EXPIRE_DAYS: int = 30
# Estación por Defecto # Estación por Defecto
DEFAULT_WORKSTATION_NAME: str = "GARITA_PRINCIPAL" DEFAULT_WORKSTATION_NAME: str = "GARITA_PRINCIPAL"
+3
View File
@@ -9,6 +9,7 @@ class LoginRequest(BaseModel):
username: str = Field(..., min_length=1, description="Nombre de usuario del operador") username: str = Field(..., min_length=1, description="Nombre de usuario del operador")
password: str = Field(..., min_length=1, description="Contraseña de acceso") password: str = Field(..., min_length=1, description="Contraseña de acceso")
workstation_name: Optional[str] = Field(None, description="Identificador de la estación de trabajo/tablet") workstation_name: Optional[str] = Field(None, description="Identificador de la estación de trabajo/tablet")
remember_me: bool = Field(True, description="Si es True, mantiene la sesión activa de forma persistente (30 días)")
class UserSessionDTO(BaseModel): class UserSessionDTO(BaseModel):
@@ -23,3 +24,5 @@ class LoginResponse(BaseModel):
message: str = "Autenticación exitosa" message: str = "Autenticación exitosa"
user: UserSessionDTO user: UserSessionDTO
workstation: Optional[str] = None workstation: Optional[str] = None
token: Optional[str] = None
token_type: str = "bearer"
+13 -4
View File
@@ -1,6 +1,7 @@
# ============================================================================== # ==============================================================================
# Servicio de Autenticación y Control de Sesión # Servicio de Autenticación y Control de Sesión
# ============================================================================== # ==============================================================================
from datetime import timedelta
from typing import Optional, Tuple from typing import Optional, Tuple
from fastapi import HTTPException, status from fastapi import HTTPException, status
from app.repositories.auth_repository import AuthRepository from app.repositories.auth_repository import AuthRepository
@@ -11,7 +12,10 @@ from app.schemas.auth_schema import LoginResponse, UserSessionDTO
class AuthService: class AuthService:
@staticmethod @staticmethod
def autenticar_usuario( def autenticar_usuario(
username: str, password_raw: str, workstation_name: Optional[str] = None username: str,
password_raw: str,
workstation_name: Optional[str] = None,
expires_delta: Optional[timedelta] = None,
) -> Tuple[LoginResponse, str]: ) -> Tuple[LoginResponse, str]:
"""Valida credenciales, genera token JWT y registra auditoría.""" """Valida credenciales, genera token JWT y registra auditoría."""
user_row = AuthRepository.obtener_usuario_por_nombre(username) user_row = AuthRepository.obtener_usuario_por_nombre(username)
@@ -31,14 +35,17 @@ class AuthService:
user_id = user_row["UsuarioID"] user_id = user_row["UsuarioID"]
nombre = user_row["Nombre"].strip() nombre = user_row["Nombre"].strip()
system_param = user_row.get("SystemParameter") system_param = user_row.get("SystemParameter")
role = "SUPERVISOR" if system_param == 1 else "OPERADOR"
# Generar Token JWT # Generar Token JWT con soporte de rol y parámetros de sesión
token_data = { token_data = {
"sub": str(user_id), "sub": str(user_id),
"username": nombre, "username": nombre,
"workstation": workstation_name or "", "workstation": workstation_name or "",
"role": role,
"system_parameter": system_param,
} }
token = crear_access_token(token_data) token = crear_access_token(token_data, expires_delta=expires_delta)
# Registrar auditoría en usrlogin # Registrar auditoría en usrlogin
AuthRepository.registrar_evento_login(user_id) AuthRepository.registrar_evento_login(user_id)
@@ -46,7 +53,7 @@ class AuthService:
user_dto = UserSessionDTO( user_dto = UserSessionDTO(
user_id=user_id, user_id=user_id,
username=nombre, username=nombre,
role="SUPERVISOR" if system_param == 1 else "OPERADOR", role=role,
system_parameter=system_param, system_parameter=system_param,
) )
@@ -55,6 +62,8 @@ class AuthService:
message="Autenticación exitosa", message="Autenticación exitosa",
user=user_dto, user=user_dto,
workstation=workstation_name, workstation=workstation_name,
token=token,
token_type="bearer",
) )
return response, token return response, token
+25
View File
@@ -67,3 +67,28 @@ async def test_me_con_sesion_activa_y_logout():
# 3. Logout # 3. Logout
logout_res = await client.post("/api/v1/auth/logout") logout_res = await client.post("/api/v1/auth/logout")
assert logout_res.status_code == 200 assert logout_res.status_code == 200
@pytest.mark.asyncio
async def test_login_con_remember_me_y_bearer_header():
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as client:
# 1. Login con remember_me=True
login_res = await client.post(
"/api/v1/auth/login",
json={"username": "guardia", "password": "guardia", "remember_me": True},
)
assert login_res.status_code == 200
data = login_res.json()
assert "token" in data and data["token"] is not None
assert data["token_type"] == "bearer"
raw_token = data["token"]
# 2. Consultar /me vía Header Bearer sin cookies (simula PWA o cliente desacoplado)
me_res = await client.get(
"/api/v1/auth/me",
headers={"Authorization": f"Bearer {raw_token}"},
)
assert me_res.status_code == 200
me_data = me_res.json()
assert me_data["username"].lower() == "guardia"
+9 -2
View File
@@ -8,13 +8,20 @@ export interface LoginResponse {
status: string; status: string;
user: UserSession; user: UserSession;
workstation: string; workstation: string;
token?: string;
token_type?: string;
} }
export const authApi = { export const authApi = {
login: (username: string, password: string, workstation_name: string) => { login: (
username: string,
password: string,
workstation_name: string,
remember_me: boolean = true
) => {
return request<LoginResponse>('/auth/login', { return request<LoginResponse>('/auth/login', {
method: 'POST', method: 'POST',
body: JSON.stringify({ username, password, workstation_name }), body: JSON.stringify({ username, password, workstation_name, remember_me }),
}); });
}, },
+6
View File
@@ -24,6 +24,12 @@ export async function request<T>(endpoint: string, options: RequestInit = {}): P
headers.set('Content-Type', 'application/json'); headers.set('Content-Type', 'application/json');
} }
// Token persistente en localStorage para soportar PWA, WebAPK y reconexión en tablets
const token = localStorage.getItem('on_ever_token');
if (token && !headers.has('Authorization')) {
headers.set('Authorization', `Bearer ${token}`);
}
const response = await fetch(url, { const response = await fetch(url, {
...options, ...options,
headers, headers,
+31 -3
View File
@@ -11,7 +11,12 @@ interface AuthContextType {
setWorkstation: (name: string) => void; setWorkstation: (name: string) => void;
isAuthenticated: boolean; isAuthenticated: boolean;
loading: boolean; loading: boolean;
login: (username: string, password: string, workstationName?: string) => Promise<void>; login: (
username: string,
password: string,
workstationName?: string,
rememberMe?: boolean
) => Promise<void>;
logout: () => Promise<void>; logout: () => Promise<void>;
} }
@@ -34,6 +39,8 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
const me = await authApi.getMe(); const me = await authApi.getMe();
setUser(me); setUser(me);
} catch { } catch {
// Sesión expirada o token inválido
localStorage.removeItem('on_ever_token');
setUser(null); setUser(null);
} finally { } finally {
setLoading(false); setLoading(false);
@@ -44,9 +51,28 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
checkSession(); checkSession();
}, [checkSession]); }, [checkSession]);
const login = async (username: string, password: string, workstationName?: string) => { const login = async (
username: string,
password: string,
workstationName?: string,
rememberMe: boolean = true
) => {
const targetWks = workstationName || workstation; const targetWks = workstationName || workstation;
const res = await authApi.login(username, password, targetWks); const res = await authApi.login(username, password, targetWks, rememberMe);
// Guardar token persistente para tablets/PWA si rememberMe está activo
if (res.token) {
if (rememberMe) {
localStorage.setItem('on_ever_token', res.token);
} else {
sessionStorage.setItem('on_ever_token', res.token);
}
}
// Guardar usuario y puesto en localStorage para el próximo inicio
localStorage.setItem('on_ever_username', username);
localStorage.setItem('on_ever_remember_me', rememberMe ? 'true' : 'false');
setUser(res.user); setUser(res.user);
if (res.workstation) { if (res.workstation) {
setWorkstation(res.workstation); setWorkstation(res.workstation);
@@ -57,6 +83,8 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
try { try {
await authApi.logout(); await authApi.logout();
} finally { } finally {
localStorage.removeItem('on_ever_token');
sessionStorage.removeItem('on_ever_token');
setUser(null); setUser(null);
} }
}; };
+58 -2
View File
@@ -13,9 +13,15 @@ export const LoginView: React.FC = () => {
const { login, workstation, setWorkstation } = useAuth(); const { login, workstation, setWorkstation } = useAuth();
const { theme, toggleTheme } = useTheme(); const { theme, toggleTheme } = useTheme();
const [username, setUsername] = useState<string>('guardia'); const [username, setUsername] = useState<string>(() => {
return localStorage.getItem('on_ever_username') || 'guardia';
});
const [password, setPassword] = useState<string>(''); const [password, setPassword] = useState<string>('');
const [showPassword, setShowPassword] = useState<boolean>(false); const [showPassword, setShowPassword] = useState<boolean>(false);
const [rememberMe, setRememberMe] = useState<boolean>(() => {
const saved = localStorage.getItem('on_ever_remember_me');
return saved !== null ? saved === 'true' : true;
});
const [selectedWks, setSelectedWks] = useState<string>(workstation || 'CFT-DESK'); const [selectedWks, setSelectedWks] = useState<string>(workstation || 'CFT-DESK');
const [availableWorkstations, setAvailableWorkstations] = useState<WorkstationListItem[]>([]); const [availableWorkstations, setAvailableWorkstations] = useState<WorkstationListItem[]>([]);
const [isLoading, setIsLoading] = useState<boolean>(false); const [isLoading, setIsLoading] = useState<boolean>(false);
@@ -57,7 +63,7 @@ export const LoginView: React.FC = () => {
try { try {
setWorkstation(selectedWks); setWorkstation(selectedWks);
await login(username.trim(), password, selectedWks); await login(username.trim(), password, selectedWks, rememberMe);
} catch (err: any) { } catch (err: any) {
setErrorMsg(err.message || 'Credenciales inválidas. Verifique usuario o contraseña.'); setErrorMsg(err.message || 'Credenciales inválidas. Verifique usuario o contraseña.');
} finally { } finally {
@@ -317,6 +323,9 @@ export const LoginView: React.FC = () => {
<span>👤</span> Usuario <span>👤</span> Usuario
</label> </label>
<input <input
id="username"
name="username"
autoComplete="username"
type="text" type="text"
value={username} value={username}
onChange={(e) => setUsername(e.target.value)} onChange={(e) => setUsername(e.target.value)}
@@ -380,6 +389,9 @@ export const LoginView: React.FC = () => {
id="passwordContainer" id="passwordContainer"
> >
<input <input
id="password"
name="password"
autoComplete="current-password"
type={showPassword ? 'text' : 'password'} type={showPassword ? 'text' : 'password'}
value={password} value={password}
onChange={(e) => setPassword(e.target.value)} onChange={(e) => setPassword(e.target.value)}
@@ -435,6 +447,50 @@ export const LoginView: React.FC = () => {
</div> </div>
</div> </div>
{/* Checkbox: Recordar sesión y permanecer conectado (PWA / Tablets) */}
<div
style={{
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
padding: '0.1rem 0.6rem',
}}
>
<label
style={{
display: 'flex',
alignItems: 'center',
gap: '0.55rem',
cursor: 'pointer',
fontSize: '0.84rem',
color: isDark ? '#94A3B8' : '#475569',
userSelect: 'none',
}}
>
<input
type="checkbox"
checked={rememberMe}
onChange={(e) => setRememberMe(e.target.checked)}
style={{
width: '18px',
height: '18px',
accentColor: '#2563EB',
cursor: 'pointer',
}}
/>
<span style={{ fontWeight: 600 }}>Permanecer conectado</span>
</label>
<span
style={{
fontSize: '0.72rem',
color: isDark ? '#64748B' : '#94A3B8',
fontStyle: 'italic',
}}
>
(Guardar sesión)
</span>
</div>
{/* Mensaje de Error (si ocurre) */} {/* Mensaje de Error (si ocurre) */}
{errorMsg && ( {errorMsg && (
<div <div