From 9ba493c2c4ff6214cb879dc739a2ac959ce6d26f Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 7 Nov 2026 15:18:41 +0100 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20(user):=20Usa=20el=20panel?= =?UTF-8?q?=20y=20el=20acceso=20del=20n=C3=BAcleo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit pagetop-user deja de depender de pagetop-admin: declara sus páginas en el panel del núcleo y monta sus rutas con su acceso. Quita las comprobaciones que repetían el permiso de la ruta y, con la acción AnonymousDenied, ofrece el inicio de sesión a un usuario anónimo sin acceso, también en las peticiones HTMX. --- Cargo.lock | 1 - extensions/pagetop-user/Cargo.toml | 1 - extensions/pagetop-user/README.md | 23 +- extensions/pagetop-user/src/account.rs | 2 + .../src/component/account_menu.rs | 3 +- .../src/component/admin/role_form.rs | 2 +- .../src/component/admin/role_table.rs | 12 +- .../src/component/admin/user_form.rs | 2 +- .../src/component/admin/user_table.rs | 10 +- .../pagetop-user/src/handlers/account.rs | 56 +++-- extensions/pagetop-user/src/handlers/admin.rs | 14 +- .../src/handlers/admin/permissions.rs | 23 +- .../pagetop-user/src/handlers/admin/roles.rs | 149 +++++------- .../pagetop-user/src/handlers/admin/users.rs | 138 +++++------ extensions/pagetop-user/src/lib.rs | 215 ++++++++++-------- extensions/pagetop-user/src/middleware.rs | 3 +- extensions/pagetop-user/src/permission.rs | 155 +------------ .../pagetop-user/src/service/role_admin.rs | 3 +- extensions/pagetop-user/tests/flows.rs | 32 +++ 19 files changed, 343 insertions(+), 501 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cf831a0a..24ba63ca 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2308,7 +2308,6 @@ dependencies = [ "argon2", "base64ct", "pagetop", - "pagetop-admin", "pagetop-htmx", "pagetop-mail", "pagetop-seaorm", diff --git a/extensions/pagetop-user/Cargo.toml b/extensions/pagetop-user/Cargo.toml index 637b2db7..24201896 100644 --- a/extensions/pagetop-user/Cargo.toml +++ b/extensions/pagetop-user/Cargo.toml @@ -20,7 +20,6 @@ demo-data = [] [dependencies] pagetop.workspace = true -pagetop-admin.workspace = true pagetop-seaorm.workspace = true pagetop-htmx.workspace = true pagetop-mail.workspace = true diff --git a/extensions/pagetop-user/README.md b/extensions/pagetop-user/README.md index c3651445..5ccc6ef1 100644 --- a/extensions/pagetop-user/README.md +++ b/extensions/pagetop-user/README.md @@ -14,8 +14,8 @@ Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la base de datos, perfil propio, recuperación de contraseña y verificación del email por correo, y control de acceso con roles y permisos. Incluye las páginas de administración de usuarios, roles y -permisos sobre `pagetop-admin`, hechas sólo con componentes del núcleo para que funcionen con -cualquier tema. +permisos en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que +funcionen con cualquier tema. ## Sobre PageTop @@ -47,9 +47,11 @@ admin_email = "admin@example.com" # Sin 'admin_password', se genera una aleatoria y se muestra una sola vez al crearlo. ``` -**Comprueba los permisos** en tus *handlers*. El usuario actual se inyecta automáticamente en el -contexto de cada `Page` al crearla con `Page::new()`, y las funciones del núcleo, como -`has_permission()`, lo consultan: +**Protege tus rutas** con su acceso (`Access`): PageTop lo comprueba antes de llegar al *handler* +con los permisos que concede esta extensión, y a un usuario anónimo sin acceso le ofrece el inicio +de sesión. Dentro del *handler*, el usuario actual está en el contexto de cada `Page` al crearla +con `Page::new()`, y funciones del núcleo como `has_permission()` lo consultan para las +comprobaciones más concretas: ```rust,no_run use pagetop::prelude::*; @@ -76,15 +78,16 @@ impl Extension for MyApp { vec![&pagetop_user::User] } - fn configure_router(&self, router: Router) -> Router { - router.route("/dashboard", web::get(dashboard)) + fn configure_router(&self, routes: Routes) -> Routes { + routes.route( + "/dashboard", + Access::Permission(&MyPermission::SeeDashboard), + web::get(dashboard), + ) } } async fn dashboard(request: HttpRequest) -> Result { - if !has_permission(&request, &MyPermission::SeeDashboard) { - return Err(ErrorPage::NotFound(Some(request))); - } Page::new(request) .with_child(Html::with(|_| html! { h1 { "Panel" } })) .render().await diff --git a/extensions/pagetop-user/src/account.rs b/extensions/pagetop-user/src/account.rs index c511c8e5..44dc192f 100644 --- a/extensions/pagetop-user/src/account.rs +++ b/extensions/pagetop-user/src/account.rs @@ -58,6 +58,8 @@ impl PermissionSet { /// Se almacena en las extensiones de la petición HTTP durante la fase de middleware y se accede /// desde los handlers o desde handlers de [`CheckPermission`] mediante /// [`HttpRequest::extension::()`](pagetop::web::HttpRequest::extension). +/// +/// [`CheckPermission`]: pagetop::base::action::auth::CheckPermission #[derive(Clone, Debug, Getters)] pub struct Account { /// Identificador del usuario. diff --git a/extensions/pagetop-user/src/component/account_menu.rs b/extensions/pagetop-user/src/component/account_menu.rs index b2931274..247d0c94 100644 --- a/extensions/pagetop-user/src/component/account_menu.rs +++ b/extensions/pagetop-user/src/component/account_menu.rs @@ -1,7 +1,6 @@ //! Menú de cuenta (iniciar y cerrar sesión). use pagetop::prelude::*; -use pagetop_admin::registry::can_access_admin; use pagetop_htmx::prelude::*; use crate::config::SETTINGS; @@ -49,7 +48,7 @@ pub fn account_menu(cx: &Context) -> Nav { if can_access_admin(cx) { menu = menu.with_item(dropdown::Item::link( Lc::t("menu-admin", &LOCALES_USER), - cx.route(pagetop_admin::ADMIN_BASE_PATH), + cx.route(admin_path("")), )); } nav.with_item(nav::Item::dropdown( diff --git a/extensions/pagetop-user/src/component/admin/role_form.rs b/extensions/pagetop-user/src/component/admin/role_form.rs index 6393a7be..b195e496 100644 --- a/extensions/pagetop-user/src/component/admin/role_form.rs +++ b/extensions/pagetop-user/src/component/admin/role_form.rs @@ -37,7 +37,7 @@ impl Component for RoleForm { async fn prepare(&self, cx: &mut Context) -> Result { let action = match self.mode() { - RoleFormMode::New => util::join!(ADMIN_ROLES_PATH, "/new"), + RoleFormMode::New => util::join!(ADMIN_ROLES_PATH.as_str(), "/new"), RoleFormMode::Edit => role_path(self.role_id().copied().unwrap_or_default(), "edit"), }; let action = self.waypoint().append_to(cx.route(action)); diff --git a/extensions/pagetop-user/src/component/admin/role_table.rs b/extensions/pagetop-user/src/component/admin/role_table.rs index 52c7aa98..d03edcb1 100644 --- a/extensions/pagetop-user/src/component/admin/role_table.rs +++ b/extensions/pagetop-user/src/component/admin/role_table.rs @@ -40,7 +40,7 @@ impl Component for RoleTable { async fn prepare(&self, cx: &mut Context) -> Result { let pager = Pager::new() - .with_base_path(ADMIN_ROLES_PATH) + .with_base_path(ADMIN_ROLES_PATH.as_str()) .with_extra_query("sort", self.sort().as_str()) .with_extra_query("dir", *self.dir()) .with_current_page(self.page()) @@ -117,7 +117,7 @@ impl Component for RoleTable { ); } - let new_href = waypoint.append_to(cx.route(util::join!(ADMIN_ROLES_PATH, "/new"))); + let new_href = waypoint.append_to(cx.route(util::join!(ADMIN_ROLES_PATH.as_str(), "/new"))); Ok(html! { div (self.props().unpack(cx)) { @@ -181,7 +181,7 @@ impl RoleTable { // en los enlaces de ver/editar/permisos, para poder volver exactamente a este mismo estado. Se // construye con `cx.route()` para que preserve el parámetro `lang` cuando corresponda. fn list_href(&self, cx: &Context) -> String { - cx.route(ADMIN_ROLES_PATH) + cx.route(ADMIN_ROLES_PATH.as_str()) .alter_param("sort", self.sort().as_str()) .alter_param("dir", *self.dir()) .alter_param("page", self.page().to_string()) @@ -200,7 +200,7 @@ impl RoleTable { let is_active = *self.sort() == field; let active = is_active.then_some(*self.dir()); let next_dir = SortDir::next_for(active); - let mut route = cx.route(ADMIN_ROLES_PATH); + let mut route = cx.route(ADMIN_ROLES_PATH.as_str()); route .alter_param("sort", field.as_str()) .alter_param("dir", next_dir); @@ -229,8 +229,8 @@ fn label_cell(role: &RoleListItem, waypoint: &Waypoint) -> Html { } // Construye la celda de acciones: gestionar permisos si se tiene `user:admin_permissions`, y -// editar/borrar sólo si el rol no está bloqueado por el sistema. Devuelve un componente `Html` para que el marcado se genere cuando -// `Table` renderice la celda, no al construir la fila. +// editar/borrar sólo si el rol no está bloqueado por el sistema. Devuelve un componente `Html` para +// que el marcado se genere cuando `Table` renderice la celda, no al construir la fila. async fn actions_cell( role: &RoleListItem, waypoint: &Waypoint, diff --git a/extensions/pagetop-user/src/component/admin/user_form.rs b/extensions/pagetop-user/src/component/admin/user_form.rs index 98b297f9..bd7ee147 100644 --- a/extensions/pagetop-user/src/component/admin/user_form.rs +++ b/extensions/pagetop-user/src/component/admin/user_form.rs @@ -54,7 +54,7 @@ impl Component for UserForm { async fn prepare(&self, cx: &mut Context) -> Result { let action = match self.mode() { - UserFormMode::New => util::join!(ADMIN_USERS_PATH, "/new"), + UserFormMode::New => util::join!(ADMIN_USERS_PATH.as_str(), "/new"), UserFormMode::Edit => user_path(self.user_id().copied().unwrap_or_default(), "edit"), UserFormMode::Profile => PROFILE_EDIT_PATH.into(), }; diff --git a/extensions/pagetop-user/src/component/admin/user_table.rs b/extensions/pagetop-user/src/component/admin/user_table.rs index 6ce7f072..4fa659ee 100644 --- a/extensions/pagetop-user/src/component/admin/user_table.rs +++ b/extensions/pagetop-user/src/component/admin/user_table.rs @@ -39,7 +39,7 @@ impl Component for UserTable { async fn prepare(&self, cx: &mut Context) -> Result { let pager = Pager::new() - .with_base_path(ADMIN_USERS_PATH) + .with_base_path(ADMIN_USERS_PATH.as_str()) .with_extra_query("q", self.query().cloned().unwrap_or_default()) .with_extra_query("sort", self.sort().as_str()) .with_extra_query("dir", *self.dir()) @@ -83,7 +83,7 @@ impl Component for UserTable { ); } - let new_href = waypoint.append_to(cx.route(util::join!(ADMIN_USERS_PATH, "/new"))); + let new_href = waypoint.append_to(cx.route(util::join!(ADMIN_USERS_PATH.as_str(), "/new"))); Ok(html! { div (self.props().unpack(cx)) { @@ -143,7 +143,7 @@ impl UserTable { // `waypoint` en los enlaces de ver/editar, para poder volver exactamente a este mismo estado. // Se construye con `cx.route()` para que preserve el parámetro `lang` cuando corresponda. fn list_href(&self, cx: &Context) -> String { - let mut route = cx.route(ADMIN_USERS_PATH); + let mut route = cx.route(ADMIN_USERS_PATH.as_str()); if let Some(q) = self.query().filter(|q| !q.is_empty()) { route.alter_param("q", q); } @@ -167,7 +167,7 @@ impl UserTable { let active = is_active.then_some(*self.dir()); let next_dir = SortDir::next_for(active); - let mut route = cx.route(ADMIN_USERS_PATH); + let mut route = cx.route(ADMIN_USERS_PATH.as_str()); if let Some(q) = self.query().filter(|q| !q.is_empty()) { route.alter_param("q", q); } @@ -228,7 +228,7 @@ async fn actions_cell( // Construye la celda de roles: sólo la insignia de administrador si lo es (tiene acceso sin // restricciones, así que sus roles no añaden nada), o las insignias de cada rol asignado, o "-" si // no tiene ninguno. Los badges se renderizan aquí mismo (con el `cx` del ciclo de renderizado de -// `Table`); el resto del marcado se difiere al `Html` que se devuelve, igual que el resto de celdas. +// `Table`); el resto del marcado se difiere al `Html` que se devuelve, como en las demás celdas. async fn roles_cell(user: &UserListItem, cx: &mut Context) -> Html { let mut badges = Vec::with_capacity(user.roles.len().max(1)); if user.is_admin { diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index 603e8a89..80ff6b76 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -4,6 +4,7 @@ use serde::Deserialize; use pagetop::prelude::*; +use pagetop_htmx::prelude::*; use crate::account::{Account, UserStatus}; use crate::auth; @@ -39,6 +40,33 @@ fn login_redirect(request: HttpRequest, next: &'static str) -> Response { Redirect::see_other(waypoint.append_to(cx.route(LOGIN_PATH))).into_response() } +// Respuesta a un usuario anónimo sin acceso a una ruta (acción `AnonymousDenied`): el formulario de +// inicio de sesión, que vuelve después a la ruta pedida. +// +// Una petición HTMX seguiría la redirección sin avisar y pintaría el formulario dentro del +// fragmento que esperaba, así que se le pide con `HX-Redirect` que cargue la página completa. +// Vuelve después a la página que tenía abierta el navegador (`HX-Current-URL`), no a la ruta del +// fragmento, que puede no admitir `GET`. +pub(crate) fn offer_login(request: &HttpRequest) -> Option { + let is_htmx = request.is_htmx(); + let waypoint = if is_htmx { + Waypoint::new( + request + .hx_current_url() + .and_then(|url| url.parse::().ok()) + .and_then(|uri| uri.path_and_query().map(|pq| pq.as_str().to_owned())), + ) + } else { + Waypoint::new(request.uri().to_owned()) + }; + let login = waypoint.append_to(Context::new(request.clone()).route(LOGIN_PATH)); + Some(if is_htmx { + HtmxResponse::empty().redirect(login).into_response() + } else { + Redirect::see_other(login).into_response() + }) +} + // **< profile_get >******************************************************************************** /// GET /user - Perfil del usuario autenticado. Redirige al formulario de inicio de sesión si no hay @@ -60,8 +88,8 @@ pub(crate) async fn profile_get(request: HttpRequest) -> Response { let can_change_password = has_permission(&request, &UserPermission::ChangeOwnPassword); let mut page = Page::new(request); - let details_block = user_details(&user, page.context()).await; - let roles_block = profile_roles(&roles, page.context()).await; + let details_block = user_details(&user, page.context_mut()).await; + let roles_block = profile_roles(&roles, page.context_mut()).await; let actions = profile_actions(can_edit, can_change_password, page.context()); page.with_title(Lc::t("title-profile", &LOCALES_USER)) @@ -159,9 +187,12 @@ pub(crate) async fn public_profile_get( request: HttpRequest, web::Path(id): web::Path, ) -> Result { - // El permiso se comprueba antes de buscar al usuario para no revelar qué ids existen. - if current_user_id(&request) != Some(id) { - require_permission(&request, &UserPermission::ViewProfiles)?; + // El permiso se comprueba antes de buscar al usuario para no revelar qué ids existen. Sin él, la + // misma respuesta que una ruta sin acceso: el inicio de sesión a un anónimo y 403 al resto. + if current_user_id(&request) != Some(id) + && !has_permission(&request, &UserPermission::ViewProfiles) + { + return Ok(deny_access(request)); } let Ok(user) = user_admin::find_user(id).await else { return Err(ErrorPage::NotFound(Some(request))); @@ -176,7 +207,7 @@ pub(crate) async fn public_profile_get( Some(name) => name.to_owned(), None => user.username.clone(), }; - let mut page = Page::new(request); + let page = Page::new(request); let details = public_profile_details(&user, page.context()); Ok(page @@ -228,7 +259,6 @@ pub(crate) async fn profile_edit_get(request: HttpRequest) -> Result Result Result Response { - let mut page = Page::new(request); - let cancel = Button::anchor( - Lc::t("btn-cancel", &LOCALES_USER), - page.context().route(PROFILE_PATH), - ); + let page = Page::new(request); + let cancel = Button::anchor(Lc::t("btn-cancel", &LOCALES_USER), page.route(PROFILE_PATH)); page.with_title(title.clone()) .with_child( Block::new() diff --git a/extensions/pagetop-user/src/handlers/admin.rs b/extensions/pagetop-user/src/handlers/admin.rs index 7b6f40da..32ef5d21 100644 --- a/extensions/pagetop-user/src/handlers/admin.rs +++ b/extensions/pagetop-user/src/handlers/admin.rs @@ -1,26 +1,20 @@ //! Handlers HTTP para el mantenimiento de usuarios, roles y permisos. //! -//! Las páginas de usuarios, roles y permisos se registran en el portal de `pagetop-admin` (ver -//! `declare_admin_pages()`). Cada handler comprueba el permiso correspondiente con -//! [`require_permission()`](pagetop::auth::require_permission) antes de construir la página. +//! Las páginas de usuarios, roles y permisos se declaran en el panel de administración (ver +//! `declare_admin_pages()`), y sus rutas exigen el permiso de su página, que PageTop comprueba +//! antes de llegar al handler. Los handlers sólo comprueban los permisos más concretos (bloquear +//! cuentas, asignar permisos a un rol). pub(crate) mod permissions; pub(crate) mod roles; pub(crate) mod users; use pagetop::prelude::*; -use pagetop_admin::component::AdminFrame; use crate::LOCALES_USER; use crate::error::AuthError; use crate::service::role_admin::ROLE_MACHINE_NAME_MAX_CHARS; -// Envuelve el contenido de una página de administración en el frame de `pagetop-admin`: -// breadcrumb, tareas y acciones locales registradas para la ruta actual en su `AdminRegistry`. -pub(crate) fn frame(title: Lc) -> AdminFrame { - AdminFrame::new().with_title(title) -} - // Traduce un `AuthError` a su clave Lc, para mostrarlo en el formulario que falló. Cubre tanto // los errores de autenticación existentes como los nuevos de administración. pub(crate) fn map_auth_error(err: &AuthError) -> Lc { diff --git a/extensions/pagetop-user/src/handlers/admin/permissions.rs b/extensions/pagetop-user/src/handlers/admin/permissions.rs index d4d6d0bb..62e39abf 100644 --- a/extensions/pagetop-user/src/handlers/admin/permissions.rs +++ b/extensions/pagetop-user/src/handlers/admin/permissions.rs @@ -7,20 +7,16 @@ use pagetop::prelude::*; use crate::LOCALES_USER; -use crate::handlers::admin::frame; -use crate::permission::{self, UserPermission}; /// GET /admin/user/permissions - Catálogo de permisos agrupado. pub(crate) async fn list_get(request: HttpRequest) -> Result { - require_permission(&request, &UserPermission::AdminPermissions)?; + let page = Page::admin(request); - let mut page = Page::admin(request); + let registry = PermissionRegistry::global(); + let groups = registry.groups_sorted(page.context()); + let mut page = page.with_title(Lc::t("title-admin-permissions", &LOCALES_USER)); - let registry = permission::registry(); - let title = Lc::t("title-admin-permissions", &LOCALES_USER); - let mut content = frame(title.clone()); - - for (group, group_label) in registry.groups_sorted(page.context()) { + for (group, group_label) in groups { let mut table = Table::new().with_prop(PropsOp::add_classes("user-admin-table")); for permission in registry.by_group(group) { table = table.with_row( @@ -29,17 +25,12 @@ pub(crate) async fn list_get(request: HttpRequest) -> Result, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let params = RolePageParams { sort: RoleSortField::from_query(query.sort.as_deref()), dir: SortDir::from_query(query.dir.as_deref()), @@ -62,8 +60,8 @@ pub(crate) async fn list_get( } else { let title = Lc::t("title-admin-roles", &LOCALES_USER); Ok(Page::admin(request) - .with_title(title.clone()) - .with_child(frame(title).with_child(table)) + .with_title(title) + .with_child(table) .render() .await .into_response()) @@ -77,21 +75,17 @@ pub(crate) async fn new_get( request: HttpRequest, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let title = Lc::t("title-admin-role-new", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) .with_child( - frame(title) - .with_child( - RoleForm::new() - .with_mode(RoleFormMode::New) - .with_waypoint(waypoint), - ) - .with_child(back_link(back_href)), + RoleForm::new() + .with_mode(RoleFormMode::New) + .with_waypoint(waypoint), ) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -113,8 +107,6 @@ pub(crate) async fn new_post( web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let weight: i32 = form.weight.trim().parse().unwrap_or(0); let result = role_admin::create_role(role_admin::NewRoleData { @@ -128,12 +120,12 @@ pub(crate) async fn new_post( match result { Ok(_) => { let cx = Context::admin(request); - let target = waypoint.or(cx.route(ADMIN_ROLES_PATH)); + let target = waypoint.or(cx.route(ADMIN_ROLES_PATH.as_str())); Ok(Redirect::see_other(target).into_response()) } Err(err) => { - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let form_component = RoleForm::new() .with_mode(RoleFormMode::New) .with_machine_name(form.machine_name) @@ -144,12 +136,9 @@ pub(crate) async fn new_post( .with_waypoint(waypoint); let title = Lc::t("title-admin-role-new", &LOCALES_USER); Ok(page - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(form_component) - .with_child(back_link(back_href)), - ) + .with_title(title) + .with_child(form_component) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -165,8 +154,6 @@ pub(crate) async fn edit_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let role = match role_admin::find_role(id).await { Ok(role) => role, Err(_) => return Err(ErrorPage::NotFound(Some(request))), @@ -175,26 +162,23 @@ pub(crate) async fn edit_get( return Err(ErrorPage::AccessDenied(Some(request))); } - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let title = Lc::t("title-admin-role-edit", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) .with_child( - frame(title) - .with_child( - RoleForm::new() - .with_mode(RoleFormMode::Edit) - .with_role_id(Some(id)) - .with_machine_name(role.machine_name) - .with_label(role.label) - .with_description(role.description.unwrap_or_default()) - .with_weight(role.weight) - .with_waypoint(waypoint), - ) - .with_child(back_link(back_href)), + RoleForm::new() + .with_mode(RoleFormMode::Edit) + .with_role_id(Some(id)) + .with_machine_name(role.machine_name) + .with_label(role.label) + .with_description(role.description.unwrap_or_default()) + .with_weight(role.weight) + .with_waypoint(waypoint), ) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -216,8 +200,6 @@ pub(crate) async fn edit_post( web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let weight: i32 = form.weight.trim().parse().unwrap_or(0); let result = role_admin::update_role( @@ -233,7 +215,7 @@ pub(crate) async fn edit_post( match result { Ok(()) => { let cx = Context::admin(request); - let target = waypoint.or(cx.route(ADMIN_ROLES_PATH)); + let target = waypoint.or(cx.route(ADMIN_ROLES_PATH.as_str())); Ok(Redirect::see_other(target).into_response()) } Err(err) => { @@ -241,8 +223,8 @@ pub(crate) async fn edit_post( .await .map(|role| role.machine_name) .unwrap_or_default(); - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let form_component = RoleForm::new() .with_mode(RoleFormMode::Edit) .with_role_id(Some(id)) @@ -254,12 +236,9 @@ pub(crate) async fn edit_post( .with_waypoint(waypoint); let title = Lc::t("title-admin-role-edit", &LOCALES_USER); Ok(page - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(form_component) - .with_child(back_link(back_href)), - ) + .with_title(title) + .with_child(form_component) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -276,8 +255,6 @@ pub(crate) async fn view_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let role = match role_admin::find_role(id).await { Ok(role) => role, Err(_) => return Err(ErrorPage::NotFound(Some(request))), @@ -289,19 +266,17 @@ pub(crate) async fn view_get( let mut page = Page::admin(request); let groups = build_permission_groups(&selected, page.context()); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); - let details_block = role_view_details(&role, page.context()).await; + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); + let details_block = role_view_details(&role, page.context_mut()).await; let title = Lc::t("title-admin-role-view", &LOCALES_USER); - let mut content = frame(title.clone()).with_child(details_block); + let mut page = page.with_title(title).with_child(details_block); for group_block in role_view_permissions(&groups) { - content = content.with_child(group_block); + page = page.with_child(group_block); } - content = content.with_child(back_link(back_href)); Ok(page - .with_title(title) - .with_child(content) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -389,8 +364,6 @@ pub(crate) async fn delete_post( web::Path(id): web::Path, web::Query(query): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let result = role_admin::delete_role(id).await; if request.is_htmx() { @@ -419,7 +392,7 @@ pub(crate) async fn delete_post( match result { Ok(()) => { let target = cx - .route(ADMIN_ROLES_PATH) + .route(ADMIN_ROLES_PATH.as_str()) .alter_param( "sort", RoleSortField::from_query(query.sort.as_deref()).as_str(), @@ -448,8 +421,6 @@ pub(crate) async fn delete_confirm_get( web::Path(id): web::Path, web::Query(query): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; - let mut cx = Context::admin(request); let delete_href = cx .route(role_path(id, "delete")) @@ -473,7 +444,7 @@ pub(crate) async fn delete_confirm_get( // **< permissions_get / permissions_post >********************************************************* fn build_permission_groups(selected: &[String], cx: &Context) -> PermissionGroups { - let registry = permission::registry(); + let registry = PermissionRegistry::global(); registry .groups_sorted(cx) .into_iter() @@ -498,7 +469,6 @@ pub(crate) async fn permissions_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; require_permission(&request, &UserPermission::AdminPermissions)?; if role_admin::find_role(id).await.is_err() { @@ -508,24 +478,21 @@ pub(crate) async fn permissions_get( Ok(keys) => keys, Err(_) => return Err(ErrorPage::InternalError(Some(request))), }; - let mut page = Page::admin(request); + let page = Page::admin(request); let groups = build_permission_groups(&selected, page.context()); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let title = Lc::t("title-admin-role-permissions", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) .with_child( - frame(title) - .with_child( - RolePermissionsForm::new() - .with_role_id(id) - .with_groups(groups) - .with_waypoint(waypoint), - ) - .with_child(back_link(back_href)), + RolePermissionsForm::new() + .with_role_id(id) + .with_groups(groups) + .with_waypoint(waypoint), ) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -547,7 +514,6 @@ pub(crate) async fn permissions_post( web::Query(waypoint): web::Query, raw: web::RawForm, ) -> Result { - require_permission(&request, &UserPermission::AdminRoles)?; require_permission(&request, &UserPermission::AdminPermissions)?; let Ok(form) = serde_qs::from_bytes::(&raw.0) else { @@ -557,14 +523,14 @@ pub(crate) async fn permissions_post( match role_admin::set_role_permissions(id, &form.permission_keys).await { Ok(()) => { let cx = Context::admin(request); - let target = waypoint.or(cx.route(ADMIN_ROLES_PATH)); + let target = waypoint.or(cx.route(ADMIN_ROLES_PATH.as_str())); Ok(Redirect::see_other(target).into_response()) } Err(err) => { - let mut page = Page::admin(request); + let page = Page::admin(request); let groups = build_permission_groups(&form.permission_keys, page.context()); - let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH)); + let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str())); let form_component = RolePermissionsForm::new() .with_role_id(id) .with_groups(groups) @@ -572,12 +538,9 @@ pub(crate) async fn permissions_post( .with_waypoint(waypoint); let title = Lc::t("title-admin-role-permissions", &LOCALES_USER); Ok(page - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(form_component) - .with_child(back_link(back_href)), - ) + .with_title(title) + .with_child(form_component) + .with_child(back_link(back_href)) .render() .await .into_response()) diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs index 5614e1e7..b26b1386 100644 --- a/extensions/pagetop-user/src/handlers/admin/users.rs +++ b/extensions/pagetop-user/src/handlers/admin/users.rs @@ -15,7 +15,7 @@ use crate::component::user_details; use crate::config::SETTINGS; use crate::entity::{role, user}; use crate::error::AuthError; -use crate::handlers::admin::{back_link, frame, map_auth_error}; +use crate::handlers::admin::{back_link, map_auth_error}; use crate::mail::{Notice, send_notice}; use crate::password; use crate::permission::UserPermission; @@ -43,8 +43,6 @@ pub(crate) async fn list_get( request: HttpRequest, web::Query(query): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; - let params = UserListParams { query: query.q.clone(), sort: UserSortField::from_query(query.sort.as_deref()), @@ -73,12 +71,9 @@ pub(crate) async fn list_get( } else { let title = Lc::t("title-admin-users", &LOCALES_USER); Ok(Page::admin(request) - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(search_bar(query.q)) - .with_child(table), - ) + .with_title(title) + .with_child(search_bar(query.q)) + .with_child(table) .render() .await .into_response()) @@ -98,7 +93,7 @@ fn search_bar(current_query: Option) -> Html { name="q" value=(value.as_str()) placeholder=[Lc::t("field-search-users", &LOCALES_USER).lookup(cx)] - hx-get=(cx.route(ADMIN_USERS_PATH).to_string()) + hx-get=(cx.route(ADMIN_USERS_PATH.as_str()).to_string()) hx-trigger="keyup changed delay:400ms, search" hx-target="#user-table-wrapper" hx-swap=(hx::swap::OUTER_HTML_SCROLL_TOP) @@ -155,7 +150,6 @@ pub(crate) async fn new_get( request: HttpRequest, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; let roles = match available_roles(&[]).await { Ok(roles) => roles, Err(_) => return Err(ErrorPage::InternalError(Some(request))), @@ -163,22 +157,19 @@ pub(crate) async fn new_get( // El campo "administrador" sólo se ofrece si quien da de alta ya es administrador: no es un // permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`). let allow_admin_field = request.extension::().is_some_and(|a| a.is_admin()); - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_USERS_PATH.as_str())); let title = Lc::t("title-admin-user-new", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) .with_child( - frame(title) - .with_child( - UserForm::new() - .with_mode(UserFormMode::New) - .with_roles(roles) - .with_allow_admin_field(allow_admin_field) - .with_waypoint(waypoint), - ) - .with_child(back_link(back_href)), + UserForm::new() + .with_mode(UserFormMode::New) + .with_roles(roles) + .with_allow_admin_field(allow_admin_field) + .with_waypoint(waypoint), ) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -213,7 +204,6 @@ pub(crate) async fn new_post( web::Query(waypoint): web::Query, raw: web::RawForm, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; let Ok(form) = serde_qs::from_bytes::(&raw.0) else { return Err(ErrorPage::BadRequest(Some(request))); }; @@ -240,13 +230,13 @@ pub(crate) async fn new_post( match result { Ok(_) => { let cx = Context::admin(request); - let target = waypoint.or(cx.route(ADMIN_USERS_PATH)); + let target = waypoint.or(cx.route(ADMIN_USERS_PATH.as_str())); Ok(Redirect::see_other(target).into_response()) } Err(err) => { let roles = available_roles(&role_ids).await.unwrap_or_default(); - let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH)); + let page = Page::admin(request); + let back_href = waypoint.or(page.route(ADMIN_USERS_PATH.as_str())); let form_component = UserForm::new() .with_mode(UserFormMode::New) .with_username(form.username) @@ -262,12 +252,9 @@ pub(crate) async fn new_post( .with_waypoint(waypoint); let title = Lc::t("title-admin-user-new", &LOCALES_USER); Ok(page - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(form_component) - .with_child(back_link(back_href)), - ) + .with_title(title) + .with_child(form_component) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -331,7 +318,7 @@ async fn render_edit_page( // Bloquear y activar exige además `user:block_accounts` (ver `status_post`). let can_change_status = has_permission(&request, &UserPermission::BlockAccounts); let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH)); + let back_href = waypoint.or(page.route(ADMIN_USERS_PATH.as_str())); let title = Lc::t("title-admin-user-edit", &LOCALES_USER); let actions = edit_actions( id, @@ -340,20 +327,17 @@ async fn render_edit_page( can_toggle_admin, can_change_status, &waypoint, - page.context(), + page.context_mut(), ); - page.with_title(title.clone()) + page.with_title(title) .with_child( - frame(title) - .with_child( - form.with_mode(UserFormMode::Edit) - .with_user_id(Some(id)) - .with_waypoint(waypoint.clone()), - ) - .with_child(actions) - .with_child(back_link(back_href)), + form.with_mode(UserFormMode::Edit) + .with_user_id(Some(id)) + .with_waypoint(waypoint.clone()), ) + .with_child(actions) + .with_child(back_link(back_href)) .render() .await .into_response() @@ -451,7 +435,6 @@ pub(crate) async fn edit_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; require_manageable(&request, id).await?; Ok(render_user_edit(request, id, None, waypoint).await) } @@ -483,7 +466,6 @@ pub(crate) async fn edit_post( web::Query(waypoint): web::Query, raw: web::RawForm, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; let user = require_manageable(&request, id).await?; let Ok(form) = serde_qs::from_bytes::(&raw.0) else { return Err(ErrorPage::BadRequest(Some(request))); @@ -510,7 +492,7 @@ pub(crate) async fn edit_post( match result { Ok(()) => { let cx = Context::admin(request); - let target = waypoint.or(cx.route(ADMIN_USERS_PATH)); + let target = waypoint.or(cx.route(ADMIN_USERS_PATH.as_str())); Ok(Redirect::see_other(target).into_response()) } Err(err) => { @@ -540,8 +522,6 @@ pub(crate) async fn view_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; - let user = match user_admin::find_user(id).await { Ok(user) => user, Err(_) => return Err(ErrorPage::NotFound(Some(request))), @@ -552,19 +532,16 @@ pub(crate) async fn view_get( }; let mut page = Page::admin(request); - let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH)); - let details_block = user_details(&user, page.context()).await; - let roles_block = user_view_roles(&roles, user.is_admin, page.context()).await; + let back_href = waypoint.or(page.route(ADMIN_USERS_PATH.as_str())); + let details_block = user_details(&user, page.context_mut()).await; + let roles_block = user_view_roles(&roles, user.is_admin, page.context_mut()).await; let title = Lc::t("title-admin-user-view", &LOCALES_USER); Ok(page - .with_title(title.clone()) - .with_child( - frame(title) - .with_child(details_block) - .with_child(roles_block) - .with_child(back_link(back_href)), - ) + .with_title(title) + .with_child(details_block) + .with_child(roles_block) + .with_child(back_link(back_href)) .render() .await .into_response()) @@ -645,7 +622,6 @@ pub(crate) async fn status_post( web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; require_permission(&request, &UserPermission::BlockAccounts)?; require_manageable(&request, id).await?; let Some(account) = request.extension::().cloned() else { @@ -731,23 +707,19 @@ pub(crate) async fn password_get( web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; let user = require_manageable(&request, id).await?; - let mut page = Page::admin(request); - let edit_href = waypoint.append_to(page.context().route(user_path(id, "edit"))); + let page = Page::admin(request); + let edit_href = waypoint.append_to(page.route(user_path(id, "edit"))); let title = Lc::t("title-admin-user-password", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) + .with_child(user_summary(&user)) .with_child( - frame(title) - .with_child(user_summary(&user)) - .with_child( - AdminPasswordForm::new() - .with_user_id(id) - .with_waypoint(waypoint), - ) - .with_child(back_link(edit_href)), + AdminPasswordForm::new() + .with_user_id(id) + .with_waypoint(waypoint), ) + .with_child(back_link(edit_href)) .render() .await .into_response()) @@ -767,7 +739,6 @@ pub(crate) async fn password_post( web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { - require_permission(&request, &UserPermission::AdminUsers)?; let user = require_manageable(&request, id).await?; let result = match password::passwords_match(&form.password, &form.confirm_password) { @@ -783,22 +754,19 @@ pub(crate) async fn password_post( Ok(Redirect::see_other(edit_href).into_response()) } Err(err) => { - let mut page = Page::admin(request); - let edit_href = waypoint.append_to(page.context().route(user_path(id, "edit"))); + let page = Page::admin(request); + let edit_href = waypoint.append_to(page.route(user_path(id, "edit"))); let title = Lc::t("title-admin-user-password", &LOCALES_USER); Ok(page - .with_title(title.clone()) + .with_title(title) + .with_child(user_summary(&user)) .with_child( - frame(title) - .with_child(user_summary(&user)) - .with_child( - AdminPasswordForm::new() - .with_user_id(id) - .with_error(map_auth_error(&err)) - .with_waypoint(waypoint), - ) - .with_child(back_link(edit_href)), + AdminPasswordForm::new() + .with_user_id(id) + .with_error(map_auth_error(&err)) + .with_waypoint(waypoint), ) + .with_child(back_link(edit_href)) .render() .await .into_response()) diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 1cc080f4..6a4025f4 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -15,8 +15,8 @@ Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la base de datos, perfil propio, recuperación de contraseña y verificación del email por correo, y control de acceso con roles y permisos. Incluye las páginas de administración de usuarios, roles y -permisos sobre `pagetop-admin`, hechas sólo con componentes del núcleo para que funcionen con -cualquier tema. +permisos en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que +funcionen con cualquier tema. ## Sobre PageTop @@ -48,9 +48,11 @@ admin_email = "admin@example.com" # Sin 'admin_password', se genera una aleatoria y se muestra una sola vez al crearlo. ``` -**Comprueba los permisos** en tus *handlers*. El usuario actual se inyecta automáticamente en el -contexto de cada [`Page`] al crearla con [`Page::new()`], y las funciones del núcleo, como -[`has_permission()`], lo consultan: +**Protege tus rutas** con su acceso (`Access`): PageTop lo comprueba antes de llegar al *handler* +con los permisos que concede esta extensión, y a un usuario anónimo sin acceso le ofrece el inicio +de sesión. Dentro del *handler*, el usuario actual está en el contexto de cada [`Page`] al crearla +con [`Page::new()`], y funciones del núcleo como [`has_permission()`] lo consultan para las +comprobaciones más concretas: ```rust,no_run use pagetop::prelude::*; @@ -77,15 +79,16 @@ impl Extension for MyApp { vec![&pagetop_user::User] } - fn configure_router(&self, router: Router) -> Router { - router.route("/dashboard", web::get(dashboard)) + fn configure_router(&self, routes: Routes) -> Routes { + routes.route( + "/dashboard", + Access::Permission(&MyPermission::SeeDashboard), + web::get(dashboard), + ) } } async fn dashboard(request: HttpRequest) -> Result { - if !has_permission(&request, &MyPermission::SeeDashboard) { - return Err(ErrorPage::NotFound(Some(request))); - } Page::new(request) .with_child(Html::with(|_| html! { h1 { "Panel" } })) .render().await @@ -159,9 +162,10 @@ ninguna. Detrás de un *proxy* inverso, los límites por IP requieren configurar */ use pagetop::prelude::*; -use pagetop_admin::prelude::*; use pagetop_seaorm::install_migrations; +use std::sync::LazyLock; + pub mod account; pub mod config; pub mod error; @@ -187,7 +191,6 @@ pub mod component; include_locales!(LOCALES_USER); pub use account::{Account, UserStatus}; -pub use permission::{DeclarePermissions, PermissionRegistry}; /// Prelude de `pagetop-user`. pub mod prelude { @@ -195,7 +198,7 @@ pub mod prelude { pub use crate::component::UserName; pub use crate::component::{AccountMenu, account_menu}; pub use crate::error::AuthError; - pub use crate::{Account, DeclarePermissions, UserStatus}; + pub use crate::{Account, UserStatus}; } // **< Rutas HTTP (fijas) >************************************************************************* @@ -236,15 +239,20 @@ const PASSWORD_RESET_PATH: &str = "/user/password/reset"; // POST - la confirma. const VERIFY_PATH: &str = "/user/verify"; -// **< Rutas de administración (fijas) >************************************************************ +// **< Rutas de administración >******************************************************************** + +// Relativas a la raíz del panel de administración, como se declaran sus páginas, y completas (ver +// `admin_path()`), para montar las rutas y enlazar. // Listado, alta, edición, asignación de roles, bloqueo/activación y restablecimiento de contraseña // de usuarios. -const ADMIN_USERS_PATH: &str = "/admin/user/users"; +const ADMIN_USERS: &str = "user/users"; +static ADMIN_USERS_PATH: LazyLock = LazyLock::new(|| admin_path(ADMIN_USERS)); // Listado, alta, edición, eliminación y asignación de permisos de roles. -const ADMIN_ROLES_PATH: &str = "/admin/user/roles"; +const ADMIN_ROLES: &str = "user/roles"; +static ADMIN_ROLES_PATH: LazyLock = LazyLock::new(|| admin_path(ADMIN_ROLES)); // Catálogo de permisos registrados, agrupado por extensión (solo lectura). -const ADMIN_PERMISSIONS_PATH: &str = "/admin/user/permissions"; +const ADMIN_PERMISSIONS: &str = "user/permissions"; // Ruta del perfil público del usuario `id`: `{PROFILE_PATH}/{id}`. fn profile_path(id: i32) -> String { @@ -253,48 +261,49 @@ fn profile_path(id: i32) -> String { // Ruta de una acción sobre el usuario `id`: `{ADMIN_USERS_PATH}/{id}/{tail}`. fn user_path(id: i32, tail: &str) -> String { - util::join!(ADMIN_USERS_PATH, "/", id.to_string(), "/", tail) + util::join!(ADMIN_USERS_PATH.as_str(), "/", id.to_string(), "/", tail) } // Ruta de una acción sobre el rol `id`: `{ADMIN_ROLES_PATH}/{id}/{tail}`. fn role_path(id: i32, tail: &str) -> String { - util::join!(ADMIN_ROLES_PATH, "/", id.to_string(), "/", tail) + util::join!(ADMIN_ROLES_PATH.as_str(), "/", id.to_string(), "/", tail) } -// **< Registro en pagetop-admin (fijo) >*********************************************************** +// **< Páginas del panel de administración >******************************************************** -// Registra las páginas de usuarios, roles y permisos en el portal de `pagetop-admin`, bajo la -// sección integrada "people". Las rutas y sus handlers ya están registrados en -// `configure_router()`; este registro sólo aporta el metadato (título, sección, permiso) para que -// aparezcan en la portada `/admin`. -fn declare_admin_pages(bag: &mut PageBag) { - bag.add(AdminPage { - path: ADMIN_USERS_PATH.to_owned(), - section: "people".to_owned(), - title: Lc::t("title-admin-users", &LOCALES_USER), - description: Some(Lc::t("description-admin-users", &LOCALES_USER)), - weight: 0, - permission: &permission::UserPermission::AdminUsers, - kind: AdminPageKind::View, - }); - bag.add(AdminPage { - path: ADMIN_ROLES_PATH.to_owned(), - section: "people".to_owned(), - title: Lc::t("title-admin-roles", &LOCALES_USER), - description: Some(Lc::t("description-admin-roles", &LOCALES_USER)), - weight: 10, - permission: &permission::UserPermission::AdminRoles, - kind: AdminPageKind::View, - }); - bag.add(AdminPage { - path: ADMIN_PERMISSIONS_PATH.to_owned(), - section: "people".to_owned(), - title: Lc::t("title-admin-permissions", &LOCALES_USER), - description: Some(Lc::t("description-admin-permissions", &LOCALES_USER)), - weight: 20, - permission: &permission::UserPermission::AdminPermissions, - kind: AdminPageKind::View, - }); +// Declara las páginas de usuarios, roles y permisos en el panel de administración, bajo la sección +// integrada "people". Las rutas y sus handlers ya están registrados en `configure_router()`; esta +// declaración sólo aporta el metadato (título, sección, permiso) para que aparezcan en el panel. +fn declare_admin_pages(bag: &mut AdminPageBag) { + bag.add( + AdminPage::new( + ADMIN_USERS, + "people", + Lc::t("title-admin-users", &LOCALES_USER), + &permission::UserPermission::AdminUsers, + ) + .with_description(Lc::t("description-admin-users", &LOCALES_USER)), + ); + bag.add( + AdminPage::new( + ADMIN_ROLES, + "people", + Lc::t("title-admin-roles", &LOCALES_USER), + &permission::UserPermission::AdminRoles, + ) + .with_description(Lc::t("description-admin-roles", &LOCALES_USER)) + .with_weight(10), + ); + bag.add( + AdminPage::new( + ADMIN_PERMISSIONS, + "people", + Lc::t("title-admin-permissions", &LOCALES_USER), + &permission::UserPermission::AdminPermissions, + ) + .with_description(Lc::t("description-admin-permissions", &LOCALES_USER)) + .with_weight(20), + ); } // **< Roles de sistema (fijos) >******************************************************************* @@ -344,7 +353,6 @@ impl Extension for User { fn dependencies(&self) -> Vec { vec![ - &pagetop_admin::Admin, &pagetop_seaorm::SeaORM, &pagetop_htmx::Htmx, &pagetop_mail::Mail, @@ -354,11 +362,13 @@ impl Extension for User { fn actions(&self) -> Vec { actions![ // Comprueba permisos mediante el modelo RBAC almacenado en BD. - CheckPermission::new(middleware::check_rbac_permission), + action::auth::CheckPermission::new(middleware::check_rbac_permission), + // Ofrece el inicio de sesión a un usuario anónimo sin acceso a una ruta. + action::auth::AnonymousDenied::new(handlers::account::offer_login), // Registra los permisos propios de pagetop-user. - DeclarePermissions::new(permission::declare_builtin_permissions), - // Registra las páginas de usuarios, roles y permisos en el portal de pagetop-admin. - DeclareAdminPages::new(declare_admin_pages), + action::auth::DeclarePermissions::new(permission::declare_builtin_permissions), + // Declara las páginas de usuarios, roles y permisos en el panel de administración. + action::admin::DeclareAdminPages::new(declare_admin_pages), // Declara las vistas previas de los correos de recuperación y verificación. pagetop_mail::DeclareMailPreviews::new(mail::declare_previews), ] @@ -373,7 +383,6 @@ impl Extension for User { m20260629_000005_create_sessions, m20260629_000006_create_user_tokens, )?; - permission::build_registry(); // Los permisos de "anonymous" en memoria sobreviven a una nueva preparación en el mismo // proceso (las pruebas lo hacen), que puede usar otra base de datos. session::invalidate_anonymous_permissions(); @@ -383,113 +392,123 @@ impl Extension for User { Ok(()) } - fn configure_router(&self, router: Router) -> Router { - router - .route( + fn configure_router(&self, routes: Routes) -> Routes { + let edit_own_profile = Access::Permission(&permission::UserPermission::EditOwnProfile); + let change_own_password = + Access::Permission(&permission::UserPermission::ChangeOwnPassword); + routes + .public_route( LOGIN_PATH, web::get(handlers::auth::login_get).post(handlers::auth::login_post), ) - .route(LOGOUT_PATH, web::post(handlers::auth::logout_post)) - .route( + .public_route(LOGOUT_PATH, web::post(handlers::auth::logout_post)) + .public_route( REGISTER_PATH, web::get(handlers::auth::register_get).post(handlers::auth::register_post), ) - .route(PROFILE_PATH, web::get(handlers::account::profile_get)) .route( + PROFILE_PATH, + Access::Authenticated, + web::get(handlers::account::profile_get), + ) + .public_route( &format!("{}/{{id}}", PROFILE_PATH), web::get(handlers::account::public_profile_get), ) .route( PROFILE_EDIT_PATH, + edit_own_profile, web::get(handlers::account::profile_edit_get) .post(handlers::account::profile_edit_post), ) .route( PROFILE_PASSWORD_PATH, + change_own_password, web::get(handlers::account::password_get).post(handlers::account::password_post), ) .route( EMAIL_PATH, + edit_own_profile, web::get(handlers::account::email_get).post(handlers::account::email_post), ) - .route( + .public_route( &format!("{}/{{uid}}/{{token}}", EMAIL_PATH), web::get(handlers::account::email_confirm_get) .post(handlers::account::email_confirm_post), ) - .route( + .public_route( PASSWORD_RESET_PATH, web::get(handlers::auth::password_reset_get) .post(handlers::auth::password_reset_post), ) - .route( + .public_route( &format!("{}/{{uid}}/{{token}}", PASSWORD_RESET_PATH), web::get(handlers::auth::password_reset_confirm_get) .post(handlers::auth::password_reset_confirm_post), ) - .route( + .public_route( &format!("{}/{{uid}}/{{token}}", VERIFY_PATH), web::get(handlers::auth::verify_email_get).post(handlers::auth::verify_email_post), ) - .route(ADMIN_USERS_PATH, web::get(handlers::admin::users::list_get)) - .route( - &format!("{}/new", ADMIN_USERS_PATH), + .admin_route(ADMIN_USERS, web::get(handlers::admin::users::list_get)) + .admin_route( + &format!("{ADMIN_USERS}/new"), web::get(handlers::admin::users::new_get).post(handlers::admin::users::new_post), ) - .route( - &format!("{}/{{id}}/edit", ADMIN_USERS_PATH), + .admin_route( + &format!("{ADMIN_USERS}/{{id}}/edit"), web::get(handlers::admin::users::edit_get).post(handlers::admin::users::edit_post), ) - .route( - &format!("{}/{{id}}/view", ADMIN_USERS_PATH), + .admin_route( + &format!("{ADMIN_USERS}/{{id}}/view"), web::get(handlers::admin::users::view_get), ) - .route( - &format!("{}/{{id}}/status", ADMIN_USERS_PATH), + .admin_route( + &format!("{ADMIN_USERS}/{{id}}/status"), web::post(handlers::admin::users::status_post), ) - .route( - &format!("{}/{{id}}/admin", ADMIN_USERS_PATH), + .admin_route( + &format!("{ADMIN_USERS}/{{id}}/admin"), web::post(handlers::admin::users::admin_post), ) - .route( - &format!("{}/{{id}}/password", ADMIN_USERS_PATH), + .admin_route( + &format!("{ADMIN_USERS}/{{id}}/password"), web::get(handlers::admin::users::password_get) .post(handlers::admin::users::password_post), ) - .route(ADMIN_ROLES_PATH, web::get(handlers::admin::roles::list_get)) - .route( - &format!("{}/new", ADMIN_ROLES_PATH), + .admin_route(ADMIN_ROLES, web::get(handlers::admin::roles::list_get)) + .admin_route( + &format!("{ADMIN_ROLES}/new"), web::get(handlers::admin::roles::new_get).post(handlers::admin::roles::new_post), ) - .route( - &format!("{}/{{id}}/edit", ADMIN_ROLES_PATH), + .admin_route( + &format!("{ADMIN_ROLES}/{{id}}/edit"), web::get(handlers::admin::roles::edit_get).post(handlers::admin::roles::edit_post), ) - .route( - &format!("{}/{{id}}/view", ADMIN_ROLES_PATH), + .admin_route( + &format!("{ADMIN_ROLES}/{{id}}/view"), web::get(handlers::admin::roles::view_get), ) - .route( - &format!("{}/{{id}}/delete", ADMIN_ROLES_PATH), + .admin_route( + &format!("{ADMIN_ROLES}/{{id}}/delete"), web::post(handlers::admin::roles::delete_post), ) - .route( - &format!("{}/{{id}}/delete/confirm", ADMIN_ROLES_PATH), + .admin_route( + &format!("{ADMIN_ROLES}/{{id}}/delete/confirm"), web::get(handlers::admin::roles::delete_confirm_get), ) - .route( - &format!("{}/{{id}}/permissions", ADMIN_ROLES_PATH), + .admin_route( + &format!("{ADMIN_ROLES}/{{id}}/permissions"), web::get(handlers::admin::roles::permissions_get) .post(handlers::admin::roles::permissions_post), ) - .route( - ADMIN_PERMISSIONS_PATH, + .admin_route( + ADMIN_PERMISSIONS, web::get(handlers::admin::permissions::list_get), ) } - fn configure_middleware(&self, router: Router) -> Router { - router.layer(web::middleware::from_fn(middleware::session_middleware)) + fn configure_middleware(&self, layers: Layers) -> Layers { + layers.layer(web::middleware::from_fn(middleware::session_middleware)) } } diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index 20c4672f..778d9e88 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -67,7 +67,8 @@ pub(crate) async fn session_middleware( // **< check_rbac_permission >********************************************************************** -/// Handler de la acción [`pagetop::auth::CheckPermission`] para el modelo RBAC de `pagetop-user`. +/// Handler de la acción [`CheckPermission`](pagetop::base::action::auth::CheckPermission) para el +/// modelo RBAC de `pagetop-user`. /// /// Lee el [`Account`] inyectado por el middleware de sesión desde las extensiones de la petición /// HTTP y concede el permiso si el account lo tiene (un administrador lo tiene concedido siempre, diff --git a/extensions/pagetop-user/src/permission.rs b/extensions/pagetop-user/src/permission.rs index 8dc7f444..644433e5 100644 --- a/extensions/pagetop-user/src/permission.rs +++ b/extensions/pagetop-user/src/permission.rs @@ -1,161 +1,12 @@ -//! Catálogo de permisos en memoria y acción `DeclarePermissions`. +//! Permisos propios de `pagetop-user`. //! -//! El catálogo se construye una sola vez durante `Extension::initialize()` a partir de -//! las acciones `DeclarePermissions` registradas por todas las extensiones. Los permisos -//! otorgados a cada rol se persisten en la tabla `role_permissions`; la definición -//! de qué permisos existen vive únicamente en memoria. - -use std::sync::OnceLock; +//! Se declaran en el catálogo de permisos de PageTop ([`PermissionRegistry`]) como los de cualquier +//! otra extensión. Los permisos concedidos a cada rol se guardan en la tabla `role_permissions`. use pagetop::prelude::*; use crate::LOCALES_USER; -// **< DeclarePermissions >************************************************************************* - -/// Acción que las extensiones dispatcean para registrar sus permisos en el catálogo. -/// -/// Cada extensión añade una instancia `DeclarePermissions::new(fn)` en `Extension::actions()`. -/// Durante `initialize()`, [`build_registry()`] despacha todas las instancias registradas -/// y construye el catálogo global. -/// -/// `label()`, `group()` y `group_label()` los aporta el propio [`Permission`] registrado -/// (con implementación por defecto si la extensión no los sobrecarga). -/// -/// # Ejemplo -/// -/// ```rust,no_run -/// # use pagetop::prelude::*; -/// # use pagetop_user::permission::{DeclarePermissions, PermissionRegistry}; -/// #[derive(Clone, Copy, Debug)] -/// enum MyPermission { -/// DoSomething, -/// } -/// -/// impl Permission for MyPermission { -/// fn key(&self) -> CowStr { -/// match self { -/// Self::DoSomething => "myext:do_something".into(), -/// } -/// } -/// } -/// -/// fn my_permissions(registry: &mut PermissionRegistry) { -/// registry.register(&MyPermission::DoSomething); -/// } -/// // En Extension::actions(): -/// // DeclarePermissions::new(my_permissions) -/// ``` -pub struct DeclarePermissions { - pub(crate) handler: fn(&mut PermissionRegistry), -} - -impl DeclarePermissions { - pub fn new(handler: fn(&mut PermissionRegistry)) -> Self { - DeclarePermissions { handler } - } - - /// Despacha todas las acciones `DeclarePermissions` registradas construyendo el catálogo. - pub(crate) fn dispatch(registry: &mut PermissionRegistry) { - dispatch_actions(|action: &Self| (action.handler)(registry)); - } -} - -impl ActionDispatcher for DeclarePermissions {} - -// **< PermissionRegistry >************************************************************************* - -/// Catálogo mutable de permisos, construido durante la fase de inicialización. -/// -/// Se construye una sola vez con un conjunto de entradas que conserva el orden de registro sin -/// estructuras adicionales. La UI de administración no usa ese orden de registro. Llama a -/// [`groups_sorted()`](Self::groups_sorted), que lo reordena alfabéticamente para cada petición -/// según el idioma activo. -#[derive(AutoDefault)] -pub struct PermissionRegistry { - permissions: Vec, - /// `(identificador de grupo, título traducible)`, en orden de primer registro. - groups: Vec<(&'static str, Lc)>, -} - -impl PermissionRegistry { - /// Registra un permiso. Se ignora si ya está registrado. - pub fn register(&mut self, perm: PermissionRef) { - let group = perm.group(); - if !self.groups.iter().any(|(g, _)| *g == group) { - self.groups.push((group, perm.group_label())); - } - if !self.has(perm) { - self.permissions.push(perm); - } - } - - /// Comprueba si un permiso está en el catálogo. - pub fn has(&self, perm: PermissionRef) -> bool { - self.permissions.iter().any(|p| p.key() == perm.key()) - } - - /// Comprueba si una clave textual (p. ej. procedente de un formulario) corresponde a un - /// permiso del catálogo. - pub fn has_key(&self, key: &str) -> bool { - self.permissions.iter().any(|p| p.key().as_ref() == key) - } - - pub fn all(&self) -> impl Iterator + '_ { - self.permissions.iter().copied() - } - - /// Grupos en orden de primer registro, sin traducir ni ordenar alfabéticamente. - /// - /// Listado de bajo nivel sobre el que se apoya [`groups_sorted()`](Self::groups_sorted); úsalo - /// en su lugar sólo cuando el orden de registro sea justo lo que se necesita (por ejemplo, para - /// inspeccionar el catálogo en pruebas). - pub fn groups(&self) -> &[(&'static str, Lc)] { - &self.groups - } - - /// Grupos ordenados alfabéticamente por su título traducido al idioma del contexto, no sensible - /// a mayúsculas y, en general, a los acentos (ver [`Lc::collation_key()`] para el criterio - /// exacto y sus límites). - pub fn groups_sorted(&self, cx: &Context) -> Vec<&(&'static str, Lc)> { - let mut groups: Vec<_> = self - .groups - .iter() - .map(|g| (g.1.collation_key(cx), g)) - .collect(); - groups.sort_by(|a, b| a.0.cmp(&b.0)); - groups.into_iter().map(|(_, g)| g).collect() - } - - pub fn by_group<'a>(&'a self, group: &'a str) -> impl Iterator + 'a { - self.permissions - .iter() - .copied() - .filter(move |p| p.group() == group) - } -} - -// **< Catálogo global >**************************************************************************** - -static PERMISSIONS: OnceLock = OnceLock::new(); - -/// Construye y almacena el catálogo global de permisos ejecutando todas las acciones -/// `DeclarePermissions` registradas. Se llama exactamente una vez desde `initialize()`. -pub fn build_registry() { - let mut registry = PermissionRegistry::default(); - DeclarePermissions::dispatch(&mut registry); - let _ = PERMISSIONS.set(registry); -} - -/// Devuelve el catálogo global ya construido. -/// -/// Entra en pánico si se llama antes de `build_registry()`. -pub fn registry() -> &'static PermissionRegistry { - PERMISSIONS - .get() - .expect("permission registry not initialized") -} - // **< Permisos integrados de pagetop-user >******************************************************** /// Permisos propios de `pagetop-user`. diff --git a/extensions/pagetop-user/src/service/role_admin.rs b/extensions/pagetop-user/src/service/role_admin.rs index 13966f5e..33581b56 100644 --- a/extensions/pagetop-user/src/service/role_admin.rs +++ b/extensions/pagetop-user/src/service/role_admin.rs @@ -10,7 +10,6 @@ use pagetop_seaorm::db::{ use crate::entity::{role, role_permission, user_role}; use crate::error::AuthError; -use crate::permission; use crate::session; // **< listado >************************************************************************************ @@ -283,7 +282,7 @@ pub(crate) async fn set_role_permissions( ) -> Result<(), AuthError> { find_role(role_id).await?; - let registry = permission::registry(); + let registry = PermissionRegistry::global(); for key in permission_keys { if !registry.has_key(key) { return Err(AuthError::UnknownPermission(key.clone())); diff --git a/extensions/pagetop-user/tests/flows.rs b/extensions/pagetop-user/tests/flows.rs index e71c8630..fb75a76d 100644 --- a/extensions/pagetop-user/tests/flows.rs +++ b/extensions/pagetop-user/tests/flows.rs @@ -197,6 +197,7 @@ async fn account_flows() { password_resets_are_limited_by_account(&client).await; requests_are_limited_by_address(&client).await; failed_logins_are_limited_by_address(&client).await; + anonymous_visitors_are_offered_to_sign_in(&client).await; } async fn registration_requires_confirming_the_address(client: &Client) { @@ -797,3 +798,34 @@ async fn failed_logins_are_limited_by_address(client: &Client) { .await; assert_eq!(reply.status, Status::SEE_OTHER); } + +// A route that needs a session or a permission sends an anonymous visitor to the login form, which +// returns to that route afterwards. An HTMX request gets the same login as a full-page redirect, +// returning to the page open in the browser, instead of the form inside the fragment it expected. +async fn anonymous_visitors_are_offered_to_sign_in(client: &Client) { + let reply = client.get("/user/edit?tab=1", None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!( + reply.location(), + "/user/login?waypoint=%2Fuser%2Fedit%3Ftab%3D1" + ); + // A public profile checks its permission in the handler, with the same answer. + let reply = client.get("/user/1", None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!(reply.location(), "/user/login?waypoint=%2Fuser%2F1"); + + let request = web::test::TestRequest::get() + .uri("/admin/user/users?page=2") + .header("hx-request", "true") + .header( + "hx-current-url", + "http://localhost:8080/admin/user/users?sort=name", + ); + let reply = client.send(request).await; + assert_eq!(reply.status, Status::OK); + assert!(reply.body.is_empty(), "{}", reply.body); + assert_eq!( + reply.header("hx-redirect"), + "/user/login?waypoint=%2Fadmin%2Fuser%2Fusers%3Fsort%3Dname" + ); +}