♻️ (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",
"base64ct",
"pagetop",
"pagetop-admin",
"pagetop-htmx",
"pagetop-mail",
"pagetop-seaorm",

View file

@ -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

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
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<Markup, ErrorPage> {
if !has_permission(&request, &MyPermission::SeeDashboard) {
return Err(ErrorPage::NotFound(Some(request)));
}
Page::new(request)
.with_child(Html::with(|_| html! { h1 { "Panel" } }))
.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
/// desde los handlers o desde handlers de [`CheckPermission`] mediante
/// [`HttpRequest::extension::<Account>()`](pagetop::web::HttpRequest::extension).
///
/// [`CheckPermission`]: pagetop::base::action::auth::CheckPermission
#[derive(Clone, Debug, Getters)]
pub struct Account {
/// Identificador del usuario.

View file

@ -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(

View file

@ -37,7 +37,7 @@ impl Component for RoleForm {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
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));

View file

@ -40,7 +40,7 @@ impl Component for RoleTable {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
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,

View file

@ -54,7 +54,7 @@ impl Component for UserForm {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
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(),
};

View file

@ -39,7 +39,7 @@ impl Component for UserTable {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
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 {

View file

@ -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<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 >********************************************************************************
/// 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<i32>,
) -> Result<Response, ErrorPage> {
// 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<Response, E
let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_EDIT_PATH));
};
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else {
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 {
return Ok(login_redirect(request, PROFILE_EDIT_PATH));
};
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else {
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() {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
}
require_permission(&request, &UserPermission::ChangeOwnPassword)?;
let title = Lc::t("title-profile-password", &LOCALES_USER);
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 {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
};
require_permission(&request, &UserPermission::ChangeOwnPassword)?;
let sid = session::extract_sid(Some(request.headers()));
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 {
return Ok(login_redirect(request, EMAIL_PATH));
};
require_permission(&request, &UserPermission::EditOwnProfile)?;
let Ok(user) = user_admin::find_user(id).await else {
return Err(ErrorPage::NotFound(Some(request)));
};
@ -411,7 +437,6 @@ pub(crate) async fn email_post(
let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, EMAIL_PATH));
};
require_permission(&request, &UserPermission::EditOwnProfile)?;
let result = if throttle::allow(&request) {
auth::request_email_change(id, &form.current_password, &form.email).await
@ -510,11 +535,8 @@ async fn render_profile_page(
title: Lc,
form: impl Component + 'static,
) -> 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()

View file

@ -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 {

View file

@ -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<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();
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<Response, ErrorPage
.with_cell(permission.key().as_ref()),
);
}
content = content.with_child(
page = page.with_child(
Block::new()
.with_title(group_label.clone())
.with_child(table),
);
}
Ok(page
.with_title(title)
.with_child(content)
.render()
.await
.into_response())
Ok(page.render().await.into_response())
}

View file

@ -12,8 +12,8 @@ use crate::component::admin::{
};
use crate::config::SETTINGS;
use crate::entity::role;
use crate::handlers::admin::{back_link, frame, map_auth_error};
use crate::permission::{self, UserPermission};
use crate::handlers::admin::{back_link, map_auth_error};
use crate::permission::UserPermission;
use crate::role_path;
use crate::service::role_admin::{self, RolePageParams, RoleSortField};
@ -34,8 +34,6 @@ pub(crate) async fn list_get(
request: HttpRequest,
web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> {
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<Waypoint>,
) -> Result<Response, ErrorPage> {
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_child(
frame(title)
.with_title(title)
.with_child(
RoleForm::new()
.with_mode(RoleFormMode::New)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
)
.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<Waypoint>,
web::Form(form): web::Form<NewRoleFormData>,
) -> Result<Response, ErrorPage> {
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_title(title)
.with_child(form_component)
.with_child(back_link(back_href)),
)
.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<i32>,
web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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,14 +162,12 @@ 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_child(
frame(title)
.with_title(title)
.with_child(
RoleForm::new()
.with_mode(RoleFormMode::Edit)
@ -193,8 +178,7 @@ pub(crate) async fn edit_get(
.with_weight(role.weight)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
)
.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<Waypoint>,
web::Form(form): web::Form<EditRoleFormData>,
) -> Result<Response, ErrorPage> {
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_title(title)
.with_child(form_component)
.with_child(back_link(back_href)),
)
.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<i32>,
web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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<i32>,
web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> {
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<i32>,
web::Query(query): web::Query<RolesQuery>,
) -> Result<Response, ErrorPage> {
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<i32>,
web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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_child(
frame(title)
.with_title(title)
.with_child(
RolePermissionsForm::new()
.with_role_id(id)
.with_groups(groups)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
)
.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<Waypoint>,
raw: web::RawForm,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminRoles)?;
require_permission(&request, &UserPermission::AdminPermissions)?;
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 {
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_title(title)
.with_child(form_component)
.with_child(back_link(back_href)),
)
.with_child(back_link(back_href))
.render()
.await
.into_response())

View file

@ -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<UsersQuery>,
) -> Result<Response, ErrorPage> {
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_title(title)
.with_child(search_bar(query.q))
.with_child(table),
)
.with_child(table)
.render()
.await
.into_response())
@ -98,7 +93,7 @@ fn search_bar(current_query: Option<String>) -> 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<Waypoint>,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let roles = match available_roles(&[]).await {
Ok(roles) => roles,
Err(_) => return Err(ErrorPage::InternalError(Some(request))),
@ -163,13 +157,11 @@ 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::<Account>().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_child(
frame(title)
.with_title(title)
.with_child(
UserForm::new()
.with_mode(UserFormMode::New)
@ -177,8 +169,7 @@ pub(crate) async fn new_get(
.with_allow_admin_field(allow_admin_field)
.with_waypoint(waypoint),
)
.with_child(back_link(back_href)),
)
.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<Waypoint>,
raw: web::RawForm,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let Ok(form) = serde_qs::from_bytes::<NewUserFormData>(&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_title(title)
.with_child(form_component)
.with_child(back_link(back_href)),
)
.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())
.with_child(
frame(title)
page.with_title(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)),
)
.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<i32>,
web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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<Waypoint>,
raw: web::RawForm,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = require_manageable(&request, id).await?;
let Ok(form) = serde_qs::from_bytes::<EditUserFormData>(&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<i32>,
web::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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_title(title)
.with_child(details_block)
.with_child(roles_block)
.with_child(back_link(back_href)),
)
.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<Waypoint>,
web::Form(form): web::Form<StatusFormData>,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
require_permission(&request, &UserPermission::BlockAccounts)?;
require_manageable(&request, id).await?;
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::Query(waypoint): web::Query<Waypoint>,
) -> Result<Response, ErrorPage> {
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_child(
frame(title)
.with_title(title)
.with_child(user_summary(&user))
.with_child(
AdminPasswordForm::new()
.with_user_id(id)
.with_waypoint(waypoint),
)
.with_child(back_link(edit_href)),
)
.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<Waypoint>,
web::Form(form): web::Form<AdminPasswordFormData>,
) -> Result<Response, ErrorPage> {
require_permission(&request, &UserPermission::AdminUsers)?;
let user = require_manageable(&request, id).await?;
let result = match password::passwords_match(&form.password, &form.confirm_password) {
@ -783,13 +754,11 @@ 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_child(
frame(title)
.with_title(title)
.with_child(user_summary(&user))
.with_child(
AdminPasswordForm::new()
@ -797,8 +766,7 @@ pub(crate) async fn password_post(
.with_error(map_auth_error(&err))
.with_waypoint(waypoint),
)
.with_child(back_link(edit_href)),
)
.with_child(back_link(edit_href))
.render()
.await
.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
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<Markup, ErrorPage> {
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<String> = 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<String> = 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<ExtensionRef> {
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<ActionBox> {
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))
}
}

View file

@ -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,

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
//! 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<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 propios de `pagetop-user`.

View file

@ -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()));

View file

@ -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"
);
}