🐛 (user): Corrige altas simultáneas y roles sistema

This commit is contained in:
Manuel Cillero 2026-11-02 19:02:04 +01:00
parent 574010374d
commit 9afbafdefb
12 changed files with 134 additions and 63 deletions

View file

@ -31,7 +31,13 @@
//! modelo leído: `model.into_active_model()`).
//! - **Macros de derivación**: [`DeriveEntityModel`], [`DeriveColumn`], [`DerivePrimaryKey`],
//! [`DeriveRelation`], [`EnumIter`].
//! - **Errores**: [`DbErr`], [`TransactionError`].
//! - **Errores**: [`DbErr`], [`TransactionError`], [`SqlErr`] (para reconocer con
//! [`DbErr::sql_err()`] la violación de una restricción única o de clave ajena).
//! - **Fechas**: [`DateTime`] es el de PageTop ([`pagetop::datetime::DateTime`]), no el alias de
//! `NaiveDateTime` que exporta SeaORM con ese nombre, para que `db::*` y el preludio de PageTop
//! puedan importarse juntos. Para las columnas de fecha y hora de una entidad se usa
//! [`DateTimeUtc`] o [`DateTimeWithTimeZone`] (con zona horaria) o
//! [`pagetop::datetime::NaiveDateTime`] (sin ella).
//! - **Resultados**: [`QueryResult`] (filas sin tipar), [`ExecResult`] (INSERT/UPDATE/DELETE),
//! [`Paginated`] (página de resultados).
//!
@ -153,6 +159,11 @@
pub use sea_orm::prelude::*;
// Sustituye al `DateTime` del prelude de SeaORM (alias de `NaiveDateTime`): al ser el mismo
// elemento que el del preludio de PageTop, el nombre no es ambiguo al importar ambos con `*`.
#[doc(no_inline)]
pub use pagetop::datetime::DateTime;
// Re-exporta el crate `sea_orm` íntegro como puerta de acceso a su API completa.
//
// Útil para tipos o utilidades que no están expuestos directamente en `db::*`; la inmensa mayoría
@ -169,7 +180,7 @@ pub use sea_orm;
pub use sea_orm::{
ActiveValue, Condition, DatabaseTransaction, DbBackend, ExecResult, IntoActiveModel, NotSet,
Order, QueryOrder, QuerySelect, Set, TransactionError, TransactionTrait, Unchanged,
Order, QueryOrder, QuerySelect, Set, SqlErr, TransactionError, TransactionTrait, Unchanged,
};
/// Re-exporta `sea_query` para construir sentencias SQL en tiempo de ejecución.

View file

@ -2,10 +2,7 @@
//! inicial.
use pagetop::prelude::*;
use pagetop_seaorm::db::{
ActiveModelTrait, ActiveValue, ColumnTrait, EntityTrait, IntoActiveModel, PaginatorTrait,
QueryFilter, Set, dbconn,
};
use pagetop_seaorm::db::*;
use crate::account::UserStatus;
use crate::config::SETTINGS;
@ -14,7 +11,9 @@ use crate::error::AuthError;
use crate::identity::{self, Email, Username};
use crate::password;
use crate::permission::UserPermission;
use crate::service::user_admin::{ensure_email_available, ensure_username_available};
use crate::service::user_admin::{
ensure_email_available, ensure_username_available, taken_on_conflict,
};
use crate::session;
use crate::token::{self, TokenKind};
@ -147,10 +146,10 @@ pub async fn register(
};
username.set_on(&mut new_user);
email.set_on(&mut new_user);
let result = user::Entity::insert(new_user).exec(dbconn()).await?;
let user_id = result.last_insert_id;
Ok(user_id)
match user::Entity::insert(new_user).exec(dbconn()).await {
Ok(result) => Ok(result.last_insert_id),
Err(err) => Err(taken_on_conflict(err.into(), Some(&username), &email, None).await),
}
}
// **< change_own_password >************************************************************************
@ -291,7 +290,9 @@ pub(crate) async fn confirm_email_change(user_id: i32, plain_token: &str) -> Res
..Default::default()
};
email.set_on(&mut model);
model.update(dbconn()).await?;
if let Err(err) = model.update(dbconn()).await {
return Err(taken_on_conflict(err.into(), None, &email, Some(user_id)).await);
}
revoke_address_tokens(user_id).await
}

View file

@ -217,13 +217,13 @@ impl RoleTable {
// rol. Devuelve un componente `Html` para que el marcado se genere cuando `Table` renderice la
// celda, no al construir la fila.
fn label_cell(role: &RoleListItem, waypoint: &Waypoint) -> Html {
let label = role.label.clone();
let label = crate::role_label(role.id, &role.label);
let id = role.id;
let waypoint = waypoint.clone();
Html::with(move |cx| {
let view_href = waypoint.append_to(cx.route(role_path(id, "view")));
html! {
a href=(view_href) { (label.as_str()) }
a href=(view_href) { (label.using(cx)) }
}
})
}

View file

@ -2,10 +2,12 @@
//!
//! Sólo se compila con la feature `demo-data`. Se ejecuta una vez desde
//! `Extension::initialize()`, después de `auth::seed_initial_data()`. Si el rol
//! `demo_role_01` ya existe, la siembra se omite para no duplicar datos en reinicios.
//! `demo_role_01` ya existe, la siembra se omite para no duplicar datos en reinicios. Roles y
//! usuarios se crean en una sola transacción: si algo falla, no queda nada sembrado y se vuelve a
//! intentar en el siguiente arranque.
use pagetop::prelude::*;
use pagetop_seaorm::db::{ActiveValue, ColumnTrait, EntityTrait, QueryFilter, Set, dbconn};
use pagetop_seaorm::db::*;
use crate::account::UserStatus;
use crate::config::SETTINGS;
@ -31,30 +33,34 @@ pub(crate) async fn seed_demo_data() {
return;
}
let role_ids = match create_demo_roles().await {
Ok(ids) => ids,
let hash = match password::hash_password(DEMO_PASSWORD) {
Ok(hash) => hash,
Err(e) => {
eprintln!(
"pagetop-user demo-data error: failed to create roles: {}",
e
);
eprintln!("pagetop-user demo-data error: failed to hash password: {e}");
return;
}
};
match create_demo_users(&role_ids).await {
let result = dbconn()
.transaction::<_, _, AuthError>(|txn| {
Box::pin(async move {
let role_ids = create_demo_roles(txn).await?;
create_demo_users(txn, &role_ids, &hash).await
})
})
.await
.map_err(flatten_txn_err);
match result {
Ok(()) => println!(
"\npagetop-user: demo data created ({ROLE_COUNT} roles, {USER_COUNT} users).\n \
password: {DEMO_PASSWORD}\n"
),
Err(e) => eprintln!(
"pagetop-user demo-data error: failed to create users: {}",
e
),
Err(e) => eprintln!("pagetop-user demo-data error: failed to create demo data: {e}"),
}
}
async fn create_demo_roles() -> Result<Vec<i32>, AuthError> {
async fn create_demo_roles(txn: &DatabaseTransaction) -> Result<Vec<i32>, AuthError> {
let now = Utc::now();
let mut role_ids = Vec::with_capacity(ROLE_COUNT);
for n in 1..=ROLE_COUNT {
@ -71,14 +77,17 @@ async fn create_demo_roles() -> Result<Vec<i32>, AuthError> {
created_at: Set(now),
updated_at: Set(now),
};
let result = role::Entity::insert(new_role).exec(dbconn()).await?;
let result = role::Entity::insert(new_role).exec(txn).await?;
role_ids.push(result.last_insert_id);
}
Ok(role_ids)
}
async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> {
let hash = password::hash_password(DEMO_PASSWORD)?;
async fn create_demo_users(
txn: &DatabaseTransaction,
role_ids: &[i32],
hash: &str,
) -> Result<(), AuthError> {
let now = Utc::now();
for n in 1..=USER_COUNT {
@ -88,7 +97,7 @@ async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> {
let mut new_user = user::ActiveModel {
id: ActiveValue::NotSet,
email_verified_at: Set(Some(now)),
password_hash: Set(hash.clone()),
password_hash: Set(hash.to_owned()),
status: Set(UserStatus::Active.as_i16()),
language: Set(None),
timezone: Set(None),
@ -106,7 +115,7 @@ async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> {
};
username.set_on(&mut new_user);
email.set_on(&mut new_user);
let result = user::Entity::insert(new_user).exec(dbconn()).await?;
let result = user::Entity::insert(new_user).exec(txn).await?;
let user_id = result.last_insert_id;
// Reparte los usuarios de forma cíclica entre los roles de demostración.
@ -114,7 +123,7 @@ async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> {
user_id: Set(user_id),
role_id: Set(role_ids[(n - 1) % role_ids.len()]),
})
.exec_without_returning(dbconn())
.exec_without_returning(txn)
.await?;
}
Ok(())

View file

@ -117,7 +117,7 @@ async fn profile_roles(roles: &[role::Model], cx: &mut Context) -> Block {
return Block::new();
}
let mut items: Vec<(String, Option<Markup>)> = Vec::with_capacity(roles.len());
let mut items: Vec<(Lc, Option<Markup>)> = Vec::with_capacity(roles.len());
for r in roles {
let system_badge = if r.locked {
Some(
@ -128,17 +128,17 @@ async fn profile_roles(roles: &[role::Model], cx: &mut Context) -> Block {
} else {
None
};
items.push((r.label.clone(), system_badge));
items.push((crate::role_label(r.id, &r.label), system_badge));
}
Block::new()
.with_title(Lc::t("field-roles", &LOCALES_USER))
.with_child(Html::with(move |_cx| {
.with_child(Html::with(move |cx| {
html! {
ul class="user-profile-roles" {
@for (label, system_badge) in &items {
li {
(label.as_str())
(label.using(cx))
@if let Some(badge) = system_badge {
" "
(badge)

View file

@ -319,7 +319,7 @@ async fn role_view_details(role: &role::Model, cx: &mut Context) -> Block {
.with_row(
table::Row::new()
.with_cell(Lc::t("field-label", &LOCALES_USER))
.with_cell(role.label.as_str()),
.with_cell(crate::role_label(role.id, &role.label)),
)
.with_row(
table::Row::new()

View file

@ -590,11 +590,11 @@ async fn user_view_roles(roles: &[role::Model], is_admin: bool, cx: &mut Context
} else {
None
};
let (id, label) = (r.id, r.label.clone());
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.as_str()) } }
html! { a href=(cx.route(role_path(id, "view"))) { (label.using(cx)) } }
}))
.with_cell(r.machine_name.as_str())
.with_cell(Html::with(move |_| {

View file

@ -55,10 +55,10 @@ pub(crate) struct Username {
impl Username {
// Guarda el nombre de usuario en el modelo.
pub(crate) fn set_on(self, model: &mut user::ActiveModel) {
model.username = Set(self.value);
model.username_key = Set(self.key);
model.username_skeleton = Set(self.skeleton);
pub(crate) fn set_on(&self, model: &mut user::ActiveModel) {
model.username = Set(self.value.clone());
model.username_key = Set(self.key.clone());
model.username_skeleton = Set(self.skeleton.clone());
}
}
@ -154,9 +154,9 @@ pub(crate) struct Email {
impl Email {
// Guarda el email en el modelo.
pub(crate) fn set_on(self, model: &mut user::ActiveModel) {
model.email = Set(self.value);
model.email_key = Set(self.key);
pub(crate) fn set_on(&self, model: &mut user::ActiveModel) {
model.email = Set(self.value.clone());
model.email_key = Set(self.key.clone());
}
}

View file

@ -313,6 +313,16 @@ fn is_system_role(role_id: i32) -> bool {
role_id == ANONYMOUS_ROLE_ID || role_id == AUTHENTICATED_ROLE_ID
}
// Etiqueta visible de un rol. Las de los roles de sistema se traducen: la migración las guarda en
// inglés y, al estar bloqueados, no se pueden editar.
fn role_label(role_id: i32, label: &str) -> Lc {
match role_id {
ANONYMOUS_ROLE_ID => Lc::t("role-anonymous", &LOCALES_USER),
AUTHENTICATED_ROLE_ID => Lc::t("role-authenticated", &LOCALES_USER),
_ => Lc::n(label.to_owned()),
}
}
// **< Extension >**********************************************************************************
/// Implementa la extensión `pagetop-user`.

View file

@ -150,6 +150,11 @@ status-active = Active
status-blocked = Blocked
status-pending = Pending email verification
# **< System roles >**
role-anonymous = Anonymous
role-authenticated = Authenticated
# **< Admin: page titles >**
title-admin-users = Users

View file

@ -150,6 +150,11 @@ status-active = Activo
status-blocked = Bloqueado
status-pending = Pendiente de verificación de email
# **< Roles de sistema >**
role-anonymous = Anónimo
role-authenticated = Autenticado
# **< Administración: títulos de página >**
title-admin-users = Usuarios

View file

@ -3,12 +3,7 @@
use std::collections::HashMap;
use pagetop::prelude::*;
use pagetop_seaorm::db::query::{Expr, Func, LikeExpr};
use pagetop_seaorm::db::{
ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, DbErr, EntityTrait,
Order, Paginated, PaginatorTrait, QueryFilter, QueryOrder, Set, TransactionTrait, dbconn,
flatten_txn_err, paginate,
};
use pagetop_seaorm::db::*;
use crate::account::UserStatus;
use crate::config::{SETTINGS, user_language_applies, user_timezone_applies};
@ -78,15 +73,17 @@ pub(crate) async fn list_users(
select = select.filter(
Condition::any()
.add(
Expr::col(user::Column::UsernameKey)
query::Expr::col(user::Column::UsernameKey)
.like(contains_pattern(&identity::username_key(q))),
)
.add(
Expr::col(user::Column::EmailKey)
query::Expr::col(user::Column::EmailKey)
.like(contains_pattern(&identity::email_key(q))),
)
.add(
Expr::expr(Func::lower(Expr::col(user::Column::DisplayName)))
query::Expr::expr(query::Func::lower(query::Expr::col(
user::Column::DisplayName,
)))
.like(contains_pattern(&q.to_lowercase())),
),
);
@ -112,7 +109,7 @@ pub(crate) async fn list_users(
// Patrón `LIKE` que busca `text` en cualquier posición, con los comodines `%` y `_` escapados para
// que se busquen tal cual (p. ej. el `_` de `demo_user`). Se escapan con `!`, no con `\`, que
// MySQL interpreta también dentro de las cadenas.
fn contains_pattern(text: &str) -> LikeExpr {
fn contains_pattern(text: &str) -> query::LikeExpr {
let mut pattern = String::with_capacity(text.len() + 2);
pattern.push('%');
for c in text.chars() {
@ -122,7 +119,7 @@ fn contains_pattern(text: &str) -> LikeExpr {
pattern.push(c);
}
pattern.push('%');
LikeExpr::new(pattern).escape('!')
query::LikeExpr::new(pattern).escape('!')
}
async fn user_items(users: Vec<user::Model>) -> Result<Vec<UserListItem>, AuthError> {
@ -253,7 +250,7 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError>
email.set_on(&mut new_user);
let role_ids = assignable_roles(data.initial_role_ids);
dbconn()
let result = dbconn()
.transaction::<_, _, AuthError>(|txn| {
Box::pin(async move {
let user_id = user::Entity::insert(new_user)
@ -265,7 +262,11 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError>
})
})
.await
.map_err(flatten_txn_err)
.map_err(flatten_txn_err);
match result {
Err(err) => Err(taken_on_conflict(err, Some(&username), &email, None).await),
ok => ok,
}
}
// **< update_user >********************************************************************************
@ -365,7 +366,9 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
}
username.set_on(&mut model);
email.set_on(&mut model);
model.update(dbconn()).await?;
if let Err(err) = model.update(dbconn()).await {
return Err(taken_on_conflict(err.into(), Some(&username), &email, Some(user_id)).await);
}
if email_changed {
crate::auth::cancel_email_change(user_id).await?;
crate::auth::revoke_address_tokens(user_id).await?;
@ -628,6 +631,33 @@ pub(crate) async fn ensure_email_available(
Ok(())
}
// Traduce el error al guardar una cuenta si otra petición ha ocupado el nombre de usuario o el email
// entre la comprobación (`ensure_username_available()`, `ensure_email_available()`) y la escritura.
// Ante la violación de un índice único repite la comprobación, para devolver `UsernameTaken` o
// `EmailTaken` en lugar de un error interno; cualquier otro error se devuelve tal cual.
pub(crate) async fn taken_on_conflict(
err: AuthError,
username: Option<&Username>,
email: &Email,
exclude_id: Option<i32>,
) -> AuthError {
let AuthError::Database(db_err) = &err else {
return err;
};
if !matches!(db_err.sql_err(), Some(SqlErr::UniqueConstraintViolation(_))) {
return err;
}
if let Some(username) = username
&& let Err(taken) = ensure_username_available(username, exclude_id).await
{
return taken;
}
match ensure_email_available(email, exclude_id).await {
Err(taken) => taken,
Ok(()) => err,
}
}
// Comprueba si `user_id` es actualmente el único usuario con `is_admin = true`.
async fn is_last_administrator(user_id: i32) -> Result<bool, AuthError> {
let user = find_user(user_id).await?;