♻️ (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:
parent
824dc4a3ab
commit
9ba493c2c4
19 changed files with 343 additions and 501 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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_title(title)
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(
|
||||
RoleForm::new()
|
||||
.with_mode(RoleFormMode::New)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href)),
|
||||
RoleForm::new()
|
||||
.with_mode(RoleFormMode::New)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -113,8 +107,6 @@ pub(crate) async fn new_post(
|
|||
web::Query(waypoint): web::Query<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_child(form_component)
|
||||
.with_child(back_link(back_href)),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(form_component)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -165,8 +154,6 @@ pub(crate) async fn edit_get(
|
|||
web::Path(id): web::Path<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,26 +162,23 @@ pub(crate) async fn edit_get(
|
|||
return Err(ErrorPage::AccessDenied(Some(request)));
|
||||
}
|
||||
|
||||
let mut page = Page::admin(request);
|
||||
let back_href = waypoint.or(page.context().route(ADMIN_ROLES_PATH));
|
||||
let page = Page::admin(request);
|
||||
let back_href = waypoint.or(page.route(ADMIN_ROLES_PATH.as_str()));
|
||||
|
||||
let title = Lc::t("title-admin-role-edit", &LOCALES_USER);
|
||||
Ok(page
|
||||
.with_title(title.clone())
|
||||
.with_title(title)
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(
|
||||
RoleForm::new()
|
||||
.with_mode(RoleFormMode::Edit)
|
||||
.with_role_id(Some(id))
|
||||
.with_machine_name(role.machine_name)
|
||||
.with_label(role.label)
|
||||
.with_description(role.description.unwrap_or_default())
|
||||
.with_weight(role.weight)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href)),
|
||||
RoleForm::new()
|
||||
.with_mode(RoleFormMode::Edit)
|
||||
.with_role_id(Some(id))
|
||||
.with_machine_name(role.machine_name)
|
||||
.with_label(role.label)
|
||||
.with_description(role.description.unwrap_or_default())
|
||||
.with_weight(role.weight)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -216,8 +200,6 @@ pub(crate) async fn edit_post(
|
|||
web::Query(waypoint): web::Query<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_child(form_component)
|
||||
.with_child(back_link(back_href)),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(form_component)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -276,8 +255,6 @@ pub(crate) async fn view_get(
|
|||
web::Path(id): web::Path<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_title(title)
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(
|
||||
RolePermissionsForm::new()
|
||||
.with_role_id(id)
|
||||
.with_groups(groups)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href)),
|
||||
RolePermissionsForm::new()
|
||||
.with_role_id(id)
|
||||
.with_groups(groups)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -547,7 +514,6 @@ pub(crate) async fn permissions_post(
|
|||
web::Query(waypoint): web::Query<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_child(form_component)
|
||||
.with_child(back_link(back_href)),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(form_component)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
|
|||
|
|
@ -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_child(search_bar(query.q))
|
||||
.with_child(table),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(search_bar(query.q))
|
||||
.with_child(table)
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -98,7 +93,7 @@ fn search_bar(current_query: Option<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,22 +157,19 @@ pub(crate) async fn new_get(
|
|||
// El campo "administrador" sólo se ofrece si quien da de alta ya es administrador: no es un
|
||||
// permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`).
|
||||
let allow_admin_field = request.extension::<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_title(title)
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(
|
||||
UserForm::new()
|
||||
.with_mode(UserFormMode::New)
|
||||
.with_roles(roles)
|
||||
.with_allow_admin_field(allow_admin_field)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href)),
|
||||
UserForm::new()
|
||||
.with_mode(UserFormMode::New)
|
||||
.with_roles(roles)
|
||||
.with_allow_admin_field(allow_admin_field)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -213,7 +204,6 @@ pub(crate) async fn new_post(
|
|||
web::Query(waypoint): web::Query<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_child(form_component)
|
||||
.with_child(back_link(back_href)),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(form_component)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -331,7 +318,7 @@ async fn render_edit_page(
|
|||
// Bloquear y activar exige además `user:block_accounts` (ver `status_post`).
|
||||
let can_change_status = has_permission(&request, &UserPermission::BlockAccounts);
|
||||
let mut page = Page::admin(request);
|
||||
let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH));
|
||||
let back_href = waypoint.or(page.route(ADMIN_USERS_PATH.as_str()));
|
||||
let title = Lc::t("title-admin-user-edit", &LOCALES_USER);
|
||||
let actions = edit_actions(
|
||||
id,
|
||||
|
|
@ -340,20 +327,17 @@ async fn render_edit_page(
|
|||
can_toggle_admin,
|
||||
can_change_status,
|
||||
&waypoint,
|
||||
page.context(),
|
||||
page.context_mut(),
|
||||
);
|
||||
|
||||
page.with_title(title.clone())
|
||||
page.with_title(title)
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(
|
||||
form.with_mode(UserFormMode::Edit)
|
||||
.with_user_id(Some(id))
|
||||
.with_waypoint(waypoint.clone()),
|
||||
)
|
||||
.with_child(actions)
|
||||
.with_child(back_link(back_href)),
|
||||
form.with_mode(UserFormMode::Edit)
|
||||
.with_user_id(Some(id))
|
||||
.with_waypoint(waypoint.clone()),
|
||||
)
|
||||
.with_child(actions)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response()
|
||||
|
|
@ -451,7 +435,6 @@ pub(crate) async fn edit_get(
|
|||
web::Path(id): web::Path<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_child(details_block)
|
||||
.with_child(roles_block)
|
||||
.with_child(back_link(back_href)),
|
||||
)
|
||||
.with_title(title)
|
||||
.with_child(details_block)
|
||||
.with_child(roles_block)
|
||||
.with_child(back_link(back_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -645,7 +622,6 @@ pub(crate) async fn status_post(
|
|||
web::Query(waypoint): web::Query<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_title(title)
|
||||
.with_child(user_summary(&user))
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(user_summary(&user))
|
||||
.with_child(
|
||||
AdminPasswordForm::new()
|
||||
.with_user_id(id)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(edit_href)),
|
||||
AdminPasswordForm::new()
|
||||
.with_user_id(id)
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(edit_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
@ -767,7 +739,6 @@ pub(crate) async fn password_post(
|
|||
web::Query(waypoint): web::Query<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,22 +754,19 @@ pub(crate) async fn password_post(
|
|||
Ok(Redirect::see_other(edit_href).into_response())
|
||||
}
|
||||
Err(err) => {
|
||||
let mut page = Page::admin(request);
|
||||
let edit_href = waypoint.append_to(page.context().route(user_path(id, "edit")));
|
||||
let page = Page::admin(request);
|
||||
let edit_href = waypoint.append_to(page.route(user_path(id, "edit")));
|
||||
let title = Lc::t("title-admin-user-password", &LOCALES_USER);
|
||||
Ok(page
|
||||
.with_title(title.clone())
|
||||
.with_title(title)
|
||||
.with_child(user_summary(&user))
|
||||
.with_child(
|
||||
frame(title)
|
||||
.with_child(user_summary(&user))
|
||||
.with_child(
|
||||
AdminPasswordForm::new()
|
||||
.with_user_id(id)
|
||||
.with_error(map_auth_error(&err))
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(edit_href)),
|
||||
AdminPasswordForm::new()
|
||||
.with_user_id(id)
|
||||
.with_error(map_auth_error(&err))
|
||||
.with_waypoint(waypoint),
|
||||
)
|
||||
.with_child(back_link(edit_href))
|
||||
.render()
|
||||
.await
|
||||
.into_response())
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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`.
|
||||
|
|
|
|||
|
|
@ -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()));
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue