♻️ (user): Usa el panel y el acceso del núcleo

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.
This commit is contained in:
Manuel Cillero 2026-11-07 15:18:41 +01:00
parent 824dc4a3ab
commit 9ba493c2c4
19 changed files with 343 additions and 501 deletions

1
Cargo.lock generated
View file

@ -2308,7 +2308,6 @@ dependencies = [
"argon2", "argon2",
"base64ct", "base64ct",
"pagetop", "pagetop",
"pagetop-admin",
"pagetop-htmx", "pagetop-htmx",
"pagetop-mail", "pagetop-mail",
"pagetop-seaorm", "pagetop-seaorm",

View file

@ -20,7 +20,6 @@ demo-data = []
[dependencies] [dependencies]
pagetop.workspace = true pagetop.workspace = true
pagetop-admin.workspace = true
pagetop-seaorm.workspace = true pagetop-seaorm.workspace = true
pagetop-htmx.workspace = true pagetop-htmx.workspace = true
pagetop-mail.workspace = true pagetop-mail.workspace = true

View file

@ -14,8 +14,8 @@
Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la 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 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 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 permisos en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que
cualquier tema. funcionen con cualquier tema.
## Sobre PageTop ## 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. # 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 **Protege tus rutas** con su acceso (`Access`): PageTop lo comprueba antes de llegar al *handler*
contexto de cada `Page` al crearla con `Page::new()`, y las funciones del núcleo, como con los permisos que concede esta extensión, y a un usuario anónimo sin acceso le ofrece el inicio
`has_permission()`, lo consultan: 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 ```rust,no_run
use pagetop::prelude::*; use pagetop::prelude::*;
@ -76,15 +78,16 @@ impl Extension for MyApp {
vec![&pagetop_user::User] vec![&pagetop_user::User]
} }
fn configure_router(&self, router: Router) -> Router { fn configure_router(&self, routes: Routes) -> Routes {
router.route("/dashboard", web::get(dashboard)) routes.route(
"/dashboard",
Access::Permission(&MyPermission::SeeDashboard),
web::get(dashboard),
)
} }
} }
async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> { async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> {
if !has_permission(&request, &MyPermission::SeeDashboard) {
return Err(ErrorPage::NotFound(Some(request)));
}
Page::new(request) Page::new(request)
.with_child(Html::with(|_| html! { h1 { "Panel" } })) .with_child(Html::with(|_| html! { h1 { "Panel" } }))
.render().await .render().await

View file

@ -58,6 +58,8 @@ impl PermissionSet {
/// Se almacena en las extensiones de la petición HTTP durante la fase de middleware y se accede /// 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 /// desde los handlers o desde handlers de [`CheckPermission`] mediante
/// [`HttpRequest::extension::<Account>()`](pagetop::web::HttpRequest::extension). /// [`HttpRequest::extension::<Account>()`](pagetop::web::HttpRequest::extension).
///
/// [`CheckPermission`]: pagetop::base::action::auth::CheckPermission
#[derive(Clone, Debug, Getters)] #[derive(Clone, Debug, Getters)]
pub struct Account { pub struct Account {
/// Identificador del usuario. /// Identificador del usuario.

View file

@ -1,7 +1,6 @@
//! Menú de cuenta (iniciar y cerrar sesión). //! Menú de cuenta (iniciar y cerrar sesión).
use pagetop::prelude::*; use pagetop::prelude::*;
use pagetop_admin::registry::can_access_admin;
use pagetop_htmx::prelude::*; use pagetop_htmx::prelude::*;
use crate::config::SETTINGS; use crate::config::SETTINGS;
@ -49,7 +48,7 @@ pub fn account_menu(cx: &Context) -> Nav {
if can_access_admin(cx) { if can_access_admin(cx) {
menu = menu.with_item(dropdown::Item::link( menu = menu.with_item(dropdown::Item::link(
Lc::t("menu-admin", &LOCALES_USER), Lc::t("menu-admin", &LOCALES_USER),
cx.route(pagetop_admin::ADMIN_BASE_PATH), cx.route(admin_path("")),
)); ));
} }
nav.with_item(nav::Item::dropdown( nav.with_item(nav::Item::dropdown(

View file

@ -37,7 +37,7 @@ impl Component for RoleForm {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> { async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let action = match self.mode() { 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"), RoleFormMode::Edit => role_path(self.role_id().copied().unwrap_or_default(), "edit"),
}; };
let action = self.waypoint().append_to(cx.route(action)); let action = self.waypoint().append_to(cx.route(action));

View file

@ -40,7 +40,7 @@ impl Component for RoleTable {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> { async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let pager = Pager::new() 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("sort", self.sort().as_str())
.with_extra_query("dir", *self.dir()) .with_extra_query("dir", *self.dir())
.with_current_page(self.page()) .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! { Ok(html! {
div (self.props().unpack(cx)) { 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 // 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. // construye con `cx.route()` para que preserve el parámetro `lang` cuando corresponda.
fn list_href(&self, cx: &Context) -> String { 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("sort", self.sort().as_str())
.alter_param("dir", *self.dir()) .alter_param("dir", *self.dir())
.alter_param("page", self.page().to_string()) .alter_param("page", self.page().to_string())
@ -200,7 +200,7 @@ impl RoleTable {
let is_active = *self.sort() == field; let is_active = *self.sort() == field;
let active = is_active.then_some(*self.dir()); let active = is_active.then_some(*self.dir());
let next_dir = SortDir::next_for(active); 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 route
.alter_param("sort", field.as_str()) .alter_param("sort", field.as_str())
.alter_param("dir", next_dir); .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 // 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 // editar/borrar sólo si el rol no está bloqueado por el sistema. Devuelve un componente `Html` para
// `Table` renderice la celda, no al construir la fila. // que el marcado se genere cuando `Table` renderice la celda, no al construir la fila.
async fn actions_cell( async fn actions_cell(
role: &RoleListItem, role: &RoleListItem,
waypoint: &Waypoint, waypoint: &Waypoint,

View file

@ -54,7 +54,7 @@ impl Component for UserForm {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> { async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let action = match self.mode() { 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::Edit => user_path(self.user_id().copied().unwrap_or_default(), "edit"),
UserFormMode::Profile => PROFILE_EDIT_PATH.into(), UserFormMode::Profile => PROFILE_EDIT_PATH.into(),
}; };

View file

@ -39,7 +39,7 @@ impl Component for UserTable {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> { async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let pager = Pager::new() 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("q", self.query().cloned().unwrap_or_default())
.with_extra_query("sort", self.sort().as_str()) .with_extra_query("sort", self.sort().as_str())
.with_extra_query("dir", *self.dir()) .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! { Ok(html! {
div (self.props().unpack(cx)) { 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. // `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. // Se construye con `cx.route()` para que preserve el parámetro `lang` cuando corresponda.
fn list_href(&self, cx: &Context) -> String { 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()) { if let Some(q) = self.query().filter(|q| !q.is_empty()) {
route.alter_param("q", q); route.alter_param("q", q);
} }
@ -167,7 +167,7 @@ impl UserTable {
let active = is_active.then_some(*self.dir()); let active = is_active.then_some(*self.dir());
let next_dir = SortDir::next_for(active); 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()) { if let Some(q) = self.query().filter(|q| !q.is_empty()) {
route.alter_param("q", q); 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 // 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 // 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 // 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 { async fn roles_cell(user: &UserListItem, cx: &mut Context) -> Html {
let mut badges = Vec::with_capacity(user.roles.len().max(1)); let mut badges = Vec::with_capacity(user.roles.len().max(1));
if user.is_admin { if user.is_admin {

View file

@ -4,6 +4,7 @@
use serde::Deserialize; use serde::Deserialize;
use pagetop::prelude::*; use pagetop::prelude::*;
use pagetop_htmx::prelude::*;
use crate::account::{Account, UserStatus}; use crate::account::{Account, UserStatus};
use crate::auth; 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() 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<Response> {
let is_htmx = request.is_htmx();
let waypoint = if is_htmx {
Waypoint::new(
request
.hx_current_url()
.and_then(|url| url.parse::<web::http::Uri>().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 >******************************************************************************** // **< profile_get >********************************************************************************
/// GET /user - Perfil del usuario autenticado. Redirige al formulario de inicio de sesión si no hay /// 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 can_change_password = has_permission(&request, &UserPermission::ChangeOwnPassword);
let mut page = Page::new(request); let mut page = Page::new(request);
let details_block = user_details(&user, page.context()).await; let details_block = user_details(&user, page.context_mut()).await;
let roles_block = profile_roles(&roles, page.context()).await; let roles_block = profile_roles(&roles, page.context_mut()).await;
let actions = profile_actions(can_edit, can_change_password, page.context()); let actions = profile_actions(can_edit, can_change_password, page.context());
page.with_title(Lc::t("title-profile", &LOCALES_USER)) page.with_title(Lc::t("title-profile", &LOCALES_USER))
@ -159,9 +187,12 @@ pub(crate) async fn public_profile_get(
request: HttpRequest, request: HttpRequest,
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
// El permiso se comprueba antes de buscar al usuario para no revelar qué ids existen. // El permiso se comprueba antes de buscar al usuario para no revelar qué ids existen. Sin él, la
if current_user_id(&request) != Some(id) { // misma respuesta que una ruta sin acceso: el inicio de sesión a un anónimo y 403 al resto.
require_permission(&request, &UserPermission::ViewProfiles)?; 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 { let Ok(user) = user_admin::find_user(id).await else {
return Err(ErrorPage::NotFound(Some(request))); return Err(ErrorPage::NotFound(Some(request)));
@ -176,7 +207,7 @@ pub(crate) async fn public_profile_get(
Some(name) => name.to_owned(), Some(name) => name.to_owned(),
None => user.username.clone(), None => user.username.clone(),
}; };
let mut page = Page::new(request); let page = Page::new(request);
let details = public_profile_details(&user, page.context()); let details = public_profile_details(&user, page.context());
Ok(page Ok(page
@ -228,7 +259,6 @@ pub(crate) async fn profile_edit_get(request: HttpRequest) -> Result<Response, E
let Some(id) = current_user_id(&request) else { let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_EDIT_PATH)); return Ok(login_redirect(request, PROFILE_EDIT_PATH));
}; };
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else { let Ok(user) = user_admin::find_user(id).await else {
return Err(ErrorPage::NotFound(Some(request))); return Err(ErrorPage::NotFound(Some(request)));
}; };
@ -270,7 +300,6 @@ pub(crate) async fn profile_edit_post(
let Some(id) = current_user_id(&request) else { let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_EDIT_PATH)); return Ok(login_redirect(request, PROFILE_EDIT_PATH));
}; };
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else { let Ok(user) = user_admin::find_user(id).await else {
return Err(ErrorPage::NotFound(Some(request))); return Err(ErrorPage::NotFound(Some(request)));
}; };
@ -332,7 +361,6 @@ pub(crate) async fn password_get(request: HttpRequest) -> Result<Response, Error
if current_user_id(&request).is_none() { if current_user_id(&request).is_none() {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH)); return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
} }
require_permission(&request, &UserPermission::ChangeOwnPassword)?;
let title = Lc::t("title-profile-password", &LOCALES_USER); let title = Lc::t("title-profile-password", &LOCALES_USER);
Ok(render_profile_page(request, title, ChangePasswordForm::new()).await) Ok(render_profile_page(request, title, ChangePasswordForm::new()).await)
} }
@ -353,7 +381,6 @@ pub(crate) async fn password_post(
let Some(id) = current_user_id(&request) else { let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH)); return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
}; };
require_permission(&request, &UserPermission::ChangeOwnPassword)?;
let sid = session::extract_sid(Some(request.headers())); let sid = session::extract_sid(Some(request.headers()));
let result = match password::passwords_match(&form.password, &form.confirm_password) { let result = match password::passwords_match(&form.password, &form.confirm_password) {
@ -386,7 +413,6 @@ pub(crate) async fn email_get(request: HttpRequest) -> Result<Response, ErrorPag
let Some(id) = current_user_id(&request) else { let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, EMAIL_PATH)); return Ok(login_redirect(request, EMAIL_PATH));
}; };
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else { let Ok(user) = user_admin::find_user(id).await else {
return Err(ErrorPage::NotFound(Some(request))); return Err(ErrorPage::NotFound(Some(request)));
}; };
@ -411,7 +437,6 @@ pub(crate) async fn email_post(
let Some(id) = current_user_id(&request) else { let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, EMAIL_PATH)); return Ok(login_redirect(request, EMAIL_PATH));
}; };
require_permission(&request, &UserPermission::EditOwnProfile)?;
let result = if throttle::allow(&request) { let result = if throttle::allow(&request) {
auth::request_email_change(id, &form.current_password, &form.email).await auth::request_email_change(id, &form.current_password, &form.email).await
@ -510,11 +535,8 @@ async fn render_profile_page(
title: Lc, title: Lc,
form: impl Component + 'static, form: impl Component + 'static,
) -> Response { ) -> Response {
let mut page = Page::new(request); let page = Page::new(request);
let cancel = Button::anchor( let cancel = Button::anchor(Lc::t("btn-cancel", &LOCALES_USER), page.route(PROFILE_PATH));
Lc::t("btn-cancel", &LOCALES_USER),
page.context().route(PROFILE_PATH),
);
page.with_title(title.clone()) page.with_title(title.clone())
.with_child( .with_child(
Block::new() Block::new()

View file

@ -1,26 +1,20 @@
//! Handlers HTTP para el mantenimiento de usuarios, roles y permisos. //! 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 //! Las páginas de usuarios, roles y permisos se declaran en el panel de administración (ver
//! `declare_admin_pages()`). Cada handler comprueba el permiso correspondiente con //! `declare_admin_pages()`), y sus rutas exigen el permiso de su página, que PageTop comprueba
//! [`require_permission()`](pagetop::auth::require_permission) antes de construir la página. //! 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 permissions;
pub(crate) mod roles; pub(crate) mod roles;
pub(crate) mod users; pub(crate) mod users;
use pagetop::prelude::*; use pagetop::prelude::*;
use pagetop_admin::component::AdminFrame;
use crate::LOCALES_USER; use crate::LOCALES_USER;
use crate::error::AuthError; use crate::error::AuthError;
use crate::service::role_admin::ROLE_MACHINE_NAME_MAX_CHARS; 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 // 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. // los errores de autenticación existentes como los nuevos de administración.
pub(crate) fn map_auth_error(err: &AuthError) -> Lc { pub(crate) fn map_auth_error(err: &AuthError) -> Lc {

View file

@ -7,20 +7,16 @@
use pagetop::prelude::*; use pagetop::prelude::*;
use crate::LOCALES_USER; use crate::LOCALES_USER;
use crate::handlers::admin::frame;
use crate::permission::{self, UserPermission};
/// GET /admin/user/permissions - Catálogo de permisos agrupado. /// GET /admin/user/permissions - Catálogo de permisos agrupado.
pub(crate) async fn list_get(request: HttpRequest) -> Result<Response, ErrorPage> { pub(crate) async fn list_get(request: HttpRequest) -> Result<Response, ErrorPage> {
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(); for (group, group_label) in groups {
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()) {
let mut table = Table::new().with_prop(PropsOp::add_classes("user-admin-table")); let mut table = Table::new().with_prop(PropsOp::add_classes("user-admin-table"));
for permission in registry.by_group(group) { for permission in registry.by_group(group) {
table = table.with_row( table = table.with_row(
@ -29,17 +25,12 @@ pub(crate) async fn list_get(request: HttpRequest) -> Result<Response, ErrorPage
.with_cell(permission.key().as_ref()), .with_cell(permission.key().as_ref()),
); );
} }
content = content.with_child( page = page.with_child(
Block::new() Block::new()
.with_title(group_label.clone()) .with_title(group_label.clone())
.with_child(table), .with_child(table),
); );
} }
Ok(page Ok(page.render().await.into_response())
.with_title(title)
.with_child(content)
.render()
.await
.into_response())
} }

View file

@ -12,8 +12,8 @@ use crate::component::admin::{
}; };
use crate::config::SETTINGS; use crate::config::SETTINGS;
use crate::entity::role; use crate::entity::role;
use crate::handlers::admin::{back_link, frame, map_auth_error}; use crate::handlers::admin::{back_link, map_auth_error};
use crate::permission::{self, UserPermission}; use crate::permission::UserPermission;
use crate::role_path; use crate::role_path;
use crate::service::role_admin::{self, RolePageParams, RoleSortField}; use crate::service::role_admin::{self, RolePageParams, RoleSortField};
@ -34,8 +34,6 @@ pub(crate) async fn list_get(
request: HttpRequest, request: HttpRequest,
web::Query(query): web::Query<RolesQuery>, web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let params = RolePageParams { let params = RolePageParams {
sort: RoleSortField::from_query(query.sort.as_deref()), sort: RoleSortField::from_query(query.sort.as_deref()),
dir: SortDir::from_query(query.dir.as_deref()), dir: SortDir::from_query(query.dir.as_deref()),
@ -62,8 +60,8 @@ pub(crate) async fn list_get(
} else { } else {
let title = Lc::t("title-admin-roles", &LOCALES_USER); let title = Lc::t("title-admin-roles", &LOCALES_USER);
Ok(Page::admin(request) Ok(Page::admin(request)
.with_title(title.clone()) .with_title(title)
.with_child(frame(title).with_child(table)) .with_child(table)
.render() .render()
.await .await
.into_response()) .into_response())
@ -77,21 +75,17 @@ pub(crate) async fn new_get(
request: HttpRequest, request: HttpRequest,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?; let page = Page::admin(request);
let mut page = Page::admin(request); let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str()));
let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH));
let title = Lc::t("title-admin-role-new", &LOCALES_USER); let title = Lc::t("title-admin-role-new", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(
frame(title) RoleForm::new()
.with_child( .with_mode(RoleFormMode::New)
RoleForm::new() .with_waypoint(waypoint),
.with_mode(RoleFormMode::New)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
) )
.with_child(back_link(back_href))
.render() .render()
.await .await
.into_response()) .into_response())
@ -113,8 +107,6 @@ pub(crate) async fn new_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
web::Form(form): web::Form<NewRoleFormData>, web::Form(form): web::Form<NewRoleFormData>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let weight: i32 = form.weight.trim().parse().unwrap_or(0); let weight: i32 = form.weight.trim().parse().unwrap_or(0);
let result = role_admin::create_role(role_admin::NewRoleData { let result = role_admin::create_role(role_admin::NewRoleData {
@ -128,12 +120,12 @@ pub(crate) async fn new_post(
match result { match result {
Ok(_) => { Ok(_) => {
let cx = Context::admin(request); 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()) Ok(Redirect::see_other(target).into_response())
} }
Err(err) => { Err(err) => {
let mut page = Page::admin(request); let page = Page::admin(request);
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 = RoleForm::new() let form_component = RoleForm::new()
.with_mode(RoleFormMode::New) .with_mode(RoleFormMode::New)
.with_machine_name(form.machine_name) .with_machine_name(form.machine_name)
@ -144,12 +136,9 @@ pub(crate) async fn new_post(
.with_waypoint(waypoint); .with_waypoint(waypoint);
let title = Lc::t("title-admin-role-new", &LOCALES_USER); let title = Lc::t("title-admin-role-new", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(form_component)
frame(title) .with_child(back_link(back_href))
.with_child(form_component)
.with_child(back_link(back_href)),
)
.render() .render()
.await .await
.into_response()) .into_response())
@ -165,8 +154,6 @@ pub(crate) async fn edit_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let role = match role_admin::find_role(id).await { let role = match role_admin::find_role(id).await {
Ok(role) => role, Ok(role) => role,
Err(_) => return Err(ErrorPage::NotFound(Some(request))), Err(_) => return Err(ErrorPage::NotFound(Some(request))),
@ -175,26 +162,23 @@ pub(crate) async fn edit_get(
return Err(ErrorPage::AccessDenied(Some(request))); return Err(ErrorPage::AccessDenied(Some(request)));
} }
let mut page = Page::admin(request); let page = Page::admin(request);
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-edit", &LOCALES_USER); let title = Lc::t("title-admin-role-edit", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(
frame(title) RoleForm::new()
.with_child( .with_mode(RoleFormMode::Edit)
RoleForm::new() .with_role_id(Some(id))
.with_mode(RoleFormMode::Edit) .with_machine_name(role.machine_name)
.with_role_id(Some(id)) .with_label(role.label)
.with_machine_name(role.machine_name) .with_description(role.description.unwrap_or_default())
.with_label(role.label) .with_weight(role.weight)
.with_description(role.description.unwrap_or_default()) .with_waypoint(waypoint),
.with_weight(role.weight)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
) )
.with_child(back_link(back_href))
.render() .render()
.await .await
.into_response()) .into_response())
@ -216,8 +200,6 @@ pub(crate) async fn edit_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
web::Form(form): web::Form<EditRoleFormData>, web::Form(form): web::Form<EditRoleFormData>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let weight: i32 = form.weight.trim().parse().unwrap_or(0); let weight: i32 = form.weight.trim().parse().unwrap_or(0);
let result = role_admin::update_role( let result = role_admin::update_role(
@ -233,7 +215,7 @@ pub(crate) async fn edit_post(
match result { match result {
Ok(()) => { Ok(()) => {
let cx = Context::admin(request); 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()) Ok(Redirect::see_other(target).into_response())
} }
Err(err) => { Err(err) => {
@ -241,8 +223,8 @@ pub(crate) async fn edit_post(
.await .await
.map(|role| role.machine_name) .map(|role| role.machine_name)
.unwrap_or_default(); .unwrap_or_default();
let mut page = Page::admin(request); let page = Page::admin(request);
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 = RoleForm::new() let form_component = RoleForm::new()
.with_mode(RoleFormMode::Edit) .with_mode(RoleFormMode::Edit)
.with_role_id(Some(id)) .with_role_id(Some(id))
@ -254,12 +236,9 @@ pub(crate) async fn edit_post(
.with_waypoint(waypoint); .with_waypoint(waypoint);
let title = Lc::t("title-admin-role-edit", &LOCALES_USER); let title = Lc::t("title-admin-role-edit", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(form_component)
frame(title) .with_child(back_link(back_href))
.with_child(form_component)
.with_child(back_link(back_href)),
)
.render() .render()
.await .await
.into_response()) .into_response())
@ -276,8 +255,6 @@ pub(crate) async fn view_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let role = match role_admin::find_role(id).await { let role = match role_admin::find_role(id).await {
Ok(role) => role, Ok(role) => role,
Err(_) => return Err(ErrorPage::NotFound(Some(request))), Err(_) => return Err(ErrorPage::NotFound(Some(request))),
@ -289,19 +266,17 @@ pub(crate) async fn view_get(
let mut page = Page::admin(request); let mut page = Page::admin(request);
let groups = build_permission_groups(&selected, page.context()); 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 details_block = role_view_details(&role, page.context()).await; let details_block = role_view_details(&role, page.context_mut()).await;
let title = Lc::t("title-admin-role-view", &LOCALES_USER); 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) { 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 Ok(page
.with_title(title) .with_child(back_link(back_href))
.with_child(content)
.render() .render()
.await .await
.into_response()) .into_response())
@ -389,8 +364,6 @@ pub(crate) async fn delete_post(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(query): web::Query<RolesQuery>, web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let result = role_admin::delete_role(id).await; let result = role_admin::delete_role(id).await;
if request.is_htmx() { if request.is_htmx() {
@ -419,7 +392,7 @@ pub(crate) async fn delete_post(
match result { match result {
Ok(()) => { Ok(()) => {
let target = cx let target = cx
.route(ADMIN_ROLES_PATH) .route(ADMIN_ROLES_PATH.as_str())
.alter_param( .alter_param(
"sort", "sort",
RoleSortField::from_query(query.sort.as_deref()).as_str(), 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<i32>, web::Path(id): web::Path<i32>,
web::Query(query): web::Query<RolesQuery>, web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
let mut cx = Context::admin(request); let mut cx = Context::admin(request);
let delete_href = cx let delete_href = cx
.route(role_path(id, "delete")) .route(role_path(id, "delete"))
@ -473,7 +444,7 @@ pub(crate) async fn delete_confirm_get(
// **< permissions_get / permissions_post >********************************************************* // **< permissions_get / permissions_post >*********************************************************
fn build_permission_groups(selected: &[String], cx: &Context) -> PermissionGroups { fn build_permission_groups(selected: &[String], cx: &Context) -> PermissionGroups {
let registry = permission::registry(); let registry = PermissionRegistry::global();
registry registry
.groups_sorted(cx) .groups_sorted(cx)
.into_iter() .into_iter()
@ -498,7 +469,6 @@ pub(crate) async fn permissions_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
require_permission(&request, &UserPermission::AdminPermissions)?; require_permission(&request, &UserPermission::AdminPermissions)?;
if role_admin::find_role(id).await.is_err() { if role_admin::find_role(id).await.is_err() {
@ -508,24 +478,21 @@ pub(crate) async fn permissions_get(
Ok(keys) => keys, Ok(keys) => keys,
Err(_) => return Err(ErrorPage::InternalError(Some(request))), 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 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); let title = Lc::t("title-admin-role-permissions", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(
frame(title) RolePermissionsForm::new()
.with_child( .with_role_id(id)
RolePermissionsForm::new() .with_groups(groups)
.with_role_id(id) .with_waypoint(waypoint),
.with_groups(groups)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
) )
.with_child(back_link(back_href))
.render() .render()
.await .await
.into_response()) .into_response())
@ -547,7 +514,6 @@ pub(crate) async fn permissions_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
raw: web::RawForm, raw: web::RawForm,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
require_permission(&request, &UserPermission::AdminPermissions)?; require_permission(&request, &UserPermission::AdminPermissions)?;
let Ok(form) = serde_qs::from_bytes::<RolePermissionsFormData>(&raw.0) else { let Ok(form) = serde_qs::from_bytes::<RolePermissionsFormData>(&raw.0) else {
@ -557,14 +523,14 @@ pub(crate) async fn permissions_post(
match role_admin::set_role_permissions(id, &form.permission_keys).await { match role_admin::set_role_permissions(id, &form.permission_keys).await {
Ok(()) => { Ok(()) => {
let cx = Context::admin(request); 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()) Ok(Redirect::see_other(target).into_response())
} }
Err(err) => { Err(err) => {
let mut page = Page::admin(request); let page = Page::admin(request);
let groups = build_permission_groups(&form.permission_keys, page.context()); 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() let form_component = RolePermissionsForm::new()
.with_role_id(id) .with_role_id(id)
.with_groups(groups) .with_groups(groups)
@ -572,12 +538,9 @@ pub(crate) async fn permissions_post(
.with_waypoint(waypoint); .with_waypoint(waypoint);
let title = Lc::t("title-admin-role-permissions", &LOCALES_USER); let title = Lc::t("title-admin-role-permissions", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(form_component)
frame(title) .with_child(back_link(back_href))
.with_child(form_component)
.with_child(back_link(back_href)),
)
.render() .render()
.await .await
.into_response()) .into_response())

View file

@ -15,7 +15,7 @@ use crate::component::user_details;
use crate::config::SETTINGS; use crate::config::SETTINGS;
use crate::entity::{role, user}; use crate::entity::{role, user};
use crate::error::AuthError; 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::mail::{Notice, send_notice};
use crate::password; use crate::password;
use crate::permission::UserPermission; use crate::permission::UserPermission;
@ -43,8 +43,6 @@ pub(crate) async fn list_get(
request: HttpRequest, request: HttpRequest,
web::Query(query): web::Query<UsersQuery>, web::Query(query): web::Query<UsersQuery>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let params = UserListParams { let params = UserListParams {
query: query.q.clone(), query: query.q.clone(),
sort: UserSortField::from_query(query.sort.as_deref()), sort: UserSortField::from_query(query.sort.as_deref()),
@ -73,12 +71,9 @@ pub(crate) async fn list_get(
} else { } else {
let title = Lc::t("title-admin-users", &LOCALES_USER); let title = Lc::t("title-admin-users", &LOCALES_USER);
Ok(Page::admin(request) Ok(Page::admin(request)
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(search_bar(query.q))
frame(title) .with_child(table)
.with_child(search_bar(query.q))
.with_child(table),
)
.render() .render()
.await .await
.into_response()) .into_response())
@ -98,7 +93,7 @@ fn search_bar(current_query: Option<String>) -> Html {
name="q" name="q"
value=(value.as_str()) value=(value.as_str())
placeholder=[Lc::t("field-search-users", &LOCALES_USER).lookup(cx)] 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-trigger="keyup changed delay:400ms, search"
hx-target="#user-table-wrapper" hx-target="#user-table-wrapper"
hx-swap=(hx::swap::OUTER_HTML_SCROLL_TOP) hx-swap=(hx::swap::OUTER_HTML_SCROLL_TOP)
@ -155,7 +150,6 @@ pub(crate) async fn new_get(
request: HttpRequest, request: HttpRequest,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let roles = match available_roles(&[]).await { let roles = match available_roles(&[]).await {
Ok(roles) => roles, Ok(roles) => roles,
Err(_) => return Err(ErrorPage::InternalError(Some(request))), 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 // 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`). // permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`).
let allow_admin_field = request.extension::<Account>().is_some_and(|a| a.is_admin()); let allow_admin_field = request.extension::<Account>().is_some_and(|a| a.is_admin());
let mut page = Page::admin(request); let 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-new", &LOCALES_USER); let title = Lc::t("title-admin-user-new", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(
frame(title) UserForm::new()
.with_child( .with_mode(UserFormMode::New)
UserForm::new() .with_roles(roles)
.with_mode(UserFormMode::New) .with_allow_admin_field(allow_admin_field)
.with_roles(roles) .with_waypoint(waypoint),
.with_allow_admin_field(allow_admin_field)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
) )
.with_child(back_link(back_href))
.render() .render()
.await .await
.into_response()) .into_response())
@ -213,7 +204,6 @@ pub(crate) async fn new_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
raw: web::RawForm, raw: web::RawForm,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let Ok(form) = serde_qs::from_bytes::<NewUserFormData>(&raw.0) else { let Ok(form) = serde_qs::from_bytes::<NewUserFormData>(&raw.0) else {
return Err(ErrorPage::BadRequest(Some(request))); return Err(ErrorPage::BadRequest(Some(request)));
}; };
@ -240,13 +230,13 @@ pub(crate) async fn new_post(
match result { match result {
Ok(_) => { Ok(_) => {
let cx = Context::admin(request); 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()) Ok(Redirect::see_other(target).into_response())
} }
Err(err) => { Err(err) => {
let roles = available_roles(&role_ids).await.unwrap_or_default(); let roles = available_roles(&role_ids).await.unwrap_or_default();
let mut page = Page::admin(request); let 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 form_component = UserForm::new() let form_component = UserForm::new()
.with_mode(UserFormMode::New) .with_mode(UserFormMode::New)
.with_username(form.username) .with_username(form.username)
@ -262,12 +252,9 @@ pub(crate) async fn new_post(
.with_waypoint(waypoint); .with_waypoint(waypoint);
let title = Lc::t("title-admin-user-new", &LOCALES_USER); let title = Lc::t("title-admin-user-new", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(form_component)
frame(title) .with_child(back_link(back_href))
.with_child(form_component)
.with_child(back_link(back_href)),
)
.render() .render()
.await .await
.into_response()) .into_response())
@ -331,7 +318,7 @@ async fn render_edit_page(
// Bloquear y activar exige además `user:block_accounts` (ver `status_post`). // Bloquear y activar exige además `user:block_accounts` (ver `status_post`).
let can_change_status = has_permission(&request, &UserPermission::BlockAccounts); let can_change_status = has_permission(&request, &UserPermission::BlockAccounts);
let mut page = Page::admin(request); 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 title = Lc::t("title-admin-user-edit", &LOCALES_USER);
let actions = edit_actions( let actions = edit_actions(
id, id,
@ -340,20 +327,17 @@ async fn render_edit_page(
can_toggle_admin, can_toggle_admin,
can_change_status, can_change_status,
&waypoint, &waypoint,
page.context(), page.context_mut(),
); );
page.with_title(title.clone()) page.with_title(title)
.with_child( .with_child(
frame(title) form.with_mode(UserFormMode::Edit)
.with_child( .with_user_id(Some(id))
form.with_mode(UserFormMode::Edit) .with_waypoint(waypoint.clone()),
.with_user_id(Some(id))
.with_waypoint(waypoint.clone()),
)
.with_child(actions)
.with_child(back_link(back_href)),
) )
.with_child(actions)
.with_child(back_link(back_href))
.render() .render()
.await .await
.into_response() .into_response()
@ -451,7 +435,6 @@ pub(crate) async fn edit_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
require_manageable(&request, id).await?; require_manageable(&request, id).await?;
Ok(render_user_edit(request, id, None, waypoint).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<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
raw: web::RawForm, raw: web::RawForm,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = require_manageable(&request, id).await?; let user = require_manageable(&request, id).await?;
let Ok(form) = serde_qs::from_bytes::<EditUserFormData>(&raw.0) else { let Ok(form) = serde_qs::from_bytes::<EditUserFormData>(&raw.0) else {
return Err(ErrorPage::BadRequest(Some(request))); return Err(ErrorPage::BadRequest(Some(request)));
@ -510,7 +492,7 @@ pub(crate) async fn edit_post(
match result { match result {
Ok(()) => { Ok(()) => {
let cx = Context::admin(request); 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()) Ok(Redirect::see_other(target).into_response())
} }
Err(err) => { Err(err) => {
@ -540,8 +522,6 @@ pub(crate) async fn view_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = match user_admin::find_user(id).await { let user = match user_admin::find_user(id).await {
Ok(user) => user, Ok(user) => user,
Err(_) => return Err(ErrorPage::NotFound(Some(request))), Err(_) => return Err(ErrorPage::NotFound(Some(request))),
@ -552,19 +532,16 @@ pub(crate) async fn view_get(
}; };
let mut page = Page::admin(request); 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 details_block = user_details(&user, page.context()).await; let details_block = user_details(&user, page.context_mut()).await;
let roles_block = user_view_roles(&roles, user.is_admin, page.context()).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); let title = Lc::t("title-admin-user-view", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child( .with_child(details_block)
frame(title) .with_child(roles_block)
.with_child(details_block) .with_child(back_link(back_href))
.with_child(roles_block)
.with_child(back_link(back_href)),
)
.render() .render()
.await .await
.into_response()) .into_response())
@ -645,7 +622,6 @@ pub(crate) async fn status_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
web::Form(form): web::Form<StatusFormData>, web::Form(form): web::Form<StatusFormData>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
require_permission(&request, &UserPermission::BlockAccounts)?; require_permission(&request, &UserPermission::BlockAccounts)?;
require_manageable(&request, id).await?; require_manageable(&request, id).await?;
let Some(account) = request.extension::<Account>().cloned() else { let Some(account) = request.extension::<Account>().cloned() else {
@ -731,23 +707,19 @@ pub(crate) async fn password_get(
web::Path(id): web::Path<i32>, web::Path(id): web::Path<i32>,
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = require_manageable(&request, id).await?; let user = require_manageable(&request, id).await?;
let mut page = Page::admin(request); let page = Page::admin(request);
let edit_href = waypoint.append_to(page.context().route(user_path(id, "edit"))); let edit_href = waypoint.append_to(page.route(user_path(id, "edit")));
let title = Lc::t("title-admin-user-password", &LOCALES_USER); let title = Lc::t("title-admin-user-password", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child(user_summary(&user))
.with_child( .with_child(
frame(title) AdminPasswordForm::new()
.with_child(user_summary(&user)) .with_user_id(id)
.with_child( .with_waypoint(waypoint),
AdminPasswordForm::new()
.with_user_id(id)
.with_waypoint(waypoint),
)
.with_child(back_link(edit_href)),
) )
.with_child(back_link(edit_href))
.render() .render()
.await .await
.into_response()) .into_response())
@ -767,7 +739,6 @@ pub(crate) async fn password_post(
web::Query(waypoint): web::Query<Waypoint>, web::Query(waypoint): web::Query<Waypoint>,
web::Form(form): web::Form<AdminPasswordFormData>, web::Form(form): web::Form<AdminPasswordFormData>,
) -> Result<Response, ErrorPage> { ) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = require_manageable(&request, id).await?; let user = require_manageable(&request, id).await?;
let result = match password::passwords_match(&form.password, &form.confirm_password) { 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()) Ok(Redirect::see_other(edit_href).into_response())
} }
Err(err) => { Err(err) => {
let mut page = Page::admin(request); let page = Page::admin(request);
let edit_href = waypoint.append_to(page.context().route(user_path(id, "edit"))); let edit_href = waypoint.append_to(page.route(user_path(id, "edit")));
let title = Lc::t("title-admin-user-password", &LOCALES_USER); let title = Lc::t("title-admin-user-password", &LOCALES_USER);
Ok(page Ok(page
.with_title(title.clone()) .with_title(title)
.with_child(user_summary(&user))
.with_child( .with_child(
frame(title) AdminPasswordForm::new()
.with_child(user_summary(&user)) .with_user_id(id)
.with_child( .with_error(map_auth_error(&err))
AdminPasswordForm::new() .with_waypoint(waypoint),
.with_user_id(id)
.with_error(map_auth_error(&err))
.with_waypoint(waypoint),
)
.with_child(back_link(edit_href)),
) )
.with_child(back_link(edit_href))
.render() .render()
.await .await
.into_response()) .into_response())

View file

@ -15,8 +15,8 @@
Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la 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 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 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 permisos en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que
cualquier tema. funcionen con cualquier tema.
## Sobre PageTop ## 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. # 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 **Protege tus rutas** con su acceso (`Access`): PageTop lo comprueba antes de llegar al *handler*
contexto de cada [`Page`] al crearla con [`Page::new()`], y las funciones del núcleo, como con los permisos que concede esta extensión, y a un usuario anónimo sin acceso le ofrece el inicio
[`has_permission()`], lo consultan: 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 ```rust,no_run
use pagetop::prelude::*; use pagetop::prelude::*;
@ -77,15 +79,16 @@ impl Extension for MyApp {
vec![&pagetop_user::User] vec![&pagetop_user::User]
} }
fn configure_router(&self, router: Router) -> Router { fn configure_router(&self, routes: Routes) -> Routes {
router.route("/dashboard", web::get(dashboard)) routes.route(
"/dashboard",
Access::Permission(&MyPermission::SeeDashboard),
web::get(dashboard),
)
} }
} }
async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> { async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> {
if !has_permission(&request, &MyPermission::SeeDashboard) {
return Err(ErrorPage::NotFound(Some(request)));
}
Page::new(request) Page::new(request)
.with_child(Html::with(|_| html! { h1 { "Panel" } })) .with_child(Html::with(|_| html! { h1 { "Panel" } }))
.render().await .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::prelude::*;
use pagetop_admin::prelude::*;
use pagetop_seaorm::install_migrations; use pagetop_seaorm::install_migrations;
use std::sync::LazyLock;
pub mod account; pub mod account;
pub mod config; pub mod config;
pub mod error; pub mod error;
@ -187,7 +191,6 @@ pub mod component;
include_locales!(LOCALES_USER); include_locales!(LOCALES_USER);
pub use account::{Account, UserStatus}; pub use account::{Account, UserStatus};
pub use permission::{DeclarePermissions, PermissionRegistry};
/// Prelude de `pagetop-user`. /// Prelude de `pagetop-user`.
pub mod prelude { pub mod prelude {
@ -195,7 +198,7 @@ pub mod prelude {
pub use crate::component::UserName; pub use crate::component::UserName;
pub use crate::component::{AccountMenu, account_menu}; pub use crate::component::{AccountMenu, account_menu};
pub use crate::error::AuthError; pub use crate::error::AuthError;
pub use crate::{Account, DeclarePermissions, UserStatus}; pub use crate::{Account, UserStatus};
} }
// **< Rutas HTTP (fijas) >************************************************************************* // **< Rutas HTTP (fijas) >*************************************************************************
@ -236,15 +239,20 @@ const PASSWORD_RESET_PATH: &str = "/user/password/reset";
// POST - la confirma. // POST - la confirma.
const VERIFY_PATH: &str = "/user/verify"; 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 // Listado, alta, edición, asignación de roles, bloqueo/activación y restablecimiento de contraseña
// de usuarios. // de usuarios.
const ADMIN_USERS_PATH: &str = "/admin/user/users"; const ADMIN_USERS: &str = "user/users";
static ADMIN_USERS_PATH: LazyLock<String> = LazyLock::new(|| admin_path(ADMIN_USERS));
// Listado, alta, edición, eliminación y asignación de permisos de roles. // 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<String> = LazyLock::new(|| admin_path(ADMIN_ROLES));
// Catálogo de permisos registrados, agrupado por extensión (solo lectura). // 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}`. // Ruta del perfil público del usuario `id`: `{PROFILE_PATH}/{id}`.
fn profile_path(id: i32) -> String { 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}`. // Ruta de una acción sobre el usuario `id`: `{ADMIN_USERS_PATH}/{id}/{tail}`.
fn user_path(id: i32, tail: &str) -> String { 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}`. // Ruta de una acción sobre el rol `id`: `{ADMIN_ROLES_PATH}/{id}/{tail}`.
fn role_path(id: i32, tail: &str) -> String { 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 // Declara las páginas de usuarios, roles y permisos en el panel de administración, bajo la sección
// sección integrada "people". Las rutas y sus handlers ya están registrados en // integrada "people". Las rutas y sus handlers ya están registrados en `configure_router()`; esta
// `configure_router()`; este registro sólo aporta el metadato (título, sección, permiso) para que // declaración sólo aporta el metadato (título, sección, permiso) para que aparezcan en el panel.
// aparezcan en la portada `/admin`. fn declare_admin_pages(bag: &mut AdminPageBag) {
fn declare_admin_pages(bag: &mut PageBag) { bag.add(
bag.add(AdminPage { AdminPage::new(
path: ADMIN_USERS_PATH.to_owned(), ADMIN_USERS,
section: "people".to_owned(), "people",
title: Lc::t("title-admin-users", &LOCALES_USER), Lc::t("title-admin-users", &LOCALES_USER),
description: Some(Lc::t("description-admin-users", &LOCALES_USER)), &permission::UserPermission::AdminUsers,
weight: 0, )
permission: &permission::UserPermission::AdminUsers, .with_description(Lc::t("description-admin-users", &LOCALES_USER)),
kind: AdminPageKind::View, );
}); bag.add(
bag.add(AdminPage { AdminPage::new(
path: ADMIN_ROLES_PATH.to_owned(), ADMIN_ROLES,
section: "people".to_owned(), "people",
title: Lc::t("title-admin-roles", &LOCALES_USER), Lc::t("title-admin-roles", &LOCALES_USER),
description: Some(Lc::t("description-admin-roles", &LOCALES_USER)), &permission::UserPermission::AdminRoles,
weight: 10, )
permission: &permission::UserPermission::AdminRoles, .with_description(Lc::t("description-admin-roles", &LOCALES_USER))
kind: AdminPageKind::View, .with_weight(10),
}); );
bag.add(AdminPage { bag.add(
path: ADMIN_PERMISSIONS_PATH.to_owned(), AdminPage::new(
section: "people".to_owned(), ADMIN_PERMISSIONS,
title: Lc::t("title-admin-permissions", &LOCALES_USER), "people",
description: Some(Lc::t("description-admin-permissions", &LOCALES_USER)), Lc::t("title-admin-permissions", &LOCALES_USER),
weight: 20, &permission::UserPermission::AdminPermissions,
permission: &permission::UserPermission::AdminPermissions, )
kind: AdminPageKind::View, .with_description(Lc::t("description-admin-permissions", &LOCALES_USER))
}); .with_weight(20),
);
} }
// **< Roles de sistema (fijos) >******************************************************************* // **< Roles de sistema (fijos) >*******************************************************************
@ -344,7 +353,6 @@ impl Extension for User {
fn dependencies(&self) -> Vec<ExtensionRef> { fn dependencies(&self) -> Vec<ExtensionRef> {
vec![ vec![
&pagetop_admin::Admin,
&pagetop_seaorm::SeaORM, &pagetop_seaorm::SeaORM,
&pagetop_htmx::Htmx, &pagetop_htmx::Htmx,
&pagetop_mail::Mail, &pagetop_mail::Mail,
@ -354,11 +362,13 @@ impl Extension for User {
fn actions(&self) -> Vec<ActionBox> { fn actions(&self) -> Vec<ActionBox> {
actions![ actions![
// Comprueba permisos mediante el modelo RBAC almacenado en BD. // 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. // Registra los permisos propios de pagetop-user.
DeclarePermissions::new(permission::declare_builtin_permissions), action::auth::DeclarePermissions::new(permission::declare_builtin_permissions),
// Registra las páginas de usuarios, roles y permisos en el portal de pagetop-admin. // Declara las páginas de usuarios, roles y permisos en el panel de administración.
DeclareAdminPages::new(declare_admin_pages), action::admin::DeclareAdminPages::new(declare_admin_pages),
// Declara las vistas previas de los correos de recuperación y verificación. // Declara las vistas previas de los correos de recuperación y verificación.
pagetop_mail::DeclareMailPreviews::new(mail::declare_previews), pagetop_mail::DeclareMailPreviews::new(mail::declare_previews),
] ]
@ -373,7 +383,6 @@ impl Extension for User {
m20260629_000005_create_sessions, m20260629_000005_create_sessions,
m20260629_000006_create_user_tokens, m20260629_000006_create_user_tokens,
)?; )?;
permission::build_registry();
// Los permisos de "anonymous" en memoria sobreviven a una nueva preparación en el mismo // 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. // proceso (las pruebas lo hacen), que puede usar otra base de datos.
session::invalidate_anonymous_permissions(); session::invalidate_anonymous_permissions();
@ -383,113 +392,123 @@ impl Extension for User {
Ok(()) Ok(())
} }
fn configure_router(&self, router: Router) -> Router { fn configure_router(&self, routes: Routes) -> Routes {
router let edit_own_profile = Access::Permission(&permission::UserPermission::EditOwnProfile);
.route( let change_own_password =
Access::Permission(&permission::UserPermission::ChangeOwnPassword);
routes
.public_route(
LOGIN_PATH, LOGIN_PATH,
web::get(handlers::auth::login_get).post(handlers::auth::login_post), web::get(handlers::auth::login_get).post(handlers::auth::login_post),
) )
.route(LOGOUT_PATH, web::post(handlers::auth::logout_post)) .public_route(LOGOUT_PATH, web::post(handlers::auth::logout_post))
.route( .public_route(
REGISTER_PATH, REGISTER_PATH,
web::get(handlers::auth::register_get).post(handlers::auth::register_post), web::get(handlers::auth::register_get).post(handlers::auth::register_post),
) )
.route(PROFILE_PATH, web::get(handlers::account::profile_get))
.route( .route(
PROFILE_PATH,
Access::Authenticated,
web::get(handlers::account::profile_get),
)
.public_route(
&format!("{}/{{id}}", PROFILE_PATH), &format!("{}/{{id}}", PROFILE_PATH),
web::get(handlers::account::public_profile_get), web::get(handlers::account::public_profile_get),
) )
.route( .route(
PROFILE_EDIT_PATH, PROFILE_EDIT_PATH,
edit_own_profile,
web::get(handlers::account::profile_edit_get) web::get(handlers::account::profile_edit_get)
.post(handlers::account::profile_edit_post), .post(handlers::account::profile_edit_post),
) )
.route( .route(
PROFILE_PASSWORD_PATH, PROFILE_PASSWORD_PATH,
change_own_password,
web::get(handlers::account::password_get).post(handlers::account::password_post), web::get(handlers::account::password_get).post(handlers::account::password_post),
) )
.route( .route(
EMAIL_PATH, EMAIL_PATH,
edit_own_profile,
web::get(handlers::account::email_get).post(handlers::account::email_post), web::get(handlers::account::email_get).post(handlers::account::email_post),
) )
.route( .public_route(
&format!("{}/{{uid}}/{{token}}", EMAIL_PATH), &format!("{}/{{uid}}/{{token}}", EMAIL_PATH),
web::get(handlers::account::email_confirm_get) web::get(handlers::account::email_confirm_get)
.post(handlers::account::email_confirm_post), .post(handlers::account::email_confirm_post),
) )
.route( .public_route(
PASSWORD_RESET_PATH, PASSWORD_RESET_PATH,
web::get(handlers::auth::password_reset_get) web::get(handlers::auth::password_reset_get)
.post(handlers::auth::password_reset_post), .post(handlers::auth::password_reset_post),
) )
.route( .public_route(
&format!("{}/{{uid}}/{{token}}", PASSWORD_RESET_PATH), &format!("{}/{{uid}}/{{token}}", PASSWORD_RESET_PATH),
web::get(handlers::auth::password_reset_confirm_get) web::get(handlers::auth::password_reset_confirm_get)
.post(handlers::auth::password_reset_confirm_post), .post(handlers::auth::password_reset_confirm_post),
) )
.route( .public_route(
&format!("{}/{{uid}}/{{token}}", VERIFY_PATH), &format!("{}/{{uid}}/{{token}}", VERIFY_PATH),
web::get(handlers::auth::verify_email_get).post(handlers::auth::verify_email_post), web::get(handlers::auth::verify_email_get).post(handlers::auth::verify_email_post),
) )
.route(ADMIN_USERS_PATH, web::get(handlers::admin::users::list_get)) .admin_route(ADMIN_USERS, web::get(handlers::admin::users::list_get))
.route( .admin_route(
&format!("{}/new", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/new"),
web::get(handlers::admin::users::new_get).post(handlers::admin::users::new_post), web::get(handlers::admin::users::new_get).post(handlers::admin::users::new_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/edit", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/{{id}}/edit"),
web::get(handlers::admin::users::edit_get).post(handlers::admin::users::edit_post), web::get(handlers::admin::users::edit_get).post(handlers::admin::users::edit_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/view", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/{{id}}/view"),
web::get(handlers::admin::users::view_get), web::get(handlers::admin::users::view_get),
) )
.route( .admin_route(
&format!("{}/{{id}}/status", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/{{id}}/status"),
web::post(handlers::admin::users::status_post), web::post(handlers::admin::users::status_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/admin", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/{{id}}/admin"),
web::post(handlers::admin::users::admin_post), web::post(handlers::admin::users::admin_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/password", ADMIN_USERS_PATH), &format!("{ADMIN_USERS}/{{id}}/password"),
web::get(handlers::admin::users::password_get) web::get(handlers::admin::users::password_get)
.post(handlers::admin::users::password_post), .post(handlers::admin::users::password_post),
) )
.route(ADMIN_ROLES_PATH, web::get(handlers::admin::roles::list_get)) .admin_route(ADMIN_ROLES, web::get(handlers::admin::roles::list_get))
.route( .admin_route(
&format!("{}/new", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/new"),
web::get(handlers::admin::roles::new_get).post(handlers::admin::roles::new_post), web::get(handlers::admin::roles::new_get).post(handlers::admin::roles::new_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/edit", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/{{id}}/edit"),
web::get(handlers::admin::roles::edit_get).post(handlers::admin::roles::edit_post), web::get(handlers::admin::roles::edit_get).post(handlers::admin::roles::edit_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/view", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/{{id}}/view"),
web::get(handlers::admin::roles::view_get), web::get(handlers::admin::roles::view_get),
) )
.route( .admin_route(
&format!("{}/{{id}}/delete", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/{{id}}/delete"),
web::post(handlers::admin::roles::delete_post), web::post(handlers::admin::roles::delete_post),
) )
.route( .admin_route(
&format!("{}/{{id}}/delete/confirm", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/{{id}}/delete/confirm"),
web::get(handlers::admin::roles::delete_confirm_get), web::get(handlers::admin::roles::delete_confirm_get),
) )
.route( .admin_route(
&format!("{}/{{id}}/permissions", ADMIN_ROLES_PATH), &format!("{ADMIN_ROLES}/{{id}}/permissions"),
web::get(handlers::admin::roles::permissions_get) web::get(handlers::admin::roles::permissions_get)
.post(handlers::admin::roles::permissions_post), .post(handlers::admin::roles::permissions_post),
) )
.route( .admin_route(
ADMIN_PERMISSIONS_PATH, ADMIN_PERMISSIONS,
web::get(handlers::admin::permissions::list_get), web::get(handlers::admin::permissions::list_get),
) )
} }
fn configure_middleware(&self, router: Router) -> Router { fn configure_middleware(&self, layers: Layers) -> Layers {
router.layer(web::middleware::from_fn(middleware::session_middleware)) layers.layer(web::middleware::from_fn(middleware::session_middleware))
} }
} }

View file

@ -67,7 +67,8 @@ pub(crate) async fn session_middleware(
// **< check_rbac_permission >********************************************************************** // **< 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 /// 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, /// HTTP y concede el permiso si el account lo tiene (un administrador lo tiene concedido siempre,

View file

@ -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 //! Se declaran en el catálogo de permisos de PageTop ([`PermissionRegistry`]) como los de cualquier
//! las acciones `DeclarePermissions` registradas por todas las extensiones. Los permisos //! otra extensión. Los permisos concedidos a cada rol se guardan en la tabla `role_permissions`.
//! 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;
use pagetop::prelude::*; use pagetop::prelude::*;
use crate::LOCALES_USER; 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<PermissionRef>,
/// `(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<Item = PermissionRef> + '_ {
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<Item = PermissionRef> + 'a {
self.permissions
.iter()
.copied()
.filter(move |p| p.group() == group)
}
}
// **< Catálogo global >****************************************************************************
static PERMISSIONS: OnceLock<PermissionRegistry> = 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 integrados de pagetop-user >********************************************************
/// Permisos propios de `pagetop-user`. /// Permisos propios de `pagetop-user`.

View file

@ -10,7 +10,6 @@ use pagetop_seaorm::db::{
use crate::entity::{role, role_permission, user_role}; use crate::entity::{role, role_permission, user_role};
use crate::error::AuthError; use crate::error::AuthError;
use crate::permission;
use crate::session; use crate::session;
// **< listado >************************************************************************************ // **< listado >************************************************************************************
@ -283,7 +282,7 @@ pub(crate) async fn set_role_permissions(
) -> Result<(), AuthError> { ) -> Result<(), AuthError> {
find_role(role_id).await?; find_role(role_id).await?;
let registry = permission::registry(); let registry = PermissionRegistry::global();
for key in permission_keys { for key in permission_keys {
if !registry.has_key(key) { if !registry.has_key(key) {
return Err(AuthError::UnknownPermission(key.clone())); return Err(AuthError::UnknownPermission(key.clone()));

View file

@ -197,6 +197,7 @@ async fn account_flows() {
password_resets_are_limited_by_account(&client).await; password_resets_are_limited_by_account(&client).await;
requests_are_limited_by_address(&client).await; requests_are_limited_by_address(&client).await;
failed_logins_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) { async fn registration_requires_confirming_the_address(client: &Client) {
@ -797,3 +798,34 @@ async fn failed_logins_are_limited_by_address(client: &Client) {
.await; .await;
assert_eq!(reply.status, Status::SEE_OTHER); 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"
);
}