use chrono::{DateTime, Utc};
use rustango::sql::Auto;
use rustango::Model;
use serde::{Deserialize, Serialize};
use crate::widget::{Widget, WidgetKind};
#[derive(Model, Debug, Clone, Serialize, Deserialize)]
#[rustango(
table = "cms_site_setting",
app = "cms",
display = "scope",
admin(list_display = "scope, updated_at", ordering = "scope",)
)]
pub struct SiteSetting {
#[rustango(primary_key)]
pub id: Auto<i64>,
#[rustango(max_length = 64, index)]
pub scope: String,
pub value_json: serde_json::Value,
#[rustango(auto_now)]
pub updated_at: Auto<DateTime<Utc>>,
}
pub async fn get(
pool: &rustango::sql::Pool,
scope: &str,
) -> Result<Option<SiteSetting>, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let rows: Vec<SiteSetting> = SiteSetting::objects()
.where_(SiteSetting::scope.eq(scope.to_owned()))
.fetch(pool)
.await?;
Ok(rows.into_iter().next())
}
pub async fn upsert(
pool: &rustango::sql::Pool,
scope: &str,
value: serde_json::Value,
) -> Result<SiteSetting, rustango::sql::ExecError> {
if let Some(mut row) = get(pool, scope).await? {
row.value_json = value;
row.save_pool(pool).await?;
return Ok(row);
}
let mut row = SiteSetting {
id: Auto::Unset,
scope: scope.to_owned(),
value_json: value,
updated_at: Auto::Unset,
};
row.insert_pool(pool).await?;
Ok(row)
}
pub async fn list_all(
pool: &rustango::sql::Pool,
) -> Result<Vec<SiteSetting>, rustango::sql::ExecError> {
use rustango::sql::FetcherPool as _;
SiteSetting::objects()
.order_by(&[("scope", false)])
.fetch(pool)
.await
}
pub struct SiteSettingSchema {
pub scope: &'static str,
pub label: &'static str,
pub fields: fn() -> Vec<Widget>,
}
inventory::collect!(SiteSettingSchema);
#[must_use]
pub fn schema_for(scope: &str) -> Option<&'static SiteSettingSchema> {
inventory::iter::<SiteSettingSchema>
.into_iter()
.find(|s| s.scope == scope)
}
#[must_use]
pub fn registered_schemas() -> Vec<&'static SiteSettingSchema> {
let mut v: Vec<_> = inventory::iter::<SiteSettingSchema>.into_iter().collect();
v.sort_by_key(|s| s.scope);
v
}
#[macro_export]
macro_rules! register_site_setting {
($scope:expr, $label:expr, $fields:expr $(,)?) => {
$crate::inventory::submit! {
$crate::site_setting::SiteSettingSchema {
scope: $scope,
label: $label,
fields: $fields,
}
}
};
}
#[must_use]
pub fn prefill_widgets(fields: Vec<Widget>, stored: &serde_json::Value) -> Vec<Widget> {
fields
.into_iter()
.map(|mut w| {
if let Some(v) = stored.get(&w.name) {
w.value = json_to_widget_value(w.kind, v);
}
w
})
.collect()
}
fn json_to_widget_value(kind: WidgetKind, v: &serde_json::Value) -> String {
if kind == WidgetKind::Boolean {
let truthy = v.as_bool().unwrap_or(false)
|| v.as_str()
.is_some_and(|s| s == "on" || s == "true" || s == "1")
|| v.as_i64().is_some_and(|n| n != 0);
return if truthy {
"on".to_owned()
} else {
String::new()
};
}
if kind.is_multi_value() {
return match v {
serde_json::Value::Array(_) => v.to_string(),
serde_json::Value::String(s) => s.clone(),
_ => String::new(),
};
}
match v {
serde_json::Value::String(s) => s.clone(),
serde_json::Value::Null => String::new(),
other => other.to_string(),
}
}
#[must_use]
pub fn value_json_from_form(
fields: &[Widget],
form: &std::collections::HashMap<String, String>,
) -> serde_json::Value {
let mut obj = serde_json::Map::new();
for w in fields {
if w.kind == WidgetKind::Boolean {
obj.insert(
w.name.clone(),
serde_json::Value::Bool(form.contains_key(&w.name)),
);
continue;
}
let Some(raw) = form.get(&w.name) else {
continue;
};
let value = match w.kind {
WidgetKind::Integer => {
let t = raw.trim();
if t.is_empty() {
continue;
}
t.parse::<i64>().map_or_else(
|_| serde_json::Value::String(t.to_owned()),
|n| serde_json::json!(n),
)
}
WidgetKind::Number | WidgetKind::Float | WidgetKind::Range => {
let t = raw.trim();
if t.is_empty() {
continue;
}
t.parse::<f64>().map_or_else(
|_| serde_json::Value::String(t.to_owned()),
|n| serde_json::json!(n),
)
}
_ if w.kind.is_multi_value() => serde_json::from_str::<serde_json::Value>(raw)
.unwrap_or_else(|_| serde_json::Value::String(raw.clone())),
_ => serde_json::Value::String(raw.clone()),
};
obj.insert(w.name.clone(), value);
}
serde_json::Value::Object(obj)
}
#[must_use]
pub fn missing_required(
fields: &[Widget],
form: &std::collections::HashMap<String, String>,
) -> Vec<String> {
fields
.iter()
.filter(|w| w.required && w.kind != WidgetKind::Boolean)
.filter(|w| form.get(&w.name).is_none_or(|s| s.trim().is_empty()))
.map(|w| w.label.clone())
.collect()
}
pub async fn prefetch_for_render(
pool: &rustango::sql::Pool,
locale_code: Option<&str>,
) -> std::collections::HashMap<String, serde_json::Value> {
let rows = list_all(pool).await.unwrap_or_default();
rows.into_iter()
.map(|r| (r.scope, localize(&r.value_json, locale_code)))
.collect()
}
pub const I18N_KEY: &str = "_i18n";
#[must_use]
pub fn localize(value: &serde_json::Value, locale: Option<&str>) -> serde_json::Value {
let Some(obj) = value.as_object() else {
return value.clone();
};
let mut out = obj.clone();
let bag = out.remove(I18N_KEY);
if let Some(tr) = locale.and_then(|code| bag.as_ref()?.get(code)?.as_object().cloned()) {
for (k, v) in tr {
if v.as_str().is_some_and(|t| !t.trim().is_empty()) {
out.insert(k, v);
}
}
}
serde_json::Value::Object(out)
}
#[must_use]
pub fn translations(value: &serde_json::Value, locale: &str) -> serde_json::Map<String, serde_json::Value> {
value
.get(I18N_KEY)
.and_then(|b| b.get(locale))
.and_then(serde_json::Value::as_object)
.cloned()
.unwrap_or_default()
}
pub fn set_translations(
value: &mut serde_json::Value,
locale: &str,
fields: serde_json::Map<String, serde_json::Value>,
) {
if !value.is_object() {
*value = serde_json::json!({});
}
let obj = value.as_object_mut().expect("object above");
let bag = obj
.entry(I18N_KEY)
.or_insert_with(|| serde_json::json!({}));
if !bag.is_object() {
*bag = serde_json::json!({});
}
let bag = bag.as_object_mut().expect("object above");
let kept: serde_json::Map<String, serde_json::Value> = fields
.into_iter()
.filter(|(_, v)| v.as_str().is_some_and(|t| !t.trim().is_empty()))
.collect();
if kept.is_empty() {
bag.remove(locale);
} else {
bag.insert(locale.to_owned(), serde_json::Value::Object(kept));
}
if bag.is_empty() {
obj.remove(I18N_KEY);
}
}
pub fn keep_translations(old: &serde_json::Value, new: &mut serde_json::Value) {
if let (Some(bag), Some(obj)) = (old.get(I18N_KEY), new.as_object_mut()) {
obj.insert(I18N_KEY.to_owned(), bag.clone());
}
}
thread_local! {
static CURRENT_SITE_SETTINGS: std::cell::RefCell<
Option<std::sync::Arc<std::collections::HashMap<String, serde_json::Value>>>,
> = const { std::cell::RefCell::new(None) };
}
#[must_use = "the guard clears the thread-local on drop; bind it to a local"]
pub struct SiteSettingsGuard {
_priv: (),
}
impl Drop for SiteSettingsGuard {
fn drop(&mut self) {
CURRENT_SITE_SETTINGS.with(|cell| {
*cell.borrow_mut() = None;
});
}
}
pub fn install(map: std::collections::HashMap<String, serde_json::Value>) -> SiteSettingsGuard {
CURRENT_SITE_SETTINGS.with(|cell| {
*cell.borrow_mut() = Some(std::sync::Arc::new(map));
});
SiteSettingsGuard { _priv: () }
}
pub fn register_tera_function(tera: &mut tera::Tera) {
tera.register_function("site_setting", SiteSettingFn);
}
struct SiteSettingFn;
impl tera::Function for SiteSettingFn {
fn call(
&self,
args: &std::collections::HashMap<String, tera::Value>,
) -> tera::Result<tera::Value> {
let scope = args
.get("scope")
.and_then(tera::Value::as_str)
.unwrap_or("");
if scope.is_empty() {
return Ok(tera::Value::Null);
}
let value = CURRENT_SITE_SETTINGS.with(|cell| {
cell.borrow()
.as_ref()
.and_then(|m| m.get(scope).cloned())
.unwrap_or(tera::Value::Null)
});
Ok(value)
}
}
#[cfg(test)]
mod schema_tests {
#[test]
fn localize_overlays_text_and_hides_the_bag() {
let v = serde_json::json!({
"shop_name": "Clay & Kiln", "footer": "Made by hand.",
"_i18n": { "fr": { "footer": "Fait main.", "shop_name": "" } }
});
assert_eq!(super::localize(&v, Some("fr")), serde_json::json!({"shop_name": "Clay & Kiln", "footer": "Fait main."}));
assert_eq!(super::localize(&v, None), serde_json::json!({"shop_name": "Clay & Kiln", "footer": "Made by hand."}));
assert_eq!(super::localize(&v, Some("de")), super::localize(&v, None));
}
#[test]
fn set_and_keep_translations() {
let mut v = serde_json::json!({"footer": "Made by hand."});
let mut f = serde_json::Map::new();
f.insert("footer".into(), serde_json::json!("Fait main."));
f.insert("shop_name".into(), serde_json::json!(" "));
super::set_translations(&mut v, "fr", f);
assert_eq!(super::translations(&v, "fr"), serde_json::json!({"footer": "Fait main."}).as_object().unwrap().clone());
let mut saved = serde_json::json!({"footer": "Made by hand, fired with care."});
super::keep_translations(&v, &mut saved);
assert_eq!(saved["_i18n"]["fr"]["footer"], "Fait main.");
super::set_translations(&mut saved, "fr", serde_json::Map::new());
assert!(saved.get("_i18n").is_none(), "no languages left → no bag");
}
use super::*;
use std::collections::HashMap;
fn footer_fields() -> Vec<Widget> {
vec![
Widget::new(WidgetKind::Text, "site_name", "Site name").required(),
Widget::new(WidgetKind::Integer, "since", "Founded year"),
Widget::new(WidgetKind::Float, "rating", "Rating"),
Widget::new(WidgetKind::Boolean, "show_social", "Show social links"),
Widget::new(WidgetKind::MultiSelect, "networks", "Networks"),
]
}
crate::register_site_setting!("__test_footer", "Test footer", footer_fields);
fn form(pairs: &[(&str, &str)]) -> HashMap<String, String> {
pairs
.iter()
.map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
.collect()
}
#[test]
fn schema_for_finds_registered_and_ignores_unknown() {
let s = schema_for("__test_footer").expect("registered schema");
assert_eq!(s.label, "Test footer");
assert_eq!((s.fields)().len(), 5);
assert!(schema_for("definitely-not-registered").is_none());
assert!(registered_schemas()
.iter()
.any(|s| s.scope == "__test_footer"));
}
#[test]
fn form_coerces_values_by_widget_kind() {
let fields = footer_fields();
let f = form(&[
("site_name", "Eugene Co"),
("since", "2014"),
("rating", "4.5"),
("show_social", "on"),
("networks", r#"["x","mastodon"]"#),
("csrf_token", "tok"),
("stray", "ignored"),
]);
let v = value_json_from_form(&fields, &f);
assert_eq!(v["site_name"], serde_json::json!("Eugene Co"));
assert_eq!(v["since"], serde_json::json!(2014)); assert_eq!(v["rating"], serde_json::json!(4.5)); assert_eq!(v["show_social"], serde_json::json!(true)); assert_eq!(v["networks"], serde_json::json!(["x", "mastodon"])); assert!(v.get("csrf_token").is_none());
assert!(v.get("stray").is_none());
}
#[test]
fn absent_checkbox_is_false_blank_number_dropped() {
let fields = footer_fields();
let v = value_json_from_form(&fields, &form(&[("site_name", "X"), ("since", "")]));
assert_eq!(v["show_social"], serde_json::json!(false));
assert!(v.get("since").is_none()); }
#[test]
fn unparseable_number_kept_as_string_not_lost() {
let fields = footer_fields();
let v = value_json_from_form(&fields, &form(&[("site_name", "X"), ("since", "MMXIV")]));
assert_eq!(v["since"], serde_json::json!("MMXIV"));
}
#[test]
fn prefill_round_trips_through_widget_value() {
let stored = serde_json::json!({
"site_name": "Eugene Co",
"since": 2014,
"show_social": true,
"networks": ["x", "mastodon"],
});
let widgets = prefill_widgets(footer_fields(), &stored);
let by_name = |n: &str| widgets.iter().find(|w| w.name == n).unwrap().value.clone();
assert_eq!(by_name("site_name"), "Eugene Co");
assert_eq!(by_name("since"), "2014"); assert_eq!(by_name("show_social"), "on"); assert_eq!(by_name("networks"), r#"["x","mastodon"]"#); }
#[test]
fn missing_required_flags_blank_required_text_only() {
let fields = footer_fields();
let missing = missing_required(&fields, &form(&[("site_name", " ")]));
assert_eq!(missing, vec!["Site name".to_owned()]);
assert!(missing_required(&fields, &form(&[("site_name", "ok")])).is_empty());
}
}
#[cfg(test)]
mod render_tests {
use super::*;
use std::collections::HashMap;
use tera::{Context, Tera};
fn fresh_tera() -> Tera {
let mut tera = Tera::default();
register_tera_function(&mut tera);
tera
}
fn render(tera: &Tera, src: &str) -> String {
let mut t = tera.clone();
t.add_raw_template("t.html", src).unwrap();
t.render("t.html", &Context::new()).unwrap()
}
#[test]
fn returns_null_when_nothing_installed() {
let tera = fresh_tera();
let out = render(
&tera,
r#"{% set v = site_setting(scope="footer") %}{% if v %}has{% else %}none{% endif %}"#,
);
assert_eq!(out, "none");
}
#[test]
fn resolves_known_scope_value_object() {
let mut m = HashMap::new();
m.insert(
"footer".to_owned(),
serde_json::json!({"site_name": "Eugene", "copyright": 2026}),
);
let _g = install(m);
let tera = fresh_tera();
let out = render(
&tera,
r#"{% set footer = site_setting(scope="footer") %}{{ footer.site_name }}-{{ footer.copyright }}"#,
);
assert_eq!(out, "Eugene-2026");
}
#[test]
fn missing_scope_returns_null() {
let mut m = HashMap::new();
m.insert("footer".to_owned(), serde_json::json!({"x": 1}));
let _g = install(m);
let tera = fresh_tera();
let out = render(
&tera,
r#"{% set v = site_setting(scope="missing") %}{% if v %}has{% else %}none{% endif %}"#,
);
assert_eq!(out, "none");
}
#[test]
fn empty_scope_arg_returns_null() {
let mut m = HashMap::new();
m.insert("footer".to_owned(), serde_json::json!({}));
let _g = install(m);
let tera = fresh_tera();
let out = render(
&tera,
r#"{% set v = site_setting(scope="") %}{% if v %}has{% else %}none{% endif %}"#,
);
assert_eq!(out, "none");
}
#[test]
fn guard_clears_thread_local() {
{
let mut m = HashMap::new();
m.insert("x".to_owned(), serde_json::json!({"v": 1}));
let _g = install(m);
let tera = fresh_tera();
assert_eq!(
render(&tera, r#"{% set s = site_setting(scope="x") %}{{ s.v }}"#,),
"1",
);
}
let tera = fresh_tera();
let out = render(
&tera,
r#"{% set v = site_setting(scope="x") %}{% if v %}has{% else %}none{% endif %}"#,
);
assert_eq!(out, "none");
}
}