pagetop/extensions/pagetop-admin/src/settings.rs
Manuel Cillero 04502ef81e ✨ (user): Añade zona horaria propia del usuario
Sustituye el campo de texto libre por un selector de zonas horarias IANA
canónicas agrupadas por región, con la opción de usar la del sitio (que
muestra la zona efectiva).
2026-10-02 22:31:58 +02:00

235 lines
7.5 KiB
Rust

//! Almacén de configuración persistente basado en `settings`.
//!
//! Proporciona una API async para leer y escribir valores JSON en la tabla `settings`.
use pagetop::prelude::*;
use pagetop_seaorm::db::{
ActiveModelTrait, ActiveValue, ColumnTrait, EntityTrait, QueryFilter, dbconn,
};
use serde::{Serialize, de::DeserializeOwned};
use crate::entity::setting::{ActiveModel, Column, Entity};
use crate::error::AdminError;
// **< API pública >********************************************************************************
/// Lee un valor persistido, devolviendo el `Default` del tipo si no existe.
pub async fn get<T: DeserializeOwned + Default>(key: &str) -> T {
get_async(key).await.unwrap_or_default()
}
/// Lee un valor persistido, devolviendo `default` si no existe o hay error.
pub async fn get_or<T: DeserializeOwned>(key: &str, default: T) -> T {
get_async(key).await.unwrap_or(default)
}
/// Escribe un valor en la tabla `settings`.
///
/// Si la clave no existe se inserta; si existe, se actualiza.
pub async fn set<T: Serialize>(key: &str, value: &T, scope: &str, user_id: Option<i32>) {
set_async(key, value, scope, user_id).await.ok();
}
/// Elimina una entrada de `settings` por clave.
pub async fn delete(key: &str) {
delete_async(key).await.ok();
}
/// Devuelve todos los pares `(key, value_json)` de un `scope` dado.
pub async fn list_scope(scope: &str) -> Vec<(String, String)> {
list_scope_async(scope).await.unwrap_or_default()
}
// **< Implementación asíncrona >*******************************************************************
async fn get_async<T: DeserializeOwned>(key: &str) -> Result<T, AdminError> {
let model = Entity::find_by_id(key)
.one(dbconn())
.await?
.ok_or_else(|| AdminError::NotFound(key.to_owned()))?;
Ok(serde_json::from_str(&model.value)?)
}
async fn set_async<T: Serialize>(
key: &str,
value: &T,
scope: &str,
user_id: Option<i32>,
) -> Result<(), AdminError> {
let value_json = serde_json::to_string(value)?;
let now = Utc::now();
let existing = Entity::find_by_id(key).one(dbconn()).await?;
if existing.is_some() {
let model = ActiveModel {
key: ActiveValue::Unchanged(key.to_owned()),
scope: ActiveValue::Set(scope.to_owned()),
value: ActiveValue::Set(value_json),
updated_at: ActiveValue::Set(now),
updated_by: ActiveValue::Set(user_id),
};
model.update(dbconn()).await?;
} else {
let model = ActiveModel {
key: ActiveValue::Set(key.to_owned()),
scope: ActiveValue::Set(scope.to_owned()),
value: ActiveValue::Set(value_json),
updated_at: ActiveValue::Set(now),
updated_by: ActiveValue::Set(user_id),
};
model.insert(dbconn()).await?;
}
Ok(())
}
async fn delete_async(key: &str) -> Result<(), AdminError> {
Entity::delete_by_id(key).exec(dbconn()).await?;
Ok(())
}
async fn list_scope_async(scope: &str) -> Result<Vec<(String, String)>, AdminError> {
let rows = Entity::find()
.filter(Column::Scope.eq(scope))
.all(dbconn())
.await?;
Ok(rows.into_iter().map(|m| (m.key, m.value)).collect())
}
// **< Tipos de esquema >***************************************************************************
/// Tipo de campo de configuración para un [`SettingsSchema`].
#[derive(Clone, Debug)]
pub enum SettingFieldType {
/// Texto libre con longitud máxima opcional.
Text { max_length: Option<usize> },
/// Número (entero o decimal).
Number { min: Option<f64>, max: Option<f64> },
/// Casilla de verificación (booleano).
Boolean,
/// Lista de opciones `(valor, etiqueta)`.
Select { options: Vec<(String, String)> },
}
/// Definición de un campo dentro de un [`SettingsSchema`].
#[derive(Clone, Debug, Getters)]
pub struct SettingField {
/// Devuelve el nombre del campo (clave dentro del scope, p. ej. `"site_name"`).
name: String,
/// Devuelve la etiqueta visible en el formulario.
label: String,
/// Devuelve el tipo de campo.
field_type: SettingFieldType,
/// Devuelve si el campo es obligatorio.
required: bool,
/// Devuelve el texto de ayuda opcional bajo el campo.
help_text: Option<String>,
/// Devuelve el valor por defecto como cadena JSON.
default_value: Option<String>,
}
#[builder_impl]
impl SettingField {
/// Crea un campo de texto con nombre y etiqueta.
pub fn text(name: impl Into<String>, label: impl Into<String>) -> Self {
SettingField {
name: name.into(),
label: label.into(),
field_type: SettingFieldType::Text { max_length: None },
required: false,
help_text: None,
default_value: None,
}
}
/// Crea un campo numérico con nombre y etiqueta.
pub fn number(name: impl Into<String>, label: impl Into<String>) -> Self {
SettingField {
name: name.into(),
label: label.into(),
field_type: SettingFieldType::Number {
min: None,
max: None,
},
required: false,
help_text: None,
default_value: None,
}
}
/// Crea un campo booleano con nombre y etiqueta.
pub fn boolean(name: impl Into<String>, label: impl Into<String>) -> Self {
SettingField {
name: name.into(),
label: label.into(),
field_type: SettingFieldType::Boolean,
required: false,
help_text: None,
default_value: None,
}
}
/// Crea un campo de selección con nombre, etiqueta y opciones.
pub fn select(
name: impl Into<String>,
label: impl Into<String>,
options: Vec<(String, String)>,
) -> Self {
SettingField {
name: name.into(),
label: label.into(),
field_type: SettingFieldType::Select { options },
required: false,
help_text: None,
default_value: None,
}
}
/// Establece si el campo es obligatorio.
pub fn with_required(mut self, required: bool) -> Self {
self.required = required;
self
}
/// Añade texto de ayuda bajo el campo.
pub fn with_help(mut self, text: impl Into<String>) -> Self {
self.help_text = Some(text.into());
self
}
/// Establece el valor por defecto (como valor JSON serializado).
pub fn with_default<T: Serialize>(mut self, value: &T) -> Self {
self.default_value = serde_json::to_string(value).ok();
self
}
}
/// Esquema de formulario de configuración: describe un grupo de ajustes en un scope.
#[derive(Clone, Debug, Getters)]
pub struct SettingsSchema {
/// Devuelve el identificador del grupo (prefijo de las claves en `settings`).
scope: String,
/// Devuelve los campos del formulario en orden de presentación.
fields: Vec<SettingField>,
}
#[builder_impl]
impl SettingsSchema {
/// Crea un nuevo esquema vacío para el `scope` dado.
pub fn new(scope: impl Into<String>) -> Self {
SettingsSchema {
scope: scope.into(),
fields: Vec::new(),
}
}
/// Añade un campo al esquema.
pub fn with_field(mut self, field: SettingField) -> Self {
self.fields.push(field);
self
}
/// Devuelve la clave completa de un campo: `"{scope}.{field_name}"`.
pub fn key_for(&self, field_name: &str) -> String {
util::join!(&self.scope, ".", field_name)
}
}