//! Handlers de administración de usuarios. use serde::Deserialize; use pagetop::prelude::*; use pagetop_htmx::prelude::*; use crate::ADMIN_USERS_PATH; use crate::LOCALES_USER; use crate::account::{Account, UserStatus}; use crate::component::admin::{ AdminPasswordForm, USER_ADMIN_FORM_ID, UserForm, UserFormMode, UserTable, }; use crate::component::{cancel_link, user_details}; use crate::config::SETTINGS; use crate::entity::{role, user}; use crate::error::AuthError; use crate::handlers::admin::{back_link, map_auth_error}; use crate::mail::{Notice, send_notice}; use crate::password; use crate::permission::UserPermission; use crate::role_path; use crate::service::role_admin; use crate::service::user_admin::{self, UserListParams, UserSortField}; use crate::user_path; #[derive(Deserialize)] pub(crate) struct UsersQuery { #[serde(default)] q: Option, #[serde(default)] sort: Option, #[serde(default)] dir: Option, #[serde(default)] page: Option, } // **< list_get >*********************************************************************************** /// GET /admin/user/users - Listado de usuarios (búsqueda, orden y paginación vía HTMX). pub(crate) async fn list_get( request: HttpRequest, web::Query(query): web::Query, ) -> Result { let params = UserListParams { query: query.q.clone(), sort: UserSortField::from_query(query.sort.as_deref()), dir: SortDir::from_query(query.dir.as_deref()), page: query.page.unwrap_or(1).max(1), per_page: SETTINGS.admin.list_page_size, }; let result = match user_admin::list_users(¶ms).await { Ok(result) => result, Err(_) => return Err(ErrorPage::InternalError(request)), }; let mut table = UserTable::new() .with_items(result.items) .with_sort(params.sort) .with_dir(params.dir) .with_query(query.q.clone()) .with_page(result.page) .with_per_page(result.per_page) .with_total(result.total); if request.is_htmx() { let mut cx = Context::admin(request); Ok(HtmxResponse::new(table.render(&mut cx).await).into_response()) } else { let title = Lc::t("title-admin-users", &LOCALES_USER); let page = Page::admin(request); let search = search_bar(page.route(ADMIN_USERS_PATH.as_str()), query.q); Ok(page .with_title(title) .with_child(search) .with_child(table) .render() .await .into_response()) } } // **< search_bar >********************************************************************************* // Los atributos HTMX van en el formulario porque `with_prop()` de un campo los pondría en su // contenedor, que no enviaría el valor. `input` cubre también vaciar con la "x" del navegador. fn search_bar(route: RoutePath, current_query: Option) -> Form { Form::new() .with_action(route.clone()) .with_method(form::Method::Get) .with_prop(PropsOp::set(hx::GET, route.to_string())) .with_prop(PropsOp::set(hx::TRIGGER, "input delay:400ms, submit")) .with_prop(PropsOp::set(hx::TARGET, "#user-table-wrapper")) .with_prop(PropsOp::set(hx::SWAP, hx::swap::OUTER_HTML_SCROLL_TOP)) .with_prop(PropsOp::set(hx::PUSH_URL, "true")) .with_child( form::input::Field::search() .with_id("user-admin-search") .with_name("q") .with_value(current_query.unwrap_or_default()) .with_placeholder(Lc::t("field-search-users", &LOCALES_USER)), ) } // **< available_roles >**************************************************************************** // Roles asignables desde la UI de usuarios: todos salvo los de sistema, que nunca se asignan. async fn available_roles(selected: &[i32]) -> Result, AuthError> { let items = role_admin::list_roles(&role_admin::RoleListParams { sort: role_admin::RoleSortField::Weight, dir: SortDir::Asc, }) .await?; Ok(items .into_iter() .filter(|r| !crate::is_system_role(r.id)) .map(|r| { let checked = selected.contains(&r.id); (r.id, r.label, checked) }) .collect()) } // Identificadores de rol enviados en el formulario de alta o edición. fn parse_role_ids(role_ids: &[String]) -> Vec { role_ids.iter().filter_map(|s| s.parse().ok()).collect() } // **< require_manageable >************************************************************************* // Carga el usuario y comprueba que quien hace la petición puede gestionarlo. La cuenta de un // administrador sólo la gestiona otro administrador: si no, quien administra usuarios podría // apoderarse de ella (p. ej. restableciendo su contraseña) y obtener acceso irrestricto, que sólo // un administrador puede conceder. async fn require_manageable(request: &HttpRequest, id: i32) -> Result { let Ok(user) = user_admin::find_user(id).await else { return Err(ErrorPage::NotFound(request.clone())); }; if user.is_admin && !request.extension::().is_some_and(|a| a.is_admin()) { return Err(ErrorPage::AccessDenied(request.clone())); } Ok(user) } // **< new_get / new_post >************************************************************************* /// GET /admin/user/users/new - Formulario de alta de usuario. pub(crate) async fn new_get( request: HttpRequest, web::Query(waypoint): web::Query, ) -> Result { let roles = match available_roles(&[]).await { Ok(roles) => roles, Err(_) => return Err(ErrorPage::InternalError(request)), }; // El campo "administrador" sólo se ofrece si quien da de alta ya es administrador: no es un // permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`). let allow_admin_field = request.extension::().is_some_and(|a| a.is_admin()); let page = Page::admin(request); let title = Lc::t("title-admin-user-new", &LOCALES_USER); Ok(page .with_title(title) .with_child( UserForm::new() .with_mode(UserFormMode::New) .with_roles(roles) .with_allow_admin_field(allow_admin_field) .with_waypoint(waypoint), ) .render() .await .into_response()) } #[derive(Deserialize)] pub(crate) struct NewUserFormData { username: String, email: String, password: String, confirm_password: String, #[serde(default)] display_name: String, #[serde(default)] language: String, #[serde(default)] timezone: String, #[serde(default)] theme: String, #[serde(default)] role_ids: Vec, #[serde(default)] is_admin: bool, } /// POST /admin/user/users/new - Crea un usuario. /// /// Usa `web::RawForm` + `serde_qs` en lugar de `web::Form` (basado en `serde_urlencoded`, que no /// deserializa claves repetidas como `role_ids=2&role_ids=3` en un `Vec`). pub(crate) async fn new_post( request: HttpRequest, web::Query(waypoint): web::Query, raw: web::RawForm, ) -> Result { let Ok(form) = serde_qs::from_bytes::(&raw.0) else { return Err(ErrorPage::BadRequest(request)); }; let allow_admin_field = request.extension::().is_some_and(|a| a.is_admin()); // Nunca fiarse sólo de que el campo esté presente en el formulario: sólo se concede si quien // envía la petición ya es administrador, aunque alguien manipulase la petición a mano. let is_admin = form.is_admin && allow_admin_field; let role_ids = parse_role_ids(&form.role_ids); let result = user_admin::create_user(user_admin::NewUserData { username: &form.username, email: &form.email, password: &form.password, confirm_password: &form.confirm_password, display_name: util::non_blank(&form.display_name), language: util::non_blank(&form.language), timezone: util::non_blank(&form.timezone), theme: util::non_blank(&form.theme), initial_role_ids: &role_ids, is_admin, }) .await; match result { Ok(_) => { let cx = Context::admin(request); 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 page = Page::admin(request); let form_component = UserForm::new() .with_mode(UserFormMode::New) .with_username(form.username) .with_email(form.email) .with_display_name(form.display_name) .with_language(form.language) .with_timezone(form.timezone) .with_theme(form.theme) .with_roles(roles) .with_allow_admin_field(allow_admin_field) .with_is_admin(is_admin) .with_error(map_auth_error(&err)) .with_waypoint(waypoint); let title = Lc::t("title-admin-user-new", &LOCALES_USER); Ok(page .with_title(title) .with_child(form_component) .render() .await .into_response()) } } } // **< edit_get / edit_post >*********************************************************************** // Pantalla de edición con el formulario relleno con los datos guardados del usuario. async fn render_user_edit( request: HttpRequest, id: i32, error: Option, waypoint: Waypoint, ) -> Response { let user = match user_admin::find_user(id).await { Ok(user) => user, Err(_) => return ErrorPage::NotFound(request).into_response(), }; let current = match user_admin::user_role_ids(id).await { Ok(ids) => ids, Err(_) => return ErrorPage::InternalError(request).into_response(), }; let roles = match available_roles(¤t).await { Ok(roles) => roles, Err(_) => return ErrorPage::InternalError(request).into_response(), }; let status = UserStatus::from_i16(user.status); let is_admin = user.is_admin; let form = UserForm::new() .with_username(user.username) .with_email(user.email) .with_display_name(user.display_name.unwrap_or_default()) .with_about(user.about.unwrap_or_default()) .with_language(user.language.unwrap_or_default()) .with_timezone(user.timezone.unwrap_or_default()) .with_theme(user.theme.unwrap_or_default()) .with_roles(roles) .with_error(error); render_edit_page(request, id, status, is_admin, form, waypoint).await } // Pantalla de edición del usuario `id` con `form` ya relleno, sea con los datos guardados o con los // enviados que no se pudieron guardar. Siempre lleva la botonera de `edit_actions()`, porque en // modo `Edit` el botón "Guardar" está en ella y no dentro del formulario. async fn render_edit_page( request: HttpRequest, id: i32, status: UserStatus, is_admin: bool, form: UserForm, waypoint: Waypoint, ) -> Response { // El botón de conceder/revocar sólo se muestra si quien lo ve ya es administrador y no está // viendo su propio perfil: no es un permiso del catálogo, y nadie puede automodificarse el flag // (ver `set_user_admin`). let can_toggle_admin = request .extension::() .is_some_and(|a| a.is_admin() && a.id() != id); // 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 title = Lc::t("title-admin-user-edit", &LOCALES_USER); let actions = edit_actions( id, status, is_admin, can_toggle_admin, can_change_status, &waypoint, page.context_mut(), ); page.with_title(title) .with_child( form.with_mode(UserFormMode::Edit) .with_user_id(Some(id)) .with_waypoint(waypoint.clone()), ) .with_child(actions) .render() .await .into_response() } // Botonera de la edición: "Guardar", "Cancelar", el enlace a la pantalla de restablecer contraseña // y los botones de bloqueo/activación (sólo si `can_change_status`) y de concesión/revocación de // acceso irrestricto (sólo si `can_toggle_admin`). El listado de origen (`waypoint`) se arrastra a // todas ellas para que, al volver aquí, esta misma pantalla siga sabiendo devolver al listado en el // estado en que se dejó. // // "Guardar" (envía el `
` de `UserForm` vía el atributo `form`, ver `USER_ADMIN_FORM_ID`), // "Cancelar" y "Restablecer contraseña" son botones sueltos; bloqueo/activación y // concesión/revocación de admin van cada uno en su propio `Form`, con un campo `Hidden` para el // nuevo valor, para conservar el envío nativo sin JavaScript, mejorado con `hx-post`/`hx-confirm`. // Todos son hijos directos del mismo `Flex`, que los alinea en fila con espaciado uniforme. fn edit_actions( user_id: i32, status: UserStatus, target_is_admin: bool, can_toggle_admin: bool, can_change_status: bool, waypoint: &Waypoint, cx: &mut Context, ) -> Flex { // Una cuenta pendiente de verificar su email también se puede activar directamente, p. ej. si // el correo de verificación no llegó. let (next_status, label_key) = match status { UserStatus::Active => ("blocked", "btn-block"), UserStatus::Blocked | UserStatus::Pending => ("active", "btn-activate"), }; let (next_is_admin, admin_label_key, admin_confirm_key) = if target_is_admin { ("false", "btn-revoke-admin", "confirm-revoke-admin") } else { ("true", "btn-grant-admin", "confirm-grant-admin") }; let password_href = waypoint.append_to(cx.route(user_path(user_id, "password"))); let status_action = waypoint.append_to(cx.route(user_path(user_id, "status"))); let admin_action = waypoint.append_to(cx.route(user_path(user_id, "admin"))); let mut status_form = Form::new() .with_action(status_action.clone()) .with_method(form::Method::Post) .with_prop(PropsOp::set(hx::POST, status_action.to_string())) .with_child(form::Hidden::field("status", next_status)) .with_child( Button::submit(Lc::t(label_key, &LOCALES_USER)) .with_style(button::Style::Solid(Intent::Warning)), ); if let Some(confirm) = Lc::t("confirm-change-status", &LOCALES_USER).lookup(cx) { status_form = status_form.with_prop(PropsOp::set(hx::CONFIRM, confirm)); } let mut container = Flex::new() .with_wrap(flex::Behavior::Wrap) .with_align(align::Items::Center) .with_gap(align::Gap::Both(UnitValue::RelRem(0.5))) .with_child( Button::submit(Lc::t("btn-save", &LOCALES_USER)) .with_style(button::Style::Solid(Intent::Primary)) .with_prop(PropsOp::set("form", USER_ADMIN_FORM_ID)), ) .with_child(cancel_link( waypoint.or(cx.route(ADMIN_USERS_PATH.as_str())), )) .with_child( Button::anchor(Lc::t("btn-reset-password", &LOCALES_USER), password_href) .with_style(button::Style::Solid(Intent::Neutral)), ); if can_change_status { container = container.with_child(status_form); } if can_toggle_admin { let admin_button = Button::submit(Lc::t(admin_label_key, &LOCALES_USER)) .with_style(button::Style::Solid(Intent::Severe)); let mut admin_form = Form::new() .with_action(admin_action.clone()) .with_method(form::Method::Post) .with_prop(PropsOp::set(hx::POST, admin_action.to_string())) .with_child(form::Hidden::field("is_admin", next_is_admin)) .with_child(admin_button); if let Some(confirm) = Lc::t(admin_confirm_key, &LOCALES_USER).lookup(cx) { admin_form = admin_form.with_prop(PropsOp::set(hx::CONFIRM, confirm)); } container = container.with_child(admin_form); } container } /// GET /admin/user/users/{id}/edit - Formulario de edición de usuario. pub(crate) async fn edit_get( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { require_manageable(&request, id).await?; Ok(render_user_edit(request, id, None, waypoint).await) } #[derive(Deserialize)] pub(crate) struct EditUserFormData { username: String, email: String, #[serde(default)] display_name: String, #[serde(default)] about: String, #[serde(default)] language: String, #[serde(default)] timezone: String, #[serde(default)] theme: String, #[serde(default)] role_ids: Vec, } /// POST /admin/user/users/{id}/edit - Actualiza los datos de perfil y los roles de un usuario. /// /// Usa `RawForm` + `serde_qs` por los roles, igual que `new_post`. pub(crate) async fn edit_post( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, raw: web::RawForm, ) -> Result { let user = require_manageable(&request, id).await?; let Ok(form) = serde_qs::from_bytes::(&raw.0) else { return Err(ErrorPage::BadRequest(request)); }; let role_ids = parse_role_ids(&form.role_ids); let mut result = user_admin::update_user( id, user_admin::UserUpdateData { username: &form.username, email: &form.email, display_name: util::non_blank(&form.display_name), about: util::non_blank(&form.about), language: util::non_blank(&form.language), timezone: util::non_blank(&form.timezone), theme: util::non_blank(&form.theme), }, ) .await; if result.is_ok() { result = user_admin::set_user_roles(id, &role_ids).await; } match result { Ok(()) => { let cx = Context::admin(request); 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 status = UserStatus::from_i16(user.status); let form = UserForm::new() .with_username(form.username) .with_email(form.email) .with_display_name(form.display_name) .with_about(form.about) .with_language(form.language) .with_timezone(form.timezone) .with_theme(form.theme) .with_roles(roles) .with_error(map_auth_error(&err)); Ok(render_edit_page(request, id, status, user.is_admin, form, waypoint).await) } } } // **< view_get >*********************************************************************************** /// GET /admin/user/users/{id}/view - Pantalla de sólo lectura con todos los datos del usuario, /// incluidos los roles asignados. pub(crate) async fn view_get( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { let user = match user_admin::find_user(id).await { Ok(user) => user, Err(_) => return Err(ErrorPage::NotFound(request)), }; let roles = match user_admin::user_roles(id).await { Ok(roles) => roles, Err(_) => return Err(ErrorPage::InternalError(request)), }; let mut page = Page::admin(request); 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) .with_child(details_block) .with_child(roles_block) .with_child(back_link(back_href)) .render() .await .into_response()) } // Bloque de sólo lectura con los roles asignados al usuario, cada uno enlazado a su propia // pantalla de vista. async fn user_view_roles(roles: &[role::Model], is_admin: bool, cx: &mut Context) -> Block { // Un bloque sin hijos no se renderiza. if roles.is_empty() { return Block::new(); } let mut table = Table::new().with_prop(PropsOp::add_classes("user-admin-table")); for r in roles { let system_badge = if r.locked { Some( Badge::warning(Lc::t("badge-system-role", &LOCALES_USER)) .render(cx) .await, ) } else { None }; let (id, label) = (r.id, crate::role_label(r.id, &r.label)); table = table.with_row( table::Row::new() .with_cell(Html::with(move |cx| { html! { a href=(cx.route(role_path(id, "view"))) { (label.using(cx)) } } })) .with_cell(r.machine_name.as_str()) .with_cell(Html::with(move |_| { html! { @if let Some(badge) = &system_badge { (badge) } } })), ); } let mut block = Block::new() .with_title(Lc::t("field-roles", &LOCALES_USER)) .with_child(table); if is_admin { block = block.with_child(Html::with(|cx| { html! { p { (Lc::t("help-admin-roles", &LOCALES_USER).using(cx)) } } })); } block } // Cabecera con los datos básicos del usuario en la pantalla de restablecimiento de contraseña, que // de otro modo no lo identifica. fn user_summary(user: &user::Model) -> Table { Table::new() .with_prop(PropsOp::add_classes("user-admin-table")) .with_row( table::Row::new() .with_cell(Lc::t("field-username-admin", &LOCALES_USER)) .with_cell(user.username.as_str()), ) .with_row( table::Row::new() .with_cell(Lc::t("field-display-name", &LOCALES_USER)) .with_cell(user.display_name.as_deref().unwrap_or("-")), ) } // **< status_post >******************************************************************************** #[derive(Deserialize)] pub(crate) struct StatusFormData { status: String, } /// POST /admin/user/users/{id}/status - Bloquea o activa una cuenta. pub(crate) async fn status_post( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { require_permission(&request, &UserPermission::BlockAccounts)?; require_manageable(&request, id).await?; let Some(account) = request.extension::().cloned() else { return Err(ErrorPage::AccessDenied(request)); }; let new_status = match form.status.as_str() { "blocked" => UserStatus::Blocked, _ => UserStatus::Active, }; // Ver comentario equivalente en `admin_post`: el botón envía la petición vía `hx-post` (para el // diálogo `hx-confirm`) sin `hx-target`, así que un `Redirect` normal terminaría anidado dentro // del propio ``. `HtmxResponse::redirect()` fuerza una navegación real en el cliente. let is_htmx = request.is_htmx(); match user_admin::set_user_status(id, new_status, account.id()).await { Ok(()) => { let cx = Context::admin(request); let edit_href = waypoint.append_to(cx.route(user_path(id, "edit"))); if is_htmx { Ok(HtmxResponse::empty().redirect(edit_href).into_response()) } else { Ok(Redirect::see_other(edit_href).into_response()) } } Err(err) => Ok(render_user_edit(request, id, Some(map_auth_error(&err)), waypoint).await), } } // **< admin_post >********************************************************************************* #[derive(Deserialize)] pub(crate) struct AdminFormData { is_admin: String, } /// POST /admin/user/users/{id}/admin - Concede o revoca el acceso irrestricto (`is_admin`). /// /// No pasa por `require_permission`: conceder o revocar este flag no es un permiso del catálogo, /// se comprueba directamente contra `account.is_admin()` para que sólo un administrador pueda /// tocarlo (un permiso concedido vía rol nunca basta). pub(crate) async fn admin_post( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { let Some(account) = request.extension::().cloned() else { return Err(ErrorPage::AccessDenied(request)); }; if !account.is_admin() { return Err(ErrorPage::AccessDenied(request)); } let new_is_admin = form.is_admin == "true"; // El botón envía la petición vía `hx-post` (para el diálogo `hx-confirm`), sin `hx-target`: si // se responde con un `Redirect` normal, HTMX sigue la redirección con `fetch` y sustituye el // propio `` (destino por defecto sin `hx-target`) por la página completa que devuelve, // anidándola dentro de sí misma. `HtmxResponse::redirect()` evita eso: instruye al cliente // (cabecera `HX-Redirect`) para que navegue de verdad a la URL, en vez de intentar un `swap`. let is_htmx = request.is_htmx(); match user_admin::set_user_admin(id, new_is_admin, account.id()).await { Ok(()) => { let cx = Context::admin(request); let edit_href = waypoint.append_to(cx.route(user_path(id, "edit"))); if is_htmx { Ok(HtmxResponse::empty().redirect(edit_href).into_response()) } else { Ok(Redirect::see_other(edit_href).into_response()) } } Err(err) => Ok(render_user_edit(request, id, Some(map_auth_error(&err)), waypoint).await), } } // **< password_get / password_post >*************************************************************** /// GET /admin/user/users/{id}/password - Formulario de restablecimiento de contraseña por un /// administrador. pub(crate) async fn password_get( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, ) -> Result { let user = require_manageable(&request, id).await?; let page = Page::admin(request); let title = Lc::t("title-admin-user-password", &LOCALES_USER); Ok(page .with_title(title) .with_child(user_summary(&user)) .with_child( AdminPasswordForm::new() .with_user_id(id) .with_waypoint(waypoint), ) .render() .await .into_response()) } #[derive(Deserialize)] pub(crate) struct AdminPasswordFormData { password: String, confirm_password: String, } /// POST /admin/user/users/{id}/password - Aplica la nueva contraseña, invalida las sesiones /// activas del usuario y le avisa del cambio por correo. pub(crate) async fn password_post( request: HttpRequest, web::Path(id): web::Path, web::Query(waypoint): web::Query, web::Form(form): web::Form, ) -> Result { let user = require_manageable(&request, id).await?; let result = match password::passwords_match(&form.password, &form.confirm_password) { Ok(()) => user_admin::admin_reset_password(id, &form.password).await, Err(err) => Err(err), }; match result { Ok(user) => { send_notice(&request, Notice::PasswordChangedByAdmin, &user); let cx = Context::admin(request); let edit_href = waypoint.append_to(cx.route(user_path(id, "edit"))); Ok(Redirect::see_other(edit_href).into_response()) } Err(err) => { let page = Page::admin(request); let title = Lc::t("title-admin-user-password", &LOCALES_USER); Ok(page .with_title(title) .with_child(user_summary(&user)) .with_child( AdminPasswordForm::new() .with_user_id(id) .with_error(map_auth_error(&err)) .with_waypoint(waypoint), ) .render() .await .into_response()) } } }