diff --git a/extensions/pagetop-user/src/account.rs b/extensions/pagetop-user/src/account.rs index bed570b2..c511c8e5 100644 --- a/extensions/pagetop-user/src/account.rs +++ b/extensions/pagetop-user/src/account.rs @@ -36,22 +36,19 @@ impl UserStatus { // **< PermissionSet >****************************************************************************** -/// Conjunto de permisos resuelto para un usuario concreto. +// Conjunto de permisos resuelto para una petición: los de una cuenta autenticada o, sin sesión, los +// del rol "anonymous". #[derive(AutoDefault, Clone, Debug)] -pub struct PermissionSet(HashSet); +pub(crate) struct PermissionSet(HashSet); impl PermissionSet { - pub fn new(keys: impl IntoIterator) -> Self { + pub(crate) fn new(keys: impl IntoIterator) -> Self { PermissionSet(keys.into_iter().collect()) } - pub fn contains(&self, key: &str) -> bool { + pub(crate) fn contains(&self, key: &str) -> bool { self.0.contains(key) } - - pub fn extend(&mut self, keys: impl IntoIterator) { - self.0.extend(keys); - } } // **< Account >************************************************************************************ @@ -74,9 +71,6 @@ pub struct Account { /// Estado de la cuenta. #[getters(copy)] status: UserStatus, - /// Nombres de máquina de los roles asignados explícitamente. No incluye "authenticated", que - /// es implícito (ver [`Account::has_role`]). - roles: Vec, // Unión de permisos de sus roles y del rol implícito "authenticated". Vacío si es // administrador: no se cargan porque `has_permission()` ya concede todos. Sin getter para que // la única consulta posible sea `has_permission()`. @@ -91,14 +85,13 @@ pub struct Account { impl Account { // Sólo se construye desde la carga de sesión, para que ningún otro crate pueda fabricar una // cuenta e inyectarla en la petición. - pub(crate) fn new(user: user::Model, roles: Vec, permissions: PermissionSet) -> Self { + pub(crate) fn new(user: user::Model, permissions: PermissionSet) -> Self { Account { id: user.id, username: user.username, email: user.email, display_name: user.display_name.unwrap_or_default(), status: UserStatus::from_i16(user.status), - roles, permissions, is_admin: user.is_admin, } @@ -117,9 +110,4 @@ impl Account { self.display_name() } } - - /// Comprueba si la cuenta tiene el rol indicado ("authenticated" siempre se cumple). - pub fn has_role(&self, machine_name: &str) -> bool { - machine_name == "authenticated" || self.roles().iter().any(|r| r == machine_name) - } } diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index eddda73b..20c4672f 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -23,8 +23,8 @@ struct AnonymousPermissions(Arc); /// petición HTTP. /// /// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado). -/// - Si hay sesión activa, inserta también el [`Account`] con roles y permisos; si no, los permisos -/// del rol "anonymous". +/// - Si hay sesión activa, inserta también el [`Account`] con sus permisos; si no, los permisos del +/// rol "anonymous". /// - Si se ha prorrogado una sesión iniciada con "recordarme", renueva su cookie en la respuesta. pub(crate) async fn session_middleware( mut req: web::Request, diff --git a/extensions/pagetop-user/src/session.rs b/extensions/pagetop-user/src/session.rs index 97737fa0..af84528f 100644 --- a/extensions/pagetop-user/src/session.rs +++ b/extensions/pagetop-user/src/session.rs @@ -12,7 +12,7 @@ use pagetop_seaorm::db::{Condition, DbErr, Set, dbconn}; use crate::account::{Account, PermissionSet, UserStatus}; use crate::config::SETTINGS; -use crate::entity::{role, role_permission, session, user, user_role}; +use crate::entity::{role_permission, session, user, user_role}; use crate::{ANONYMOUS_ROLE_ID, AUTHENTICATED_ROLE_ID}; // **< Generación de session ID >******************************************************************* @@ -84,8 +84,8 @@ pub fn extract_sid(headers: Option<&web::http::HeaderMap>) -> Option<&str> { /// Lee la cookie de sesión de las cabeceras y resuelve la terna /// `(CurrentUser, Option, Option)` de [`load_user_from_session`]. /// -/// Si no hay una cookie de sesión válida, o la sesión no existe o ha expirado, devuelve -/// `(CurrentUser::anonymous(), None, None)`. Se llama desde el middleware de sesión, que es async. +/// Si no hay una cookie de sesión válida, o [`load_user_from_session`] no resuelve la sesión, +/// devuelve `(CurrentUser::anonymous(), None, None)`. Se llama desde el middleware de sesión. pub async fn resolve_session( headers: &web::http::HeaderMap, ) -> (CurrentUser, Option, Option) { @@ -103,7 +103,8 @@ pub async fn resolve_session( /// Devuelve la terna `(CurrentUser, Option, Option)`, cuyo tercer elemento es la /// cabecera `Set-Cookie` que renueva la cookie persistente cuando se prorroga una sesión iniciada /// con "recordarme". Devuelve `(CurrentUser::anonymous(), None, None)` si la sesión no existe o ha -/// expirado. +/// expirado, si la cuenta no está activa (p. ej. bloqueada tras iniciar la sesión) o si falla la +/// consulta, que se registra como aviso. pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option, Option) { let now = Utc::now(); @@ -124,53 +125,43 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option, return (CurrentUser::anonymous(), None, None); } - // Roles explícitos del usuario más el implícito "authenticated" (no se asigna en `user_role` - // pero se aplica siempre), con sus permisos, en una sola consulta: una fila por permiso, o una - // sin permiso si el rol no tiene ninguno. "anonymous" se excluye aunque figure en `user_role` - // (p. ej. insertado directamente en la base de datos): sus permisos nunca llegan a una cuenta. - let rows = role::Entity::find() - .select_only() - .columns([role::Column::Id, role::Column::MachineName]) - .column(role_permission::Column::PermissionKey) - .left_join(role_permission::Entity) - .filter( - Condition::any() - .add( - role::Column::Id.in_subquery( - Query::select() - .column(user_role::Column::RoleId) - .from(user_role::Entity) - .and_where(user_role::Column::UserId.eq(sess.user_id)) - .and_where(user_role::Column::RoleId.ne(ANONYMOUS_ROLE_ID)) - .to_owned(), - ), - ) - .add(role::Column::Id.eq(AUTHENTICATED_ROLE_ID)), - ) - .into_tuple::<(i32, String, Option)>() - .all(dbconn()) - .await; - let rows = match rows { - Ok(rows) => rows, - Err(err) => { - trace::warn!("session: failed to load roles and permissions: {err}"); - return (CurrentUser::anonymous(), None, None); + // Un administrador tiene todos los permisos (ver `Account::has_permission`): no se cargan. + // Si no, se leen en una sola consulta los de sus roles más los del implícito "authenticated", + // que no se asigna en `user_role` pero se aplica siempre. "anonymous" se excluye aunque figure + // en `user_role` (p. ej. insertado directamente en la base de datos): sus permisos nunca llegan + // a una cuenta. + let permissions = if user_model.is_admin { + PermissionSet::default() + } else { + let keys = role_permission::Entity::find() + .select_only() + .column(role_permission::Column::PermissionKey) + .filter( + Condition::any() + .add( + role_permission::Column::RoleId.in_subquery( + Query::select() + .column(user_role::Column::RoleId) + .from(user_role::Entity) + .and_where(user_role::Column::UserId.eq(sess.user_id)) + .and_where(user_role::Column::RoleId.ne(ANONYMOUS_ROLE_ID)) + .to_owned(), + ), + ) + .add(role_permission::Column::RoleId.eq(AUTHENTICATED_ROLE_ID)), + ) + .into_tuple::() + .all(dbconn()) + .await; + match keys { + Ok(keys) => PermissionSet::new(keys), + Err(err) => { + trace::warn!("session: failed to load permissions: {err}"); + return (CurrentUser::anonymous(), None, None); + } } }; - // Un administrador tiene todos los permisos: no hace falta guardar los de sus roles. - let is_admin = user_model.is_admin; - let mut role_names: Vec = Vec::new(); - let mut permissions = PermissionSet::default(); - for (role_id, machine_name, key) in rows { - if role_id != AUTHENTICATED_ROLE_ID && !role_names.contains(&machine_name) { - role_names.push(machine_name); - } - if !is_admin { - permissions.extend(key); - } - } - let mut renewed_cookie = None; if let Some(expires_at) = renewed_expiry( sess.last_activity_at, @@ -197,7 +188,7 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option, let language = user_model.language.take(); let timezone = user_model.timezone.take(); let theme = user_model.theme.take(); - let account = Account::new(user_model, role_names, permissions); + let account = Account::new(user_model, permissions); let current_user = CurrentUser::authenticated(account.id(), account.display()) .with_language(language.as_deref()) .with_timezone(timezone.as_deref())