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:
+33
-17
@@ -1,6 +1,8 @@
|
||||
# ==============================================================================
|
||||
# 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 fastapi import APIRouter, Response, Request, HTTPException, status, Depends
|
||||
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
||||
@@ -16,23 +18,24 @@ def get_current_user_payload(
|
||||
request: Request,
|
||||
bearer: Optional[HTTPAuthorizationCredentials] = Depends(security_bearer),
|
||||
) -> 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")
|
||||
if not token and bearer:
|
||||
token = bearer.credentials
|
||||
payload = decodificar_access_token(token) if token else None
|
||||
|
||||
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(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
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
|
||||
|
||||
|
||||
@@ -41,21 +44,33 @@ obtener_usuario_actual = get_current_user_payload
|
||||
|
||||
@router.post("/login", response_model=LoginResponse, summary="Iniciar sesión de operador")
|
||||
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(
|
||||
username=login_req.username,
|
||||
password_raw=login_req.password,
|
||||
workstation_name=login_req.workstation_name,
|
||||
expires_delta=delta,
|
||||
)
|
||||
|
||||
# Cookie HttpOnly segura
|
||||
# Cookie HttpOnly persistente
|
||||
response.set_cookie(
|
||||
key="access_token",
|
||||
value=token,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
secure=False, # En LAN sin HTTPS directo se permite False; en Nginx SSL pasará a True
|
||||
max_age=1800, # 30 minutos
|
||||
secure=False, # Permite HTTP en LAN y HTTPS en PWA
|
||||
max_age=max_age_seg,
|
||||
path="/",
|
||||
)
|
||||
|
||||
return res_dto
|
||||
@@ -64,15 +79,16 @@ async def login(login_req: LoginRequest, response: Response):
|
||||
@router.post("/logout", summary="Cerrar sesión")
|
||||
async def logout(response: Response):
|
||||
"""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"}
|
||||
|
||||
|
||||
@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)):
|
||||
"""Retorna la información del usuario autenticado."""
|
||||
"""Retorna la información del usuario autenticado preservando rol y parámetros."""
|
||||
return UserSessionDTO(
|
||||
user_id=int(payload["sub"]),
|
||||
username=payload["username"],
|
||||
role="OPERADOR",
|
||||
role=payload.get("role", "OPERADOR"),
|
||||
system_parameter=payload.get("system_parameter"),
|
||||
)
|
||||
|
||||
@@ -46,8 +46,8 @@ class Settings(BaseSettings):
|
||||
|
||||
# Seguridad JWT
|
||||
SECRET_KEY: str = "dev_secret_key_change_in_production_min_32_chars_1234567890"
|
||||
ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
|
||||
REFRESH_TOKEN_EXPIRE_DAYS: int = 7
|
||||
ACCESS_TOKEN_EXPIRE_MINUTES: int = 43200 # 30 días para puestos de control / tablets persistentes
|
||||
REFRESH_TOKEN_EXPIRE_DAYS: int = 30
|
||||
|
||||
# Estación por Defecto
|
||||
DEFAULT_WORKSTATION_NAME: str = "GARITA_PRINCIPAL"
|
||||
|
||||
@@ -9,6 +9,7 @@ class LoginRequest(BaseModel):
|
||||
username: str = Field(..., min_length=1, description="Nombre de usuario del operador")
|
||||
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")
|
||||
remember_me: bool = Field(True, description="Si es True, mantiene la sesión activa de forma persistente (30 días)")
|
||||
|
||||
|
||||
class UserSessionDTO(BaseModel):
|
||||
@@ -23,3 +24,5 @@ class LoginResponse(BaseModel):
|
||||
message: str = "Autenticación exitosa"
|
||||
user: UserSessionDTO
|
||||
workstation: Optional[str] = None
|
||||
token: Optional[str] = None
|
||||
token_type: str = "bearer"
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Autenticación y Control de Sesión
|
||||
# ==============================================================================
|
||||
from datetime import timedelta
|
||||
from typing import Optional, Tuple
|
||||
from fastapi import HTTPException, status
|
||||
from app.repositories.auth_repository import AuthRepository
|
||||
@@ -11,7 +12,10 @@ from app.schemas.auth_schema import LoginResponse, UserSessionDTO
|
||||
class AuthService:
|
||||
@staticmethod
|
||||
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]:
|
||||
"""Valida credenciales, genera token JWT y registra auditoría."""
|
||||
user_row = AuthRepository.obtener_usuario_por_nombre(username)
|
||||
@@ -31,14 +35,17 @@ class AuthService:
|
||||
user_id = user_row["UsuarioID"]
|
||||
nombre = user_row["Nombre"].strip()
|
||||
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 = {
|
||||
"sub": str(user_id),
|
||||
"username": nombre,
|
||||
"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
|
||||
AuthRepository.registrar_evento_login(user_id)
|
||||
@@ -46,7 +53,7 @@ class AuthService:
|
||||
user_dto = UserSessionDTO(
|
||||
user_id=user_id,
|
||||
username=nombre,
|
||||
role="SUPERVISOR" if system_param == 1 else "OPERADOR",
|
||||
role=role,
|
||||
system_parameter=system_param,
|
||||
)
|
||||
|
||||
@@ -55,6 +62,8 @@ class AuthService:
|
||||
message="Autenticación exitosa",
|
||||
user=user_dto,
|
||||
workstation=workstation_name,
|
||||
token=token,
|
||||
token_type="bearer",
|
||||
)
|
||||
|
||||
return response, token
|
||||
|
||||
@@ -67,3 +67,28 @@ async def test_me_con_sesion_activa_y_logout():
|
||||
# 3. Logout
|
||||
logout_res = await client.post("/api/v1/auth/logout")
|
||||
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"
|
||||
|
||||
@@ -8,13 +8,20 @@ export interface LoginResponse {
|
||||
status: string;
|
||||
user: UserSession;
|
||||
workstation: string;
|
||||
token?: string;
|
||||
token_type?: string;
|
||||
}
|
||||
|
||||
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', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ username, password, workstation_name }),
|
||||
body: JSON.stringify({ username, password, workstation_name, remember_me }),
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
@@ -24,6 +24,12 @@ export async function request<T>(endpoint: string, options: RequestInit = {}): P
|
||||
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, {
|
||||
...options,
|
||||
headers,
|
||||
|
||||
@@ -11,7 +11,12 @@ interface AuthContextType {
|
||||
setWorkstation: (name: string) => void;
|
||||
isAuthenticated: 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>;
|
||||
}
|
||||
|
||||
@@ -34,6 +39,8 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
|
||||
const me = await authApi.getMe();
|
||||
setUser(me);
|
||||
} catch {
|
||||
// Sesión expirada o token inválido
|
||||
localStorage.removeItem('on_ever_token');
|
||||
setUser(null);
|
||||
} finally {
|
||||
setLoading(false);
|
||||
@@ -44,9 +51,28 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
|
||||
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 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);
|
||||
if (res.workstation) {
|
||||
setWorkstation(res.workstation);
|
||||
@@ -57,6 +83,8 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
|
||||
try {
|
||||
await authApi.logout();
|
||||
} finally {
|
||||
localStorage.removeItem('on_ever_token');
|
||||
sessionStorage.removeItem('on_ever_token');
|
||||
setUser(null);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -13,9 +13,15 @@ export const LoginView: React.FC = () => {
|
||||
const { login, workstation, setWorkstation } = useAuth();
|
||||
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 [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 [availableWorkstations, setAvailableWorkstations] = useState<WorkstationListItem[]>([]);
|
||||
const [isLoading, setIsLoading] = useState<boolean>(false);
|
||||
@@ -57,7 +63,7 @@ export const LoginView: React.FC = () => {
|
||||
|
||||
try {
|
||||
setWorkstation(selectedWks);
|
||||
await login(username.trim(), password, selectedWks);
|
||||
await login(username.trim(), password, selectedWks, rememberMe);
|
||||
} catch (err: any) {
|
||||
setErrorMsg(err.message || 'Credenciales inválidas. Verifique usuario o contraseña.');
|
||||
} finally {
|
||||
@@ -317,6 +323,9 @@ export const LoginView: React.FC = () => {
|
||||
<span>👤</span> Usuario
|
||||
</label>
|
||||
<input
|
||||
id="username"
|
||||
name="username"
|
||||
autoComplete="username"
|
||||
type="text"
|
||||
value={username}
|
||||
onChange={(e) => setUsername(e.target.value)}
|
||||
@@ -380,6 +389,9 @@ export const LoginView: React.FC = () => {
|
||||
id="passwordContainer"
|
||||
>
|
||||
<input
|
||||
id="password"
|
||||
name="password"
|
||||
autoComplete="current-password"
|
||||
type={showPassword ? 'text' : 'password'}
|
||||
value={password}
|
||||
onChange={(e) => setPassword(e.target.value)}
|
||||
@@ -435,6 +447,50 @@ export const LoginView: React.FC = () => {
|
||||
</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) */}
|
||||
{errorMsg && (
|
||||
<div
|
||||
|
||||
Reference in New Issue
Block a user