use crate::log_err::LogErr as _;
use super::{AdminError, PageForm};
use crate::locale::Locale;
use crate::media::Media;
use crate::page::Page;
use crate::page_type::find_handler;
use crate::page_type_model::PageType;
use crate::tree_ops::NewPage;
use axum::extract::{Form, Path, Query, State};
use axum::http::{header, HeaderMap, HeaderValue};
use axum::response::{Html, IntoResponse, Redirect, Response};
use axum::Json;
use rustango::core::Column as _;
use rustango::extractors::Tenant;
use rustango::messages::Level as MsgLevel;
use rustango::sql::{transaction_pool, FetcherPool as _, FetcherTx as _};
use serde::Deserialize;
use std::sync::OnceLock;
use tera::Context;
use crate::security_log::Entry as SecurityEntry;
fn messages_secret() -> &'static [u8] {
static SECRET: OnceLock<Vec<u8>> = OnceLock::new();
SECRET.get_or_init(|| crate::signing::derived_key("rcms:flash"))
}
async fn sanitized_extension_form(
handler: &dyn crate::page_type::PageTypeHandler,
pool: &rustango::sql::Pool,
page_id: i64,
form_map: &std::collections::HashMap<String, String>,
) -> std::collections::HashMap<String, String> {
let mut out = form_map.clone();
if let Ok(widgets) = handler.widgets(pool, page_id).await {
for w in widgets {
if w.kind == crate::widget::WidgetKind::RichText {
if let Some(raw) = out.get(&w.name) {
let cleaned = crate::markdown::sanitize_html(raw);
out.insert(w.name.clone(), cleaned);
}
}
}
}
out
}
const PREVIEW_TOKEN_TTL_SECS: i64 = 3600;
pub(crate) fn render_with_csrf(
state: &super::AdminState,
headers: &HeaderMap,
template: &str,
ctx: &mut Context,
) -> Result<Response, AdminError> {
let user_pref = ctx
.get("user_lang_pref")
.and_then(|v| v.as_str())
.map(str::to_owned);
let tenant_default = super::i18n::tenant_default_locale();
let lang = super::i18n::negotiate(
headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
headers
.get(header::ACCEPT_LANGUAGE)
.and_then(|v| v.to_str().ok()),
user_pref.as_deref(),
tenant_default.as_deref(),
);
let lang_dir = rustango::i18n::text_direction(&lang);
ctx.insert("LANG", &lang);
ctx.insert("LANG_DIR", lang_dir);
let csrf_cookie = rustango::forms::csrf::stamp_into_context(headers, ctx);
let msg_clear = rustango::messages::stamp_into_context(messages_secret(), headers, ctx);
let html = state.tera.render(template, ctx)?;
let mut resp = Html(html).into_response();
if let Some(c) = csrf_cookie {
if let Ok(v) = HeaderValue::from_str(&c) {
resp.headers_mut().append(header::SET_COOKIE, v);
}
}
if let Some(c) = msg_clear {
if let Ok(v) = HeaderValue::from_str(&c) {
resp.headers_mut().append(header::SET_COOKIE, v);
}
}
Ok(resp)
}
fn redirect_named_with_message(
name: &'static str,
level: MsgLevel,
body: &str,
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr(headers, body, &[]);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn redirect_named_with_message_args(
name: &'static str,
level: MsgLevel,
key: &str,
args: &[(&str, &str)],
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr(headers, key, args);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn redirect_named_with_message_plural(
name: &'static str,
level: MsgLevel,
key: &str,
n: i64,
args: &[(&str, &str)],
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr_plural(headers, key, n, args);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn redirect_named_with_params_and_message_plural(
name: &'static str,
params: &[(&str, String)],
level: MsgLevel,
key: &str,
n: i64,
args: &[(&str, &str)],
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let owned: std::collections::HashMap<String, String> = params
.iter()
.map(|(k, v)| ((*k).to_owned(), v.clone()))
.collect();
let url = rustango::urls::reverse_owned(name, &owned)
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr_plural(headers, key, n, args);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn unauthorized_no_session() -> Response {
unauthorized_no_session_for(None)
}
fn unauthorized_no_session_for(headers: Option<&HeaderMap>) -> Response {
let wants_json = headers
.map(|h| {
let accept = h
.get(header::ACCEPT)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
if accept.contains("application/json") {
return true;
}
h.get("x-requested-with")
.and_then(|v| v.to_str().ok())
.is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
})
.unwrap_or(false);
let t = |key: &str| -> String {
match headers {
Some(h) => super::i18n::tr(h, key, &[]),
None => key.to_owned(),
}
};
if wants_json {
let payload = serde_json::json!({
"error": "session_expired",
"message": t("Sign in again to keep uploading."),
"login_url": "/login?next=/cms-admin/",
});
return (
axum::http::StatusCode::UNAUTHORIZED,
[(axum::http::header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response();
}
let lang = headers
.map(|h| {
super::i18n::negotiate(
h.get(header::COOKIE).and_then(|v| v.to_str().ok()),
h.get(header::ACCEPT_LANGUAGE).and_then(|v| v.to_str().ok()),
None,
super::i18n::tenant_default_locale().as_deref(),
)
})
.unwrap_or_else(|| "en".to_owned());
let dir = rustango::i18n::text_direction(&lang);
const STYLE: &str = r#"<style>
body{font:14px/1.5 -apple-system,system-ui,sans-serif;color:#222;background:#fafafa;margin:0;padding:48px 20px}
.box{max-width:560px;margin:0 auto;padding:32px;background:#fff;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.08)}
h1{font-size:18px;margin:0 0 12px}
p{margin:0 0 12px;color:#444}
ul{margin:0 0 12px;padding-left:20px;color:#444}
li{margin:4px 0}
a{color:#1565c0}
</style>"#;
let mut body = String::with_capacity(STYLE.len() + 1024);
body.push_str("<!doctype html>\n<html lang=\"");
body.push_str(&crate::forms::render::html_escape(&lang));
body.push_str("\" dir=\"");
body.push_str(dir);
body.push_str("\"><head><meta charset=\"utf-8\"><title>");
body.push_str(&crate::forms::render::html_escape(&t("Session expired")));
body.push_str(" — ");
body.push_str(&crate::forms::render::html_escape(&t("CMS Admin")));
body.push_str("</title>");
body.push_str(STYLE);
body.push_str("</head><body><div class=\"box\">\n<h1>");
body.push_str(&crate::forms::render::html_escape(&t(
"Your session has expired",
)));
body.push_str("</h1>\n<p>");
body.push_str(&crate::forms::render::html_escape(&t(
"The form couldn't be saved because your admin session decoded as anonymous. The most likely causes:",
)));
body.push_str("</p>\n<ul>\n<li>");
body.push_str(&crate::forms::render::html_escape(&t(
"Your login session expired or was signed out from another tab.",
)));
body.push_str("</li>\n<li>");
body.push_str(&crate::forms::render::html_escape(&t(
"The cookie was issued for a different tenant slug.",
)));
body.push_str("</li>\n<li>");
body.push_str(&crate::forms::render::html_escape(&t(
"On sqlite/mysql builds the framework's tenant session store may not be wired up yet (see issue #259).",
)));
body.push_str("</li>\n</ul>\n<p><a href=\"/login?next=/cms-admin/\">");
body.push_str(&crate::forms::render::html_escape(&t("Sign back in")));
body.push_str("</a>");
body.push_str(&crate::forms::render::html_escape(&t(
", then re-submit the form.",
)));
body.push_str("</p>\n</div></body></html>");
(
axum::http::StatusCode::UNAUTHORIZED,
[(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
body,
)
.into_response()
}
pub(crate) fn redirect_named_with_params_and_message(
name: &'static str,
params: &[(&str, String)],
level: MsgLevel,
body: &str,
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let owned: std::collections::HashMap<String, String> = params
.iter()
.map(|(k, v)| ((*k).to_owned(), v.clone()))
.collect();
let url = rustango::urls::reverse_owned(name, &owned)
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr(headers, body, &[]);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
pub(crate) fn redirect_named_with_params_and_message_args(
name: &'static str,
params: &[(&str, String)],
level: MsgLevel,
key: &str,
args: &[(&str, &str)],
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let owned: std::collections::HashMap<String, String> = params
.iter()
.map(|(k, v)| ((*k).to_owned(), v.clone()))
.collect();
let url = rustango::urls::reverse_owned(name, &owned)
.map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
let body = super::i18n::tr(headers, key, args);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn redirect_after_page_save(
action: &str,
page_id: i64,
parent_id: Option<i64>,
body: &str,
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let url = match action {
"continue" => rustango::urls::reverse_owned(
"rcms-admin:pages:edit",
&std::iter::once(("id".to_owned(), page_id.to_string())).collect(),
)
.map_err(|e| AdminError::Validation(format!("url reversal of `pages:edit` failed: {e}")))?,
"addanother" => {
let base =
rustango::urls::reverse("rcms-admin:pages:new", &std::collections::HashMap::new())
.map_err(|e| {
AdminError::Validation(format!("url reversal of `pages:new` failed: {e}"))
})?;
match parent_id {
Some(pid) => format!("{base}?parent={pid}"),
None => base,
}
}
_ => rustango::urls::reverse("rcms-admin:pages:list", &std::collections::HashMap::new())
.map_err(|e| {
AdminError::Validation(format!("url reversal of `pages:list` failed: {e}"))
})?,
};
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
MsgLevel::Success,
body,
&url,
))
}
pub(crate) fn user_email(u: &rustango::tenancy::auth::User) -> String {
u.email
.as_deref()
.map(str::trim)
.filter(|e| !e.is_empty())
.or_else(|| u.data.get("email").and_then(|v| v.as_str()).map(str::trim))
.unwrap_or("")
.to_owned()
}
pub async fn add_chrome(
ctx: &mut Context,
tenant: &Tenant,
active_tab: &str,
session_user: Option<&rustango::tenancy::auth::User>,
) {
add_chrome_sync(ctx, tenant, active_tab);
if let Some(user) = session_user {
add_user_chrome(ctx, user, tenant.pool()).await;
}
add_branding_urls(ctx, tenant).await;
}
pub(crate) async fn add_branding_urls(ctx: &mut Context, tenant: &Tenant) {
let mut site_name = tenant.org.display_name.clone();
if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
if let Some(n) = row.value_json.get("site_name").and_then(|v| v.as_str()).filter(|n| !n.trim().is_empty()) {
n.trim().clone_into(&mut site_name);
}
let is_set = |key: &str| {
row.value_json
.get(key)
.and_then(|v| v.as_str())
.is_some_and(|s| !s.is_empty())
};
if is_set("logo_storage_key") {
ctx.insert("branding_logo_url", "/__cms-branding/logo");
}
if is_set("favicon_storage_key") {
ctx.insert("branding_favicon_url", "/__cms-branding/favicon");
}
}
ctx.insert("site_name", &site_name);
}
fn add_chrome_sync(ctx: &mut Context, tenant: &Tenant, active_tab: &str) {
ctx.insert("active_tab", active_tab);
ctx.insert("tenant_slug", &tenant.org.slug);
ctx.insert("LANG", "en");
ctx.insert("LANG_DIR", "ltr");
ctx.insert(
"ui_locales",
&super::i18n::UI_LOCALES
.iter()
.map(|(c, n)| serde_json::json!({ "code": c, "name": n }))
.collect::<Vec<_>>(),
);
let brand = tenant
.org
.brand_name
.clone()
.filter(|s| !s.is_empty())
.unwrap_or_else(|| tenant.org.display_name.clone());
ctx.insert("brand_name", &brand);
ctx.insert("user_timezone", "");
static DEFAULT_TZ: std::sync::OnceLock<String> = std::sync::OnceLock::new();
let tenant_default_tz = DEFAULT_TZ
.get_or_init(|| crate::config::var("DEFAULT_TIMEZONE").unwrap_or_default())
.clone();
ctx.insert("tenant_default_timezone", &tenant_default_tz);
let mut by_section: std::collections::BTreeMap<String, Vec<serde_json::Value>> =
std::collections::BTreeMap::new();
for handler in super::admin_page::registered_admin_pages() {
let section = handler.section().label().to_owned();
by_section
.entry(section)
.or_default()
.push(serde_json::json!({
"slug": handler.slug(),
"label": handler.label(),
"icon": handler.icon(),
"sort_order": handler.sort_order(),
}));
}
for items in by_section.values_mut() {
items.sort_by(|a, b| {
let ao = a.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
let bo = b.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
ao.cmp(&bo).then_with(|| {
a.get("label")
.and_then(|v| v.as_str())
.unwrap_or("")
.cmp(b.get("label").and_then(|v| v.as_str()).unwrap_or(""))
})
});
}
ctx.insert("extra_admin_pages_by_section", &by_section);
let reports_nav: Vec<serde_json::Value> = super::report::registered_reports()
.iter()
.map(|r| {
serde_json::json!({
"slug": r.slug(),
"title": r.title(),
"icon": r.icon(),
})
})
.collect();
ctx.insert("registered_reports", &reports_nav);
let plugin_menu_items: Vec<serde_json::Value> = crate::hooks::admin_menu_items()
.into_iter()
.map(|i| {
serde_json::json!({
"key": i.key,
"label": i.label,
"icon": i.icon,
"href": i.href,
})
})
.collect();
ctx.insert("plugin_admin_menu_items", &plugin_menu_items);
let help_menu_items: Vec<serde_json::Value> = crate::hooks::help_menu_items()
.into_iter()
.map(|i| {
serde_json::json!({
"key": i.key,
"label": i.label,
"icon": i.icon,
"href": i.href,
})
})
.collect();
ctx.insert("help_menu_items", &help_menu_items);
ctx.insert("admin_css_blobs", &crate::hooks::admin_css());
ctx.insert("admin_js_blobs", &crate::hooks::admin_js());
ctx.insert("sidebar_gating", &false);
ctx.insert("user_is_superuser", &false);
ctx.insert(
"allowed_resources",
&std::collections::HashSet::<String>::new(),
);
}
pub(crate) async fn add_user_chrome(
ctx: &mut Context,
user: &rustango::tenancy::auth::User,
pool: &rustango::sql::Pool,
) {
let user_timezone = user
.data
.get("timezone")
.and_then(serde_json::Value::as_str)
.unwrap_or("")
.to_owned();
ctx.insert("user_timezone", &user_timezone);
if let Some(pref) = user
.data
.get("admin_lang")
.and_then(serde_json::Value::as_str)
.filter(|s| super::i18n::is_ui_locale(s))
{
ctx.insert("user_lang_pref", pref);
}
ctx.insert("user_is_superuser", &user.is_superuser);
ctx.insert("user_username", &user.username);
let display_name = user
.data
.get("display_name")
.and_then(serde_json::Value::as_str)
.filter(|s| !s.is_empty())
.unwrap_or(&user.username)
.to_owned();
ctx.insert("user_display_name", &display_name);
let has_avatar = user
.data
.get("avatar_path")
.and_then(serde_json::Value::as_str)
.map(|s| !s.is_empty())
.unwrap_or(false);
if has_avatar {
let uid = user.id.get().copied().unwrap_or(0);
ctx.insert("user_avatar_url", &format!("/__cms-avatar/{uid}"));
}
let codenames = if user.is_superuser {
std::collections::HashSet::<String>::new()
} else {
let uid = user.id.get().copied().unwrap_or(0);
crate::permissions::user_codenames(pool, uid)
.await
.unwrap_or_default()
};
ctx.insert("allowed_resources", &codenames);
ctx.insert("sidebar_gating", &true);
}
pub async fn collections_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
.order_by(&[("parent_id", false), ("sort_order", false), ("name", false)])
.fetch(tenant.pool())
.await?;
let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = collections
.iter()
.filter_map(|c| c.id.get().copied().map(|id| (id, c)))
.collect();
fn depth(
c: &crate::media::MediaCollection,
by_id: &std::collections::HashMap<i64, &crate::media::MediaCollection>,
cache: &mut std::collections::HashMap<i64, i32>,
) -> i32 {
let id = c.id.get().copied().unwrap_or_default();
if let Some(d) = cache.get(&id) {
return *d;
}
let d = match c.parent_id {
None => 0,
Some(pid) => match by_id.get(&pid) {
Some(parent) => depth(parent, by_id, cache) + 1,
None => 0,
},
};
cache.insert(id, d);
d
}
let media: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for m in &media {
if let Some(cid) = m.collection_id {
*counts.entry(cid).or_insert(0) += 1;
}
}
let mut depth_cache: std::collections::HashMap<i64, i32> = std::collections::HashMap::new();
let rows: Vec<serde_json::Value> = collections
.iter()
.map(|c| {
let id = c.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": id,
"name": c.name,
"parent_id": c.parent_id,
"parent_name": c.parent_id.and_then(|pid| by_id.get(&pid)).map(|p| p.name.clone()),
"sort_order": c.sort_order,
"depth": depth(c, &by_id, &mut depth_cache),
"media_count": counts.get(&id).copied().unwrap_or(0),
"created_at": c.created_at.get().copied(),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("collections", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/collections_list.html",
&mut ctx,
)
}
#[derive(Debug, Deserialize)]
pub struct CollectionForm {
pub name: String,
#[serde(default, deserialize_with = "super::deserialize_optional_i64")]
pub parent_id: Option<i64>,
#[serde(default)]
pub sort_order: Option<i32>,
}
pub async fn collections_create(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<CollectionForm>,
) -> Result<Response, AdminError> {
let name = form.name.trim().to_owned();
if name.is_empty() {
return Err(AdminError::Validation(
"Collection name is required.".to_owned(),
));
}
let mut row = crate::media::MediaCollection {
id: rustango::sql::Auto::Unset,
name: name.clone(),
parent_id: form.parent_id,
sort_order: form.sort_order.unwrap_or(100),
created_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:media:collections",
MsgLevel::Success,
"Collection “{name}” created.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn collections_edit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<CollectionForm>,
) -> Result<Response, AdminError> {
let mut row = crate::media::MediaCollection::objects()
.where_(crate::media::MediaCollection::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let name = form.name.trim().to_owned();
if name.is_empty() {
return Err(AdminError::Validation(
"Collection name is required.".to_owned(),
));
}
if form.parent_id == Some(id) {
return Err(AdminError::Validation(
"A collection cannot be its own parent.".to_owned(),
));
}
row.name = name;
row.parent_id = form.parent_id;
if let Some(so) = form.sort_order {
row.sort_order = so;
}
row.save_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:media:collections",
MsgLevel::Success,
"Collection saved.",
&headers,
)
}
pub async fn collections_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = crate::media::MediaCollection::objects()
.where_(crate::media::MediaCollection::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let parent = row.parent_id;
let name = row.name.clone();
for mut child in crate::media::MediaCollection::objects()
.where_(crate::media::MediaCollection::parent_id.eq(Some(id)))
.fetch(tenant.pool())
.await?
{
child.parent_id = parent;
child.save_pool(tenant.pool()).await?;
}
for mut m in Media::objects()
.where_(Media::collection_id.eq(Some(id)))
.fetch(tenant.pool())
.await?
{
m.collection_id = None;
m.save_pool(tenant.pool()).await?;
}
row.delete_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:media:collections",
MsgLevel::Success,
"Collection “{name}” deleted. Children re-parented; media moved to Uncategorized.",
&[("name", name.as_str())],
&headers,
)
}
use crate::category::model::{self as category_model, Category, CategoryError};
fn category_tree_redirect(
slug: &str,
headers: &HeaderMap,
level: MsgLevel,
key: &str,
args: &[(&str, &str)],
) -> Result<Response, AdminError> {
let body = super::i18n::tr(headers, key, args);
let url = format!("/cms-admin/taxonomies/{slug}");
Ok(rustango::messages::redirect_with_message(
messages_secret(),
headers,
level,
&body,
&url,
))
}
fn opt_i64_from_form(form: &std::collections::HashMap<String, String>, key: &str) -> Option<i64> {
form.get(key)
.map(|s| s.trim())
.filter(|s| !s.is_empty())
.and_then(|s| s.parse::<i64>().ok())
}
fn category_base_widgets(
cat: Option<&Category>,
parent_opts: Vec<(String, String)>,
) -> Vec<crate::widget::Widget> {
use crate::widget::{Widget, WidgetKind};
let mut opts = vec![(String::new(), "— none (top level) —".to_owned())];
opts.extend(parent_opts);
vec![
Widget::new(WidgetKind::Text, "name", "Name")
.required()
.with_value(cat.map(|c| c.name.clone()).unwrap_or_default()),
Widget::new(WidgetKind::Text, "slug", "Slug")
.with_help("URL identifier — auto-generated from the name if left blank.")
.with_value(cat.map(|c| c.slug.clone()).unwrap_or_default()),
Widget::new(WidgetKind::Textarea, "description", "Description")
.with_value(cat.map(|c| c.description.clone()).unwrap_or_default()),
Widget::new(
WidgetKind::MediaPicker,
"featured_image_id",
"Featured image",
)
.with_value(
cat.and_then(|c| c.featured_image_id)
.map(|i| i.to_string())
.unwrap_or_default(),
),
Widget::new(WidgetKind::MediaPicker, "thumbnail_id", "Thumbnail").with_value(
cat.and_then(|c| c.thumbnail_id)
.map(|i| i.to_string())
.unwrap_or_default(),
),
Widget::new(WidgetKind::Select, "parent_id", "Parent")
.with_options(opts)
.with_help("Nest this category under another (siblings share a parent).")
.with_value(
cat.and_then(|c| c.parent_id)
.map(|i| i.to_string())
.unwrap_or_default(),
),
]
}
async fn category_parent_options(
pool: &rustango::sql::Pool,
taxonomy_id: i64,
exclude: Option<i64>,
) -> Result<Vec<(String, String)>, AdminError> {
let cats = category_model::all_in_taxonomy(pool, taxonomy_id)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?;
Ok(cats
.iter()
.filter(|c| c.id.get().copied() != exclude)
.map(|c| {
let indent = "— ".repeat((c.depth.max(1) - 1) as usize);
(
c.id.get().copied().unwrap_or_default().to_string(),
format!("{indent}{}", c.name),
)
})
.collect())
}
pub async fn taxonomies_index(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let taxes = crate::category::taxonomies(tenant.pool())
.await
.map_err(|e| AdminError::Validation(e.to_string()))?;
let all_cats: Vec<Category> = Category::objects().fetch(tenant.pool()).await?;
let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for c in &all_cats {
*counts.entry(c.taxonomy_id).or_insert(0) += 1;
}
let rows: Vec<serde_json::Value> = taxes
.iter()
.map(|t| {
serde_json::json!({
"slug": t.slug,
"verbose_name": t.verbose_name,
"icon": if t.icon.is_empty() { "sell".to_owned() } else { t.icon.clone() },
"description": t.description,
"hierarchical": t.hierarchical,
"count": counts.get(&t.id.get().copied().unwrap_or_default()).copied().unwrap_or(0),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("taxonomies", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/taxonomies_list.html",
&mut ctx,
)
}
pub async fn category_tree(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let cats =
category_model::all_in_taxonomy(tenant.pool(), tax.id.get().copied().unwrap_or_default())
.await
.map_err(|e| AdminError::Validation(e.to_string()))?;
let rows: Vec<serde_json::Value> = cats
.iter()
.map(|c| {
serde_json::json!({
"id": c.id.get().copied(),
"name": c.name,
"slug": c.slug,
"description": c.description,
"depth": c.depth,
"thumbnail_id": c.thumbnail_id,
"featured_image_id": c.featured_image_id,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("taxonomy_slug", &tax.slug);
ctx.insert("taxonomy_name", &tax.verbose_name);
ctx.insert("categories", &rows);
render_with_csrf(&state, &headers, "rcms_admin/category_tree.html", &mut ctx)
}
pub async fn category_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let tid = tax.id.get().copied().unwrap_or_default();
let mut fields = if tax.hierarchical {
category_base_widgets(
None,
category_parent_options(tenant.pool(), tid, None).await?,
)
} else {
let mut w = category_base_widgets(None, Vec::new());
w.pop();
w
};
let _ = &mut fields;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("taxonomy_slug", &tax.slug);
ctx.insert("taxonomy_name", &tax.verbose_name);
ctx.insert("mode", "new");
ctx.insert("fields", &fields);
render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
}
pub async fn category_create(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let tid = tax.id.get().copied().unwrap_or_default();
let new = category_model::NewCategory {
name: form
.get("name")
.cloned()
.unwrap_or_default()
.trim()
.to_owned(),
slug: form.get("slug").cloned().unwrap_or_default(),
description: form.get("description").cloned().unwrap_or_default(),
featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
parent_id: opt_i64_from_form(&form, "parent_id"),
};
if new.name.is_empty() {
return category_tree_redirect(
&slug,
&headers,
MsgLevel::Error,
"Category name is required.",
&[],
);
}
match category_model::create(tenant.pool(), tid, new).await {
Ok(cat) => {
let id = cat.id.get().copied().unwrap_or_default();
let body = super::i18n::tr(
&headers,
"Category “{name}” created.",
&[("name", cat.name.as_str())],
);
let url = format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit");
Ok(rustango::messages::redirect_with_message(
messages_secret(),
&headers,
MsgLevel::Success,
&body,
&url,
))
}
Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
}
}
pub async fn category_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((slug, id)): Path<(String, i64)>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let tid = tax.id.get().copied().unwrap_or_default();
let cat = Category::objects()
.where_(Category::id.eq(id))
.where_(Category::taxonomy_id.eq(tid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut fields = if tax.hierarchical {
category_base_widgets(
Some(&cat),
category_parent_options(tenant.pool(), tid, Some(id)).await?,
)
} else {
let mut w = category_base_widgets(Some(&cat), Vec::new());
w.pop();
w
};
if let Some(handler) = crate::category::find_handler(&slug) {
if let Ok(ext) = handler.ext_widgets(tenant.pool(), id).await {
fields.extend(ext);
}
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("taxonomy_slug", &tax.slug);
ctx.insert("taxonomy_name", &tax.verbose_name);
ctx.insert("mode", "edit");
ctx.insert("category_id", &id);
ctx.insert("fields", &fields);
let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let editing_locale = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.and_then(|code| locales.iter().find(|l| l.code == code && !l.is_default).cloned());
if let Some(loc) = &editing_locale {
let lid = loc.id.get().copied().unwrap_or_default();
let mut existing = crate::category_translation::fetch_for_categories(tenant.pool(), &[id], lid)
.await
.unwrap_or_default();
ctx.insert("translation_mode", &true);
ctx.insert("editing_locale", loc);
ctx.insert("category_name", &cat.name);
ctx.insert("tr_name", &existing.remove(&id).and_then(|mut f| f.remove("name")).unwrap_or_default());
}
ctx.insert("locales", &locales);
render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
}
pub async fn category_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((slug, id)): Path<(String, i64)>,
Query(q): Query<EditQuery>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
use crate::category_translation::{CategoryTranslation, TRANSLATABLE_FIELDS};
let code = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
let locale = crate::locale::Locale::objects()
.where_(crate::locale::Locale::code.eq(code.to_owned()))
.where_(crate::locale::Locale::active.eq(true))
.where_(crate::locale::Locale::is_default.eq(false))
.first(tenant.pool())
.await?
.ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
let locale_id = locale.id.get().copied().unwrap_or_default();
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
Category::objects()
.where_(Category::id.eq(id))
.where_(Category::taxonomy_id.eq(tax.id.get().copied().unwrap_or_default()))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for field in TRANSLATABLE_FIELDS {
let Some(value) = form.get(&format!("tr__{field}")) else {
continue;
};
let value = value.trim().to_owned();
let existing: Vec<CategoryTranslation> = CategoryTranslation::objects()
.where_(CategoryTranslation::category_id.eq(id))
.where_(CategoryTranslation::locale_id.eq(locale_id))
.where_(CategoryTranslation::field_path.eq(field.to_owned()))
.fetch_tx(tx)
.await?;
if value.is_empty() {
for row in existing {
row.delete_tx(tx).await?;
}
} else if let Some(mut row) = existing.into_iter().next() {
row.value = value;
row.save_tx(tx).await?;
} else {
let mut row = CategoryTranslation {
id: rustango::sql::Auto::Unset,
category_id: id,
locale_id,
field_path: field.to_owned(),
value,
updated_at: rustango::sql::Auto::Unset,
};
row.save_tx(tx).await?;
}
}
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
Ok(Redirect::to(&format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit?locale={code}")).into_response())
}
pub async fn category_update(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((slug, id)): Path<(String, i64)>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let tid = tax.id.get().copied().unwrap_or_default();
let new = category_model::NewCategory {
name: form
.get("name")
.cloned()
.unwrap_or_default()
.trim()
.to_owned(),
slug: form.get("slug").cloned().unwrap_or_default(),
description: form.get("description").cloned().unwrap_or_default(),
featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
parent_id: opt_i64_from_form(&form, "parent_id"),
};
if new.name.is_empty() {
return category_tree_redirect(
&slug,
&headers,
MsgLevel::Error,
"Category name is required.",
&[],
);
}
let new_parent = new.parent_id;
if let Err(e) = category_model::update(tenant.pool(), tid, id, new).await {
return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
}
if let Err(e) = category_model::move_to(tenant.pool(), tid, id, new_parent).await {
return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
}
if let Some(handler) = crate::category::find_handler(&slug) {
if let Err(e) = handler.save_ext(tenant.pool(), id, &form).await {
tracing::warn!(category_id = id, error = %e, "category extension save failed");
}
}
category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category saved.", &[])
}
pub async fn category_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((slug, id)): Path<(String, i64)>,
) -> Result<Response, AdminError> {
let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
.await
.map_err(|e| AdminError::Validation(e.to_string()))?
.ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
let tid = tax.id.get().copied().unwrap_or_default();
match category_model::delete(tenant.pool(), tid, id, false).await {
Ok(_) => {
category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category deleted.", &[])
}
Err(CategoryError::HasChildren(_, n)) => {
let n = n.to_string();
category_tree_redirect(
&slug,
&headers,
MsgLevel::Error,
"Can't delete a category with {count} child categor(ies) — delete or move them first.",
&[("count", n.as_str())],
)
}
Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
}
}
async fn ensure_builder_access(
tenant: &Tenant,
user: Option<&rustango::tenancy::auth::User>,
) -> Option<Response> {
super::codename_gate(tenant, user, "cms_page_type.build").await
}
pub async fn page_type_build_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let pt = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let draft = crate::page_builder::model::draft_for(tenant.pool(), id).await?;
let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
let doc_value = draft
.as_ref()
.map(|d| d.document.clone())
.or_else(|| published.as_ref().map(|p| p.document.clone()))
.unwrap_or_else(|| serde_json::json!({ "nodes": [] }));
let schema_json =
serde_json::to_string(&doc_value).unwrap_or_else(|_| "{\"nodes\":[]}".to_owned());
let components: Vec<serde_json::Value> =
crate::page_builder::model::all_components(tenant.pool())
.await?
.iter()
.map(|c| serde_json::json!({ "slug": c.slug, "label": c.label }))
.collect();
let components_json = serde_json::to_string(&components).unwrap_or_else(|_| "[]".to_owned());
let versions: Vec<serde_json::Value> =
crate::page_builder::model::list_versions(tenant.pool(), id)
.await?
.iter()
.map(|v| {
serde_json::json!({
"version": v.version,
"status": v.status,
"updated_at": v.updated_at.get().copied(),
})
})
.collect();
let is_ui_type = pt.app_label == "cms_ui";
let page_count = if is_ui_type {
Page::objects()
.where_(Page::page_type_id.eq(id))
.fetch(tenant.pool())
.await
.map(|v| v.len())
.unwrap_or(0)
} else {
0
};
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("page_type_id", &id);
ctx.insert("title", &pt.verbose_name);
ctx.insert("schema_json", &schema_json);
ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
ctx.insert(
"publish_url",
&format!("/cms-admin/page-types/{id}/build/publish"),
);
ctx.insert("delete_url", &format!("/cms-admin/page-types/{id}/delete"));
ctx.insert("list_url", "/cms-admin/page-types");
ctx.insert("components_json", &components_json);
ctx.insert("versions", &versions);
ctx.insert("has_unpublished", &draft.is_some());
let translate_locales: Vec<crate::locale::Locale> = if published.is_some() {
crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.where_(crate::locale::Locale::is_default.eq(false))
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?
} else {
Vec::new()
};
ctx.insert("translate_locales", &translate_locales);
ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
ctx.insert("is_ui_type", &is_ui_type);
ctx.insert("page_count", &page_count);
ctx.insert("deletable", &(is_ui_type && page_count == 0));
render_with_csrf(
&state,
&headers,
"rcms_admin/page_type_builder.html",
&mut ctx,
)
}
pub async fn page_type_translate_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let pt = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
let fields = published
.as_ref()
.map(|p| crate::page_builder::choice_i18n::choice_fields(&p.document, &locale.code))
.unwrap_or_default();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("title", &pt.verbose_name);
ctx.insert("editing_locale", &locale);
ctx.insert("choice_fields", &fields);
ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
render_with_csrf(&state, &headers, "rcms_admin/page_type_translate.html", &mut ctx)
}
pub async fn page_type_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
let labels: std::collections::HashMap<(String, String), String> = form
.into_iter()
.filter_map(|(k, v)| {
let rest = k.strip_prefix("tr__")?;
let (path, value) = rest.split_once("__")?;
Some(((path.to_owned(), value.to_owned()), v))
})
.collect();
for row in [
crate::page_builder::model::published_for(tenant.pool(), id).await?,
crate::page_builder::model::draft_for(tenant.pool(), id).await?,
]
.into_iter()
.flatten()
{
let mut row = row;
if crate::page_builder::choice_i18n::set_choice_labels(&mut row.document, &locale.code, &labels) > 0 {
row.save_pool(tenant.pool()).await?;
}
}
let back = format!("/cms-admin/page-types/{id}/translate?locale={}", locale.code);
Ok(rustango::messages::redirect_with_message(
messages_secret(),
&headers,
MsgLevel::Success,
&super::i18n::tr(&headers, "Translations saved.", &[]),
&back,
))
}
async fn translate_locale(tenant: &Tenant, code: Option<&str>) -> Result<crate::locale::Locale, AdminError> {
let code = code
.filter(|c| !c.is_empty())
.ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
crate::locale::Locale::objects()
.where_(crate::locale::Locale::code.eq(code.to_owned()))
.where_(crate::locale::Locale::active.eq(true))
.where_(crate::locale::Locale::is_default.eq(false))
.first(tenant.pool())
.await?
.ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))
}
async fn parse_builder_submit(
tenant: &Tenant,
user: Option<&rustango::tenancy::auth::User>,
id: i64,
schema_str: &str,
) -> Result<Result<(crate::page_builder::Document, Vec<String>), Response>, AdminError> {
if let Some(r) = ensure_builder_access(tenant, user).await {
return Ok(Err(r));
}
let exists = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(tenant.pool())
.await?
.is_some();
if !exists {
return Err(AdminError::NotFound(id));
}
let value: serde_json::Value = serde_json::from_str(schema_str)
.map_err(|e| AdminError::Validation(format!("invalid schema JSON: {e}")))?;
let doc = crate::page_builder::parse_schema(&value)
.map_err(|e| AdminError::Validation(format!("invalid schema document: {e}")))?;
let components = crate::page_builder::model::component_map(tenant.pool()).await?;
let problems = crate::page_builder::validate_schema(&doc, &components);
Ok(Ok((doc, problems)))
}
pub async fn page_type_build_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<FormBuildSubmit>,
) -> Result<Response, AdminError> {
let (doc, problems) =
match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
Ok(v) => v,
Err(resp) => return Ok(resp),
};
let document =
serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
let (level, msg) = if problems.is_empty() {
(MsgLevel::Success, "Draft saved.".to_owned())
} else {
(
MsgLevel::Warning,
format!("Draft saved with warnings: {}", problems.join(" ")),
)
};
redirect_named_with_params_and_message(
"rcms-admin:page-types:build",
&[("id", id.to_string())],
level,
&msg,
&headers,
)
}
pub async fn page_type_publish_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<FormBuildSubmit>,
) -> Result<Response, AdminError> {
let (doc, problems) =
match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
Ok(v) => v,
Err(resp) => return Ok(resp),
};
let document =
serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
if !problems.is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:page-types:build",
&[("id", id.to_string())],
MsgLevel::Error,
&format!("Can't publish — fix these first: {}", problems.join(" ")),
&headers,
);
}
crate::page_builder::model::publish(tenant.pool(), id).await?;
redirect_named_with_params_and_message(
"rcms-admin:page-types:build",
&[("id", id.to_string())],
MsgLevel::Success,
"Schema published — the page editor now uses this structure.",
&headers,
)
}
pub(crate) async fn save_page_builder_values(
pool: &rustango::sql::Pool,
page_type_id: i64,
page_id: i64,
form_map: &std::collections::HashMap<String, String>,
) -> Result<(), rustango::sql::ExecError> {
let Some(row) = crate::page_builder::model::published_for(pool, page_type_id).await? else {
return Ok(());
};
let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
return Ok(());
};
let components = crate::page_builder::model::component_map(pool).await?;
let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
crate::page_builder::values::save_from_form(pool, page_id, &compiled, form_map).await
}
async fn save_type_content(
pool: &rustango::sql::Pool,
page_type: Option<&PageType>,
page_type_id: i64,
page_id: i64,
form_map: &std::collections::HashMap<String, String>,
) -> Result<(), AdminError> {
if let Some(handler) = page_type.and_then(|pt| find_handler(&pt.type_name)) {
let ext_form = sanitized_extension_form(handler.as_ref(), pool, page_id, form_map).await;
handler.save_extension(pool, page_id, &ext_form).await?;
for spec in handler.inline_panels() {
let rows = extract_inline_panel_rows(form_map, &spec);
handler.save_inline_panel(pool, page_id, &spec.name, &rows).await?;
}
}
save_page_builder_values(pool, page_type_id, page_id, form_map).await?;
Ok(())
}
async fn reindex_from_form(
pool: &rustango::sql::Pool,
org_slug: &str,
page_id: i64,
form_map: &std::collections::HashMap<String, String>,
) {
let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
for (key, value) in form_map {
let mut found = crate::reference_index::scan(value, key);
refs.append(&mut found);
}
crate::task_queue::reindex_page(pool, org_slug, page_id, refs).await;
}
#[allow(clippy::too_many_arguments)]
async fn insert_type_fields(
ctx: &mut Context,
tera: &tera::Tera,
pool: &rustango::sql::Pool,
handler: Option<&dyn crate::page_type::PageTypeHandler>,
mut widgets: Vec<crate::widget::Widget>,
page_id: i64,
page_type_id: i64,
held: Option<&std::collections::HashMap<String, String>>,
) {
if let Some(form) = held {
overlay_pending_widgets(&mut widgets, form);
}
for w in &mut widgets {
if matches!(w.kind, crate::widget::WidgetKind::Custom) {
if let Some(reg) = crate::widget::registry::find_custom_widget(&w.custom_name) {
let mut sub = Context::new();
sub.insert("w", &w);
w.custom_html = tera.render(reg.template, &sub).unwrap_or_else(|e| {
tracing::warn!(
target: "rustango_cms::widget",
custom_name = %w.custom_name,
template = reg.template,
error = %e,
"custom widget template render failed",
);
String::new()
});
}
}
}
for w in &mut widgets {
if matches!(w.kind, crate::widget::WidgetKind::Stream) {
w.custom_html = crate::block::admin::render_stream_editor(w, tera);
}
}
ctx.insert("extension_fields", &widgets);
if let Some((body_html, rules_json, upgraded)) =
page_builder_editor_ctx(pool, tera, page_id, page_type_id, held).await
{
ctx.insert("builder_body_html", &body_html);
ctx.insert("builder_rules_json", &rules_json);
ctx.insert("builder_upgraded", &upgraded);
}
let mut inline_panels: Vec<serde_json::Value> = Vec::new();
if let Some(h) = handler {
for spec in h.inline_panels() {
let rows = h
.load_inline_panel(pool, page_id, &spec.name)
.await
.unwrap_or_default();
inline_panels.push(serde_json::json!({
"spec": spec,
"rows": rows,
}));
}
}
ctx.insert("inline_panels", &inline_panels);
}
async fn page_builder_editor_ctx(
pool: &rustango::sql::Pool,
tera: &tera::Tera,
page_id: i64,
page_type_id: i64,
held: Option<&std::collections::HashMap<String, String>>,
) -> Option<(String, String, bool)> {
let row = crate::page_builder::model::published_for(pool, page_type_id)
.await
.ok()??;
let doc = crate::page_builder::parse_schema(&row.document).ok()?;
let components = crate::page_builder::model::component_map(pool)
.await
.unwrap_or_default();
let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
let (mut values, report) =
crate::page_builder::values::load_upgraded(pool, page_id, &compiled)
.await
.unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
if let Some(form) = held {
values = serde_json::Value::Object(crate::page_builder::values::build_values(&compiled, form));
}
let html =
crate::page_builder::values::render_body(&compiled, &values, tera);
let rules: Vec<serde_json::Value> = compiled
.rules
.iter()
.map(|r| serde_json::json!({ "field": r.field, "rule": r.rule }))
.collect();
let rules_json = serde_json::to_string(&rules).unwrap_or_else(|_| "[]".to_owned());
Some((html, rules_json, report.upgraded))
}
pub async fn components_index(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let comps = crate::page_builder::model::all_components(tenant.pool()).await?;
let mut rows = Vec::with_capacity(comps.len());
for c in &comps {
let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug)
.await
.unwrap_or_default();
rows.push(serde_json::json!({
"id": c.id.get().copied(),
"slug": c.slug,
"label": c.label,
"icon": if c.icon.is_empty() { "extension".to_owned() } else { c.icon.clone() },
"description": c.description,
"version": c.version,
"ref_count": refs.len(),
}));
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "components", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("components", &rows);
ctx.insert("new_url", "/cms-admin/components/new");
render_with_csrf(
&state,
&headers,
"rcms_admin/components_list.html",
&mut ctx,
)
}
#[allow(clippy::too_many_arguments)]
async fn render_component_builder(
state: &super::AdminState,
headers: &HeaderMap,
tenant: &Tenant,
user: Option<&rustango::tenancy::auth::User>,
id: Option<i64>,
slug: &str,
label: &str,
icon: &str,
description: &str,
schema_json: &str,
error: Option<&str>,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, tenant, "components", user).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("component_id", &id);
ctx.insert("slug", slug);
ctx.insert("label", label);
ctx.insert("icon", icon);
ctx.insert("description", description);
ctx.insert("schema_json", schema_json);
ctx.insert("is_edit", &id.is_some());
let save_url = match id {
Some(cid) => format!("/cms-admin/components/{cid}/edit"),
None => "/cms-admin/components/new".to_owned(),
};
ctx.insert("save_url", &save_url);
ctx.insert("list_url", "/cms-admin/components");
if let Some(e) = error {
ctx.insert("error", e);
}
render_with_csrf(
state,
headers,
"rcms_admin/component_builder.html",
&mut ctx,
)
}
pub async fn component_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
render_component_builder(
&state,
&headers,
&tenant,
session_user.as_ref(),
None,
"",
"",
"",
"",
"{\"nodes\":[]}",
None,
)
.await
}
pub async fn component_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
.await?
.ok_or(AdminError::NotFound(id))?;
let doc: crate::page_builder::schema::ComponentDoc =
serde_json::from_value(c.document.clone()).unwrap_or_default();
let schema_json =
serde_json::to_string(&serde_json::json!({ "nodes": doc.children })).unwrap_or_default();
render_component_builder(
&state,
&headers,
&tenant,
session_user.as_ref(),
Some(id),
&c.slug,
&c.label,
&c.icon,
&c.description,
&schema_json,
None,
)
.await
}
fn parse_component_doc(
schema_str: &str,
) -> Result<crate::page_builder::schema::ComponentDoc, String> {
let value: serde_json::Value =
serde_json::from_str(schema_str).map_err(|e| format!("invalid schema JSON: {e}"))?;
let doc = crate::page_builder::parse_schema(&value)
.map_err(|e| format!("invalid schema document: {e}"))?;
let cdoc = crate::page_builder::schema::ComponentDoc {
label_format: None,
children: doc.nodes,
};
let problems = crate::page_builder::schema::validate_component(&cdoc);
if problems.is_empty() {
Ok(cdoc)
} else {
Err(problems.join(" "))
}
}
pub async fn component_create(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<FormComponentSubmit>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let slug = crate::forms::schema::slugify_key(&form.slug);
let checked: Result<crate::page_builder::schema::ComponentDoc, String> =
if !crate::forms::schema::is_valid_key(&slug) {
Err(
"Slug is invalid — use letters/digits/underscores, starting with a letter."
.to_owned(),
)
} else if form.label.trim().is_empty() {
Err("Label is required.".to_owned())
} else {
parse_component_doc(&form.schema)
};
let msg: Option<String> = match checked {
Ok(cdoc) => {
let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
match crate::page_builder::model::create_component(
tenant.pool(),
&slug,
form.label.trim(),
form.icon.trim(),
form.description.trim(),
document,
)
.await
{
Ok(_) => {
return redirect_named_with_message(
"rcms-admin:components:index",
MsgLevel::Success,
"Component created.",
&headers,
)
}
Err(_) => Some(format!(
"Could not create — a component with slug `{slug}` may already exist."
)),
}
}
Err(e) => Some(e),
};
render_component_builder(
&state,
&headers,
&tenant,
session_user.as_ref(),
None,
&form.slug,
&form.label,
&form.icon,
&form.description,
&form.schema,
msg.as_deref(),
)
.await
}
pub async fn component_update(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<FormComponentSubmit>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let existing = crate::page_builder::model::component_by_id(tenant.pool(), id)
.await?
.ok_or(AdminError::NotFound(id))?;
if form.label.trim().is_empty() {
return render_component_builder(
&state,
&headers,
&tenant,
session_user.as_ref(),
Some(id),
&existing.slug,
&form.label,
&form.icon,
&form.description,
&form.schema,
Some("Label is required."),
)
.await;
}
let cdoc = match parse_component_doc(&form.schema) {
Ok(d) => d,
Err(e) => {
return render_component_builder(
&state,
&headers,
&tenant,
session_user.as_ref(),
Some(id),
&existing.slug,
&form.label,
&form.icon,
&form.description,
&form.schema,
Some(&e),
)
.await
}
};
let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
crate::page_builder::model::update_component(
tenant.pool(),
id,
form.label.trim(),
form.icon.trim(),
form.description.trim(),
document,
)
.await?;
redirect_named_with_message(
"rcms-admin:components:index",
MsgLevel::Success,
"Component saved — referencing page types pick it up on next open.",
&headers,
)
}
pub async fn component_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
.await?
.ok_or(AdminError::NotFound(id))?;
let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug).await?;
if !refs.is_empty() {
let ids: Vec<i64> = refs.iter().map(|(pt, _)| *pt).collect();
let pts: Vec<PageType> = PageType::objects()
.where_(PageType::id.is_in(ids))
.fetch(tenant.pool())
.await
.unwrap_or_default();
let names: Vec<String> = pts.iter().map(|p| p.verbose_name.clone()).collect();
let listed = if names.is_empty() {
format!("{} page type(s)", refs.len())
} else {
names.join(", ")
};
return redirect_named_with_message(
"rcms-admin:components:index",
MsgLevel::Error,
&format!("Can't delete `{}` — still used by: {listed}.", c.slug),
&headers,
);
}
crate::page_builder::model::delete_component(tenant.pool(), id).await?;
redirect_named_with_message(
"rcms-admin:components:index",
MsgLevel::Success,
"Component deleted.",
&headers,
)
}
pub async fn page_type_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("list_url", "/cms-admin/page-types");
insert_workflow_choices(&mut ctx, tenant.pool()).await;
render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
}
async fn insert_workflow_choices(ctx: &mut Context, pool: &rustango::sql::Pool) {
let names: Vec<String> = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::active.eq(true))
.order_by(&[("name", false)])
.fetch(pool)
.await
.unwrap_or_default()
.into_iter()
.map(|w| w.name)
.collect();
ctx.insert("workflows", &names);
}
fn type_list_json(raw: &str) -> serde_json::Value {
serde_json::Value::Array(
raw.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|s| serde_json::Value::String(s.to_owned()))
.collect(),
)
}
async fn ui_page_type(
pool: &rustango::sql::Pool,
id: i64,
) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
Ok(crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(pool)
.await?
.filter(|t| crate::page_type::find_handler(&t.type_name).is_none()))
}
pub async fn page_type_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
Path(id): Path<i64>,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Some(pt) = ui_page_type(tenant.pool(), id).await? else {
return Err(AdminError::NotFound(id));
};
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("list_url", "/cms-admin/page-types");
ctx.insert("edit_id", &id);
ctx.insert("form_verbose_name", &pt.verbose_name);
ctx.insert("form_type_name", &pt.type_name);
ctx.insert("form_allowed_parents", &pt.allowed_parents().join(", "));
ctx.insert("form_allowed_children", &pt.allowed_children().join(", "));
ctx.insert("form_workflow", &pt.workflow);
insert_workflow_choices(&mut ctx, tenant.pool()).await;
render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
}
pub async fn page_type_update(
tenant: Tenant,
headers: HeaderMap,
Path(id): Path<i64>,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<FormPageTypeCreate>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Some(mut pt) = ui_page_type(tenant.pool(), id).await? else {
return Err(AdminError::NotFound(id));
};
if form.verbose_name.trim().is_empty() {
return Err(AdminError::Validation("Name is required.".to_owned()));
}
pt.verbose_name = form.verbose_name.trim().to_owned();
pt.allowed_parent_types = type_list_json(&form.allowed_parents);
pt.allowed_child_types = type_list_json(&form.allowed_children);
pt.workflow = form.workflow.trim().to_owned();
pt.save_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:page-types",
MsgLevel::Success,
"Page type settings saved.",
&headers,
)
}
pub async fn page_type_create(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<FormPageTypeCreate>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let ident_src = if form.type_name.trim().is_empty() {
form.verbose_name.as_str()
} else {
form.type_name.as_str()
};
let slug = crate::forms::schema::slugify_key(ident_src);
let err: Option<String> = if form.verbose_name.trim().is_empty() {
Some("Name is required.".to_owned())
} else if !crate::forms::schema::is_valid_key(&slug) {
Some(
"Identifier is invalid — use letters/digits/underscores, starting with a letter."
.to_owned(),
)
} else if crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::type_name.eq(slug.clone()))
.first(tenant.pool())
.await?
.is_some()
|| crate::page_type::find_handler(&slug).is_some()
{
Some(format!(
"A page type with identifier `{slug}` already exists."
))
} else {
None
};
if let Some(msg) = err {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("list_url", "/cms-admin/page-types");
ctx.insert("error", &msg);
ctx.insert("form_verbose_name", &form.verbose_name);
ctx.insert("form_type_name", &form.type_name);
ctx.insert("form_allowed_parents", &form.allowed_parents);
ctx.insert("form_allowed_children", &form.allowed_children);
ctx.insert("form_workflow", &form.workflow);
insert_workflow_choices(&mut ctx, tenant.pool()).await;
return render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx);
}
let view_mode = crate::page_view::PageViewMode::parse(&form.view_mode);
let default_template = if view_mode == crate::page_view::PageViewMode::Api {
String::new()
} else {
crate::page_builder::DEFAULT_SCHEMA_TEMPLATE.to_owned()
};
let mut row = crate::page_type_model::PageType {
id: rustango::sql::Auto::Unset,
app_label: "cms_ui".to_owned(),
type_name: slug.clone(),
verbose_name: form.verbose_name.trim().to_owned(),
default_template,
view_mode: view_mode.as_str().to_owned(),
is_creatable: true,
allowed_parent_types: type_list_json(&form.allowed_parents),
allowed_child_types: type_list_json(&form.allowed_children),
workflow: form.workflow.trim().to_owned(),
created_at: rustango::sql::Auto::Unset,
updated_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
let new_id = row.id.get().copied().unwrap_or_default();
let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_builder::model::save_draft(
tenant.pool(),
new_id,
serde_json::json!({ "nodes": [] }),
created_by,
)
.await
.log_warn("empty builder draft not seeded");
redirect_named_with_params_and_message(
"rcms-admin:page-types:build",
&[("id", new_id.to_string())],
MsgLevel::Success,
"Page type created — design its body, then Publish.",
&headers,
)
}
pub async fn page_type_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let pt = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if pt.app_label != "cms_ui" {
return redirect_named_with_message(
"rcms-admin:page-types",
MsgLevel::Error,
"Only UI-created page types can be deleted.",
&headers,
);
}
let page_count = Page::objects()
.where_(Page::page_type_id.eq(id))
.fetch(tenant.pool())
.await
.map(|v| v.len())
.unwrap_or(0);
if page_count > 0 {
return redirect_named_with_message(
"rcms-admin:page-types",
MsgLevel::Error,
"Can't delete — pages still use this type. Delete or move them first.",
&headers,
);
}
for row in crate::page_builder::model::list_versions(tenant.pool(), id)
.await
.unwrap_or_default()
{
row.delete_pool(tenant.pool()).await.log_warn("page-builder schema version not deleted");
}
pt.delete_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:page-types",
MsgLevel::Success,
"Page type deleted.",
&headers,
)
}
fn translation_canonical_html(widget_tag: &str, canonical: &str) -> String {
if widget_tag == "richtext" && !canonical.trim().is_empty() {
crate::markdown::sanitize_html(canonical)
} else {
String::new()
}
}
async fn builder_translation_groups(
tenant: &Tenant,
page_id: i64,
page_type_id: i64,
existing: &std::collections::HashMap<String, String>,
) -> (Vec<serde_json::Value>, std::collections::HashSet<String>) {
let mut paths = std::collections::HashSet::new();
let Ok(Some(row)) =
crate::page_builder::model::published_for(tenant.pool(), page_type_id).await
else {
return (Vec::new(), paths);
};
let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
return (Vec::new(), paths);
};
let components = crate::page_builder::model::component_map(tenant.pool())
.await
.unwrap_or_default();
let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
let (values, _) = crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
.await
.unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
let leaves = crate::page_builder::values::builder_translatable_leaves(&compiled, &values);
let mut groups: Vec<serde_json::Value> = Vec::new();
let mut cur = String::new();
for leaf in &leaves {
paths.insert(leaf.path.clone());
let rowv = serde_json::json!({
"path": leaf.path,
"widget_kind": leaf.widget_kind.as_tag(),
"field_label": leaf.field_label,
"canonical": leaf.canonical_text,
"canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
"value": existing.get(&leaf.path).cloned().unwrap_or_default(),
});
if leaf.block_id != cur {
cur.clone_from(&leaf.block_id);
groups.push(serde_json::json!({
"block_type": leaf.block_type,
"block_label": leaf.block_label,
"block_id": leaf.block_id,
"depth": leaf.depth,
"leaves": [rowv],
}));
} else if let Some(arr) = groups
.last_mut()
.and_then(|g| g.get_mut("leaves"))
.and_then(|v| v.as_array_mut())
{
arr.push(rowv);
}
}
(groups, paths)
}
pub async fn media_bulk_move_collection(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
let target: Option<i64> = form
.iter()
.find(|(k, _)| k == "collection_id")
.and_then(|(_, v)| v.parse::<i64>().ok())
.filter(|id| *id > 0);
let ids: Vec<i64> = form
.iter()
.filter(|(k, _)| k == "ids" || k == "id")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
let kind = form
.iter()
.find(|(k, _)| k == "kind")
.map(|(_, v)| v.clone())
.unwrap_or_else(|| "image".to_owned());
let mut touched = 0;
for id in ids {
if let Some(mut m) = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
{
m.collection_id = target;
m.save_pool(tenant.pool()).await?;
touched += 1;
}
}
let redirect_url = if kind == "document" {
"rcms-admin:documents:list"
} else {
"rcms-admin:media:list"
};
let dest = match target {
Some(id) => format!("to collection #{id}"),
None => "to Uncategorized".to_owned(),
};
redirect_named_with_message_plural(
redirect_url,
MsgLevel::Success,
"Moved {count} item(s) {dest}.",
touched as i64,
&[("count", &touched.to_string()), ("dest", &dest)],
&headers,
)
}
pub async fn collection_permissions_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let collection = crate::media::MediaCollection::objects()
.where_(crate::media::MediaCollection::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let grants: Vec<crate::permissions::CollectionPermission> =
crate::permissions::CollectionPermission::objects()
.where_(crate::permissions::CollectionPermission::collection_id.eq(id))
.fetch(tenant.pool())
.await?;
let granted: std::collections::HashSet<(i64, String)> = grants
.iter()
.map(|g| (g.role_id, g.permission.clone()))
.collect();
let actions: Vec<&str> = crate::permissions::Action::all()
.iter()
.map(|a| a.as_str())
.collect();
let perm_grid: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
let rid = r.id.get().copied().unwrap_or_default();
let row_cells: Vec<serde_json::Value> = actions
.iter()
.map(|a| {
serde_json::json!({
"action": a,
"granted": granted.contains(&(rid, (*a).to_owned())),
})
})
.collect();
serde_json::json!({
"role_id": rid,
"role_name": r.name,
"role_description": r.description,
"cells": row_cells,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("collection_id", &id);
ctx.insert("collection_name", &collection.name);
ctx.insert("perm_actions", &actions);
ctx.insert("perm_grid", &perm_grid);
let restriction = crate::collection_view_restriction::direct_for_collection(tenant.pool(), id)
.await
.unwrap_or_default();
let restriction_kind = restriction
.as_ref()
.map(|r| r.kind.clone())
.unwrap_or_else(|| "none".to_owned());
let restriction_groups: std::collections::HashSet<i64> = restriction
.as_ref()
.map(|r| r.parsed_groups().into_iter().collect())
.unwrap_or_default();
let restriction_has_password = restriction
.as_ref()
.map(|r| !r.password_hash.is_empty())
.unwrap_or(false);
let role_options: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
let rid = r.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": rid,
"name": r.name,
"selected": restriction_groups.contains(&rid),
})
})
.collect();
let restriction_codenames: Vec<String> = restriction
.as_ref()
.map(|r| r.parsed_codenames())
.unwrap_or_default();
let restriction_codenames_str = restriction_codenames.join(",");
let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
.into_iter()
.map(|(codename, label)| {
serde_json::json!({
"codename": codename,
"label": label,
"checked": restriction_codenames.contains(&codename),
})
})
.collect();
ctx.insert("restriction_kind", &restriction_kind);
ctx.insert("restriction_has_password", &restriction_has_password);
ctx.insert("restriction_roles", &role_options);
ctx.insert("restriction_codenames_str", &restriction_codenames_str);
ctx.insert("restriction_codename_choices", &codename_choices);
render_with_csrf(
&state,
&headers,
"rcms_admin/collection_permissions.html",
&mut ctx,
)
}
#[derive(Deserialize)]
pub struct CollectionPrivacyForm {
pub kind: String,
#[serde(default)]
pub password: String,
#[serde(default)]
pub group_ids: String,
#[serde(default)]
pub codenames: String,
}
pub async fn collection_privacy_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<CollectionPrivacyForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let existing =
crate::collection_view_restriction::direct_for_collection(tenant.pool(), id).await?;
if form.kind == "none" {
if let Some(row) = existing {
row.delete_pool(tenant.pool()).await?;
return redirect_named_with_params_and_message(
"rcms-admin:media:collection-permissions",
&[("id", id.to_string())],
MsgLevel::Success,
"Removed view restriction — collection is now public.",
&headers,
);
}
return redirect_named_with_params_and_message(
"rcms-admin:media:collection-permissions",
&[("id", id.to_string())],
MsgLevel::Info,
"No restriction to remove.",
&headers,
);
}
let Some(kind) = crate::collection_view_restriction::RestrictionKind::parse(&form.kind) else {
return Err(AdminError::Validation(format!(
"unknown restriction kind `{}`",
form.kind
)));
};
let password_hash = match kind {
crate::collection_view_restriction::RestrictionKind::Password => {
if form.password.is_empty() {
if let Some(row) = &existing {
if row.kind == kind.as_str() {
row.password_hash.clone()
} else {
return redirect_named_with_params_and_message(
"rcms-admin:media:collection-permissions",
&[("id", id.to_string())],
MsgLevel::Error,
"Password is required when switching the restriction kind to password.",
&headers,
);
}
} else {
return redirect_named_with_params_and_message(
"rcms-admin:media:collection-permissions",
&[("id", id.to_string())],
MsgLevel::Error,
"Password is required for password-protected collections.",
&headers,
);
}
} else {
crate::passwords::hash(&form.password).await
.map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
}
}
_ => String::new(),
};
let group_ids: Vec<i64> = if matches!(
kind,
crate::collection_view_restriction::RestrictionKind::Groups
) {
form.group_ids
.split(',')
.filter_map(|s| s.trim().parse::<i64>().ok())
.collect()
} else {
Vec::new()
};
let group_json = serde_json::json!(group_ids);
let codenames: Vec<String> = if matches!(
kind,
crate::collection_view_restriction::RestrictionKind::Permission
) {
form.codenames
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned)
.collect()
} else {
Vec::new()
};
let codenames_json = serde_json::json!(codenames);
match existing {
Some(mut row) => {
row.kind = kind.as_str().to_owned();
row.password_hash = password_hash;
row.group_ids = group_json;
row.codenames = codenames_json;
row.save_pool(tenant.pool()).await?;
}
None => {
let mut row = crate::collection_view_restriction::CollectionViewRestriction {
id: Auto::Unset,
collection_id: id,
kind: kind.as_str().to_owned(),
password_hash,
group_ids: group_json,
codenames: codenames_json,
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
}
}
redirect_named_with_params_and_message(
"rcms-admin:media:collection-permissions",
&[("id", id.to_string())],
MsgLevel::Success,
"Collection privacy updated. New requests to /__media__/<spec>/<id> will enforce it.",
&headers,
)
}
pub async fn collection_permissions_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(collection_id): Path<i64>,
axum::Json(payload): axum::Json<PagePermissionsPayload>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
.iter()
.map(|a| a.as_str())
.collect();
let want: std::collections::BTreeSet<(i64, String)> = payload
.grants
.iter()
.filter(|g| valid_actions.contains(g.action.as_str()))
.map(|g| (g.role_id, g.action.clone()))
.collect();
let existing: Vec<crate::permissions::CollectionPermission> =
crate::permissions::CollectionPermission::objects()
.where_(crate::permissions::CollectionPermission::collection_id.eq(collection_id))
.fetch(tenant.pool())
.await?;
let have: std::collections::BTreeSet<(i64, String)> = existing
.iter()
.map(|p| (p.role_id, p.permission.clone()))
.collect();
for p in &existing {
let key = (p.role_id, p.permission.clone());
if !want.contains(&key) {
p.clone().delete_pool(tenant.pool()).await?;
}
}
for (role_id, action) in &want {
if !have.contains(&(*role_id, action.clone())) {
let mut row = crate::permissions::CollectionPermission {
id: Auto::Unset,
collection_id,
role_id: *role_id,
permission: action.clone(),
created_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
}
}
Ok(axum::http::StatusCode::NO_CONTENT.into_response())
}
#[derive(Debug, Deserialize)]
pub struct PagePermissionsPayload {
pub grants: Vec<PagePermissionGrant>,
}
#[derive(Debug, Deserialize)]
pub struct PagePermissionGrant {
pub role_id: i64,
pub action: String,
}
pub async fn page_permissions_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(page_id): Path<i64>,
axum::Json(payload): axum::Json<PagePermissionsPayload>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
.iter()
.map(|a| a.as_str())
.collect();
let want: std::collections::BTreeSet<(i64, String)> = payload
.grants
.iter()
.filter(|g| valid_actions.contains(g.action.as_str()))
.map(|g| (g.role_id, g.action.clone()))
.collect();
let existing: Vec<crate::permissions::PagePermission> =
crate::permissions::PagePermission::objects()
.where_(crate::permissions::PagePermission::page_id.eq(page_id))
.fetch(tenant.pool())
.await?;
let have: std::collections::BTreeSet<(i64, String)> = existing
.iter()
.map(|p| (p.role_id, p.permission.clone()))
.collect();
for p in &existing {
let key = (p.role_id, p.permission.clone());
if !want.contains(&key) {
p.clone().delete_pool(tenant.pool()).await?;
}
}
for (role_id, action) in &want {
if !have.contains(&(*role_id, action.clone())) {
let mut row = crate::permissions::PagePermission {
id: Auto::Unset,
page_id,
role_id: *role_id,
permission: action.clone(),
created_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
}
}
Ok(axum::http::StatusCode::NO_CONTENT.into_response())
}
fn render_extra_tabs(
specs: Vec<crate::page_type::TabSpec>,
tera: &std::sync::Arc<tera::Tera>,
base_ctx: &Context,
headers: &HeaderMap,
) -> Vec<serde_json::Value> {
use crate::page_type::TabBody;
specs
.into_iter()
.map(|spec| {
let html = match spec.body {
TabBody::Html(s) => s,
TabBody::Template { path, context } => {
let mut tab_ctx = base_ctx.clone();
for (k, v) in context {
tab_ctx.insert(&k, &v);
}
tera.render(&path, &tab_ctx).unwrap_or_else(|e| {
format!(
r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
<span class="rcms-flash-body"><strong>{label}</strong> {failed} <code>{path}</code>: {e}</span>
</div>"#,
label = tera::escape_html(&super::i18n::tr(headers, "Tab template error:", &[])),
failed = tera::escape_html(&super::i18n::tr(headers, "failed to render", &[])),
path = tera::escape_html(&path),
e = tera::escape_html(&e.to_string()),
)
})
}
TabBody::Widgets(widgets) => {
let mut ctx = Context::new();
ctx.insert("widgets", &widgets);
tera.render("rcms_admin/_widget_group.html", &ctx)
.unwrap_or_else(|e| {
format!(
r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
<span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
</div>"#,
label = tera::escape_html(&super::i18n::tr(headers, "Widget-group tab error:", &[])),
e = tera::escape_html(&e.to_string()),
)
})
}
TabBody::Group { heading, help, layout, widgets } => {
let mut ctx = Context::new();
ctx.insert("widgets", &widgets);
let inner = tera
.render("rcms_admin/_widget_group.html", &ctx)
.unwrap_or_else(|e| {
format!(
r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
<span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
</div>"#,
label = tera::escape_html(&super::i18n::tr(headers, "Panel-group tab error:", &[])),
e = tera::escape_html(&e.to_string()),
)
});
let help_html = if help.is_empty() {
String::new()
} else {
format!(
r#"<p class="rcms-hint rcms-panel-group-help">{}</p>"#,
tera::escape_html(&help),
)
};
format!(
r#"<fieldset class="rcms-panel-group rcms-panel-group--{layout}">
<legend>{heading}</legend>
{help_html}
<div class="rcms-panel-group-body">{inner}</div>
</fieldset>"#,
layout = layout.class_suffix(),
heading = tera::escape_html(&heading),
help_html = help_html,
inner = inner,
)
}
TabBody::Help { content } => {
format!(
r#"<div class="rcms-panel-help">{content}</div>"#,
content = content,
)
}
};
serde_json::json!({
"name": spec.name,
"label": spec.label,
"icon": spec.icon,
"badge": spec.badge,
"html": html,
})
})
.collect()
}
pub async fn admin_page_dispatch(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
) -> Result<Response, AdminError> {
match super::admin_page::find_admin_page(&slug) {
Some(handler) => Ok(handler
.render(super::admin_page::AdminPageCtx {
tera: &state.tera,
tenant: &tenant,
headers: &headers,
user: session_user.as_ref(),
})
.await),
None => Err(AdminError::NotFound(0)),
}
}
pub(crate) async fn add_admin_theme(ctx: &mut Context, pool: &rustango::sql::Pool) {
let mut admin_default: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.where_(crate::theme::Theme::is_admin_default.eq(true))
.fetch(pool)
.await
.unwrap_or_default();
let theme = if let Some(t) = admin_default.pop() {
t
} else {
let mut any: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.where_(crate::theme::Theme::is_default.eq(true))
.fetch(pool)
.await
.unwrap_or_default();
match any.pop() {
Some(t) => t,
None => {
let mut first: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.order_by(&[("name", false)])
.fetch(pool)
.await
.unwrap_or_default();
let Some(t) = first.pop() else {
ctx.insert("theme_css", &String::new());
ctx.insert("theme_slug", &String::new());
ctx.insert("theme_default_mode", &"light");
ctx.insert("theme_font_url", &String::new());
return;
};
t
}
}
};
let theme_id = theme.id.get().copied().unwrap_or_default();
let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
.where_(crate::theme::BrandColor::theme_id.eq(theme_id))
.order_by(&[("sort_order", false)])
.fetch(pool)
.await
.unwrap_or_default();
let css = crate::theme::emit_css(&theme, &brand_colors);
ctx.insert("theme_css", &css);
ctx.insert("theme_slug", &theme.slug);
ctx.insert("theme_name", &theme.name);
ctx.insert("theme_default_mode", &theme.default_mode);
ctx.insert("theme_font_url", &theme.font_url);
}
#[derive(Debug, Deserialize)]
pub struct ListQuery {
#[serde(default)]
pub parent: Option<i64>,
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub r#type: Option<String>,
#[serde(default)]
pub status: Option<String>,
}
pub async fn page_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<ListQuery>,
) -> Result<Response, AdminError> {
match crate::page::run_schedule_sweep_with_mailer(
tenant.pool(),
state.mailer.as_deref(),
&state.mailer_from,
&tenant.org.slug,
)
.await
{
Ok(result) if !result.changed_urls.is_empty() => {
crate::task_queue::purge_urls(
state.cache_invalidator.clone(),
tenant.org.slug.clone(),
result.changed_urls,
)
.await;
}
Ok(_) => {}
Err(e) => tracing::warn!(target: "rustango_cms::admin", error = %e, "schedule sweep failed"),
}
let all_pages: Vec<Page> = Page::objects()
.order_by(&[("path", false), ("sort_order", false)])
.fetch(tenant.pool())
.await?;
let by_id: std::collections::HashMap<i64, &Page> = all_pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let parent_page: Option<&Page> = q.parent.and_then(|pid| by_id.get(&pid).copied());
let mut breadcrumbs: Vec<serde_json::Value> = Vec::new();
if let Some(mut cur) = parent_page {
breadcrumbs.push(serde_json::json!({
"id": cur.id.get().copied(),
"title": cur.title.clone(),
}));
while let Some(ppid) = cur.parent_id {
if let Some(p) = by_id.get(&ppid).copied() {
breadcrumbs.push(serde_json::json!({
"id": p.id.get().copied(),
"title": p.title.clone(),
}));
cur = p;
} else {
break;
}
}
breadcrumbs.reverse();
}
let search_query =
q.q.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let status_filter = q
.status
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let type_filter_slug = q
.r#type
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let viewer_user_id: Option<i64> = session_user
.as_ref()
.filter(|u| u.active)
.and_then(|u| u.id.get().copied());
let viewer_is_superuser = session_user.as_ref().is_some_and(|u| u.is_superuser);
let permission_filter_enabled = viewer_user_id.is_some() && !viewer_is_superuser;
let viewable_ids: Option<std::collections::HashSet<i64>> = match viewer_user_id {
Some(uid) if permission_filter_enabled => {
let pages: Vec<(i64, Option<i64>)> = all_pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p.parent_id)))
.collect();
Some(
crate::permissions::viewable_page_ids(tenant.pool(), uid, &pages)
.await
.unwrap_or_default(),
)
}
_ => None,
};
let fts_rank: Option<std::collections::HashMap<i64, usize>> = match search_query.as_deref() {
Some(q) => crate::search::search_page_ids_all_statuses(tenant.pool(), q, 1000)
.await
.map(|ids| ids.iter().enumerate().map(|(i, id)| (*id, i)).collect()),
None => None,
};
let visible: Vec<&Page> = if search_query.is_some()
|| status_filter.is_some()
|| type_filter_slug.is_some()
{
let q_lower = search_query.as_deref().map(str::to_lowercase);
let prefetch_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
let type_id_by_slug: std::collections::HashMap<String, i64> = prefetch_types
.iter()
.filter_map(|t| t.id.get().copied().map(|id| (t.type_name.clone(), id)))
.collect();
let type_id_filter = type_filter_slug
.as_deref()
.and_then(|s| type_id_by_slug.get(s).copied());
all_pages
.iter()
.filter(|p| {
let matches_search = match &q_lower {
None => true,
Some(needle) => {
fts_rank.as_ref().is_some_and(|rank| {
p.id.get().copied().is_some_and(|id| rank.contains_key(&id))
}) || p.title.to_lowercase().contains(needle)
|| p.slug.to_lowercase().contains(needle)
|| p.url_path.to_lowercase().contains(needle)
}
};
let matches_status = match &status_filter {
None => true,
Some(s) => p.status == *s,
};
let matches_type = match type_id_filter {
None => true,
Some(id) => p.page_type_id == id,
};
matches_search && matches_status && matches_type
})
.collect()
} else {
all_pages
.iter()
.filter(|p| p.parent_id == q.parent)
.collect()
};
let visible_before_permission_filter = visible.len();
let visible: Vec<&Page> = match &viewable_ids {
None => visible,
Some(set) => visible
.into_iter()
.filter(|p| p.id.get().copied().is_some_and(|id| set.contains(&id)))
.collect(),
};
let visible: Vec<&Page> = if let Some(rank) = &fts_rank {
let mut v = visible;
v.sort_by_key(|p| {
p.id.get()
.copied()
.and_then(|id| rank.get(&id).copied())
.unwrap_or(usize::MAX)
});
v
} else {
visible
};
let is_search_mode =
search_query.is_some() || status_filter.is_some() || type_filter_slug.is_some();
let empty_filtered = is_search_mode && visible.is_empty();
let empty_hidden_by_perms = !is_search_mode
&& visible.is_empty()
&& visible_before_permission_filter > 0
&& permission_filter_enabled;
let mut child_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for p in &all_pages {
if let Some(ppid) = p.parent_id {
*child_counts.entry(ppid).or_insert(0) += 1;
}
}
let types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
let type_map: std::collections::HashMap<i64, String> = types
.iter()
.filter_map(|t| t.id.get().copied().map(|id| (id, t.verbose_name.clone())))
.collect();
let live_urls = build_live_url_map(&all_pages);
let ancestors_for = |p: &Page| -> Vec<serde_json::Value> {
let mut chain: Vec<serde_json::Value> = Vec::new();
let mut cur_parent = p.parent_id;
while let Some(pid) = cur_parent {
match by_id.get(&pid).copied() {
Some(ancestor) => {
chain.push(serde_json::json!({
"id": ancestor.id.get().copied(),
"title": ancestor.title.clone(),
}));
cur_parent = ancestor.parent_id;
}
None => break,
}
}
chain.reverse();
chain
};
let rows: Vec<serde_json::Value> = visible
.iter()
.map(|p| {
let id = p.id.get().copied();
let ancestors = if is_search_mode {
ancestors_for(p)
} else {
Vec::new()
};
serde_json::json!({
"id": id,
"title": p.title,
"slug": p.slug,
"path": p.path,
"url_path": p.url_path,
"status": p.status,
"page_type_id": p.page_type_id,
"go_live_at": p.go_live_at,
"expire_at": p.expire_at,
"updated_at": p.updated_at.get().copied(),
"published_at": p.published_at,
"locale_variant_of": p.locale_variant_of,
"alias_of": p.alias_of,
"child_count": id.and_then(|i| child_counts.get(&i).copied()).unwrap_or(0),
"ancestors": ancestors,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("type_map", &type_map);
ctx.insert("creatable_types", &allowed_root_types(&types));
ctx.insert("live_urls", &live_urls);
ctx.insert("breadcrumbs", &breadcrumbs);
ctx.insert("parent_id", &q.parent);
ctx.insert("parent_title", &parent_page.map(|p| p.title.clone()));
ctx.insert("search_query", &search_query);
ctx.insert("status_filter", &status_filter);
ctx.insert("type_filter", &type_filter_slug);
ctx.insert("is_search_mode", &is_search_mode);
ctx.insert("empty_filtered", &empty_filtered);
ctx.insert("empty_hidden_by_perms", &empty_hidden_by_perms);
let mut type_slugs: Vec<(String, String)> = types
.iter()
.map(|t| (t.type_name.clone(), t.verbose_name.clone()))
.collect();
type_slugs.sort_by(|a, b| a.1.cmp(&b.1));
ctx.insert("type_choices", &type_slugs);
let move_choices: Vec<serde_json::Value> = all_pages
.iter()
.map(|p| {
let indent = "—".repeat(p.depth.max(1) as usize - 1);
let label = if indent.is_empty() {
p.title.clone()
} else {
format!("{indent} {}", p.title)
};
serde_json::json!({
"id": p.id.get().copied(),
"label": label,
"path": p.path.clone(),
})
})
.collect();
ctx.insert("move_choices", &move_choices);
ctx.insert(
"plugin_page_listing_buttons",
&crate::hooks::page_listing_buttons_raw(),
);
let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_page")
.into_iter()
.map(|a| {
serde_json::json!({
"key": a.key,
"label": a.label,
"icon": a.icon,
"danger": a.danger,
"confirm_message": a.confirm_message,
"action_url": a.action_url,
})
})
.collect();
ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
let copy_locales: Vec<Locale> = Locale::objects()
.where_(Locale::active.eq(true))
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.filter(|l| !l.is_default)
.collect();
ctx.insert("copy_locales", ©_locales);
render_with_csrf(&state, &headers, "rcms_admin/page_list.html", &mut ctx)
}
fn extract_inline_panel_rows(
form: &std::collections::HashMap<String, String>,
spec: &crate::page_type::InlinePanelSpec,
) -> Vec<serde_json::Map<String, serde_json::Value>> {
let mut by_idx: std::collections::BTreeMap<usize, serde_json::Map<String, serde_json::Value>> =
std::collections::BTreeMap::new();
let prefix = format!("inline__{}__", spec.name);
for (key, value) in form {
let Some(rest) = key.strip_prefix(&prefix) else {
continue;
};
let Some((idx_str, field_name)) = rest.split_once("__") else {
continue;
};
let Ok(idx) = idx_str.parse::<usize>() else {
continue;
};
if field_name == "__deleted" && value == "1" {
by_idx.remove(&idx);
let mut row = serde_json::Map::new();
row.insert("__deleted".to_owned(), serde_json::Value::Bool(true));
by_idx.insert(idx, row);
continue;
}
if !spec.fields.iter().any(|f| f.name == field_name) {
continue;
}
let row = by_idx.entry(idx).or_default();
if row.contains_key("__deleted") {
continue;
}
row.insert(
field_name.to_owned(),
serde_json::Value::String(value.clone()),
);
}
by_idx
.into_iter()
.filter_map(|(_, row)| {
if row.contains_key("__deleted") {
None
} else {
Some(row)
}
})
.collect()
}
fn build_live_url_map(pages: &[Page]) -> std::collections::HashMap<String, String> {
let mut by_id: std::collections::HashMap<String, String> = std::collections::HashMap::new();
for p in pages {
let Some(pid) = p.id.get().copied() else {
continue;
};
let url = match p.parent_id {
None => {
if p.slug.is_empty() {
"/".to_owned()
} else {
format!("/{}", p.slug)
}
}
Some(parent_id) => {
let parent_url = by_id
.get(&parent_id.to_string())
.cloned()
.unwrap_or_else(|| "/".to_owned());
if p.slug.is_empty() {
parent_url
} else if parent_url == "/" {
format!("/{}", p.slug)
} else {
format!("{}/{}", parent_url, p.slug)
}
}
};
by_id.insert(pid.to_string(), url);
}
by_id
}
#[derive(Debug, Deserialize)]
pub struct NewQuery {
#[serde(default)]
pub parent: Option<i64>,
#[serde(default, rename = "type")]
pub type_id: Option<i64>,
}
pub async fn page_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<NewQuery>,
) -> Result<Response, AdminError> {
let all_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
let (parent, allowed_types) = match q.parent {
Some(pid) => {
let parent_row = Page::objects()
.where_(Page::id.eq(pid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(pid))?;
let allowed = allowed_children_for(&parent_row, &all_types);
(Some(parent_row), allowed)
}
None => (None, allowed_root_types(&all_types)),
};
let Some(type_id) = q.type_id else {
#[derive(serde::Serialize)]
struct PickerType<'a> {
id: i64,
type_name: &'a str,
verbose_name: &'a str,
icon: Option<&'static str>,
description: Option<&'static str>,
}
let allowed_enriched: Vec<PickerType<'_>> = allowed_types
.iter()
.map(|t| {
let handler = find_handler(&t.type_name);
PickerType {
id: t.id.get().copied().unwrap_or_default(),
type_name: t.type_name.as_str(),
verbose_name: t.verbose_name.as_str(),
icon: handler.as_ref().and_then(|h| h.icon()),
description: handler.as_ref().and_then(|h| h.description()),
}
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("parent", &parent);
ctx.insert("allowed_types", &allowed_enriched);
return render_with_csrf(
&state,
&headers,
"rcms_admin/page_type_picker.html",
&mut ctx,
);
};
let chosen_type = allowed_types
.iter()
.find(|t| t.id.get().copied() == Some(type_id))
.cloned()
.ok_or_else(|| {
AdminError::Validation(format!(
"page type {type_id} is not creatable under the chosen parent"
))
})?;
let mut page_seed = empty_page_form_values();
if let Some(obj) = page_seed.as_object_mut() {
obj.insert("page_type_id".to_owned(), serde_json::json!(type_id));
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert("parent", &parent);
ctx.insert("chosen_type", &chosen_type);
ctx.insert("page", &page_seed);
let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
&& crate::workflow::review_workflow_for_type(tenant.pool(), type_id).await?.is_some();
ctx.insert("review_required", &review_required);
ctx.insert("extra_tabs", &Vec::<crate::page_type::TabSpec>::new());
let handler = find_handler(&chosen_type.type_name);
let widgets = match &handler {
Some(h) => h.widgets(tenant.pool(), 0).await.unwrap_or_default(),
None => Vec::new(),
};
insert_type_fields(&mut ctx, &state.tera, tenant.pool(), handler.as_deref(), widgets, 0, type_id, None).await;
ctx.insert(
"picker_options",
&crate::block::admin::picker_options(&state.tera),
);
ctx.insert("page_tags", &Vec::<String>::new());
ctx.insert("page_tags_csv", "");
ctx.insert("all_tags", &Vec::<serde_json::Value>::new());
insert_category_choices(&mut ctx, tenant.pool(), None).await;
render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
}
pub(crate) fn slugify(raw: &str) -> String {
let mut out = String::with_capacity(raw.len());
let mut last_hyphen = true;
for ch in raw.chars() {
let c = ch.to_ascii_lowercase();
if c.is_ascii_alphanumeric() {
out.push(c);
last_hyphen = false;
} else if !last_hyphen {
out.push('-');
last_hyphen = true;
}
}
while out.ends_with('-') {
out.pop();
}
if out.len() > 60 {
out.truncate(60);
while out.ends_with('-') {
out.pop();
}
}
out
}
pub(crate) async fn dedup_slug_under_parent(
pool: &rustango::sql::Pool,
parent_id: Option<i64>,
candidate: &str,
) -> Result<String, AdminError> {
let taken: std::collections::HashSet<String> = {
let q = Page::objects();
let rows = match parent_id {
Some(pid) => q.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
None => q.where_(Page::parent_id.is_null()).fetch(pool).await?,
};
rows.into_iter().map(|p| p.slug).collect()
};
if !taken.contains(candidate) {
return Ok(candidate.to_owned());
}
let with_copy = format!("{candidate}-copy");
if !taken.contains(&with_copy) {
return Ok(with_copy);
}
for n in 2..50_u32 {
let trial = format!("{candidate}-copy-{n}");
if !taken.contains(&trial) {
return Ok(trial);
}
}
Err(AdminError::Validation(format!(
"could not find a free slug for “{candidate}” after 50 -copy attempts"
)))
}
async fn front_page_taken(pool: &rustango::sql::Pool) -> Result<bool, AdminError> {
use rustango::sql::CounterPool as _;
let n = Page::objects()
.where_(Page::parent_id.is_null())
.where_(Page::slug.eq(String::new()))
.count(pool)
.await?;
Ok(n > 0)
}
async fn insert_category_choices(ctx: &mut tera::Context, pool: &rustango::sql::Pool, page_id: Option<i64>) {
let (groups, checked) = match crate::category::assign::editor_groups(pool, page_id).await {
Ok(v) => v,
Err(e) => {
tracing::warn!(error = %e, "category choices not loaded; the field is hidden");
Default::default()
}
};
ctx.insert("category_groups", &groups);
ctx.insert("page_category_ids", &checked);
}
pub async fn page_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form_map): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let form: PageForm = serde_urlencoded::from_str(
&serde_urlencoded::to_string(&form_map).unwrap_or_default(),
)
.map_err(|e| AdminError::Validation(format!("page form: {e}")))?;
if form.parent_id.is_none() {
let types = PageType::objects().fetch(tenant.pool()).await?;
if let Some(row) = types
.iter()
.find(|t| t.id.get().copied() == Some(form.page_type_id))
{
let parents = row.allowed_parents();
if !parents.is_empty() {
return Err(AdminError::Validation(format!(
"`{}` can't be a root page — it may only be created under: {}",
row.type_name,
parents.join(", ")
)));
}
}
}
let mut effective_slug = if !form.slug.trim().is_empty() {
slugify(&form.slug)
} else if form.parent_id.is_none() && !front_page_taken(tenant.pool()).await? {
String::new()
} else {
slugify(&form.title)
};
if !effective_slug.is_empty() {
effective_slug =
dedup_slug_under_parent(tenant.pool(), form.parent_id, &effective_slug).await?;
}
let intended = derive_scheduled_status(form.parsed_status().as_str(), form.parsed_go_live_at());
let mut held_back: Option<String> = None;
if let Some(user) = session_user.as_ref().filter(|u| !u.is_superuser) {
if crate::page::PageStatus::str_goes_live(crate::page::PageStatus::Draft.as_str(), &intended) {
let uid = user.id.get().copied().unwrap_or_default();
let req = super::route_perms::Requirement {
codename: "cms_page.publish".to_owned(),
page: form.parent_id.map(|pid| (pid, crate::permissions::Action::Publish)),
};
if let Some(wf) = crate::workflow::review_workflow_for_type(tenant.pool(), form.page_type_id).await? {
held_back = Some(super::i18n::tr(
&headers,
"Saved as a draft: pages of this type go live after review (“{workflow}”). Click Submit for review.",
&[("workflow", wf.name.as_str())],
));
} else if !super::route_perms::allows_id(tenant.pool(), uid, false, &req).await {
held_back = Some(super::i18n::tr(
&headers,
"Saved as a draft: you don't have permission to publish pages here.",
&[],
));
}
}
}
let new = NewPage::new(
form.page_type_id,
form.title.clone(),
effective_slug.clone(),
)
.with_status(if held_back.is_some() { crate::page::PageStatus::Draft } else { form.parsed_status() })
.with_seo(form.seo_title.clone(), form.seo_description.clone());
let mut page = match form.parent_id {
Some(pid) => {
let parent = Page::objects()
.where_(Page::id.eq(pid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(pid))?;
Page::create_child(&tenant, &parent, new).await?
}
None => Page::create_root(&tenant, new).await?,
};
page.robots_index = form.parsed_robots_index();
page.sitemap_priority = form.parsed_sitemap_priority();
page.theme_id = form.theme_id.flatten();
page.go_live_at = if held_back.is_some() { None } else { form.parsed_go_live_at() };
page.expire_at = form.parsed_expire_at();
page.status = derive_scheduled_status(&page.status, page.go_live_at);
page.show_in_menus = form.parsed_show_in_menus();
page.preview_path = form.preview_path.trim().to_owned();
page.template_override = form.template_override.trim().to_owned();
page.og_title = form.og_title.clone();
page.og_description = form.og_description.clone();
page.og_image_media_id = form.og_image_media_id;
if let Some(tc) = form.twitter_card.as_deref() {
if matches!(tc, "summary" | "summary_large_image") {
page.twitter_card = tc.to_owned();
}
}
page.save_pool(tenant.pool()).await?;
let new_id = page.id.get().copied().unwrap_or_default();
if let Some(raw) = form.tags.as_deref().filter(|t| !t.trim().is_empty()) {
let names: Vec<String> = raw.split(',').map(str::to_owned).collect();
crate::page_tag::replace_tags(tenant.pool(), new_id, &names).await?;
}
crate::category::assign::save_from_form(tenant.pool(), new_id, form.categories.as_deref()).await?;
let page_type: Option<PageType> = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.first(tenant.pool())
.await?;
save_type_content(tenant.pool(), page_type.as_ref(), page.page_type_id, new_id, &form_map).await?;
crate::revision::capture(tenant.pool(), &page, None)
.await
.log_warn("revision not captured; the history has a gap");
reindex_from_form(tenant.pool(), &tenant.org.slug, new_id, &form_map).await;
let message = held_back.unwrap_or_else(|| {
super::i18n::tr(&headers, "Created page “{title}”.", &[("title", page.title.as_str())])
});
redirect_after_page_save(
&form.action,
page.id.get().copied().unwrap_or_default(),
page.parent_id,
&message,
&headers,
)
}
#[derive(Debug, Deserialize, Default)]
pub struct EditQuery {
#[serde(default)]
pub locale: Option<String>,
}
pub async fn page_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(source_id) = page.alias_of {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", source_id.to_string())],
MsgLevel::Info,
"Editing the source — alias “{title}” shares content with this row.",
&[("title", page.title.as_str())],
&headers,
);
}
let locales: Vec<Locale> = Locale::objects()
.where_(Locale::active.eq(true))
.order_by(&[("is_default", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let editing_locale: Option<Locale> = match q.locale.as_deref() {
Some(code) if !code.is_empty() => locales.iter().find(|l| l.code == code).cloned(),
_ => None,
};
let translation_mode = editing_locale
.as_ref()
.map(|l| !l.is_default)
.unwrap_or(false);
let pending = crate::pending_change::for_page(tenant.pool(), id).await?;
let existing_translations = if translation_mode {
let lid = editing_locale
.as_ref()
.and_then(|l| l.id.get().copied())
.unwrap_or(0);
crate::translation::fetch_for(tenant.pool(), id, lid)
.await
.unwrap_or_default()
} else {
std::collections::HashMap::new()
};
let themes_for_picker: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let chosen_type: PageType = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.first(tenant.pool())
.await?
.ok_or_else(|| {
AdminError::Validation(format!(
"page_type_id {} on cms_page row has no cms_page_type row",
page.page_type_id
))
})?;
let ancestors = page.ancestors(tenant.pool()).await.unwrap_or_default();
let mut segments: Vec<&str> = ancestors
.iter()
.filter(|a| !a.slug.is_empty())
.map(|a| a.slug.as_str())
.collect();
if !page.slug.is_empty() {
segments.push(page.slug.as_str());
}
let live_url = if segments.is_empty() {
"/".to_owned()
} else {
format!("/{}", segments.join("/"))
};
let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
.where_(crate::revision::Revision::page_id.eq(id))
.order_by(&[("sequence", true)]) .limit(20)
.fetch(tenant.pool())
.await?;
let core_fields = ["title", "seo_title", "seo_description"];
let core_translations: std::collections::HashMap<String, String> = core_fields
.iter()
.map(|f| {
(
(*f).to_owned(),
existing_translations.get(*f).cloned().unwrap_or_default(),
)
})
.collect();
let mut extra_translations: Vec<(String, String)> = existing_translations
.iter()
.filter(|(k, _)| !core_fields.contains(&k.as_str()))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
extra_translations.sort_by(|a, b| a.0.cmp(&b.0));
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert("parent", &Option::<Page>::None);
ctx.insert("chosen_type", &chosen_type);
ctx.insert("page", &page);
ctx.insert("live_url", &live_url);
let site_preview_base = match crate::preview_url::configured_base(tenant.pool()).await {
Ok(base) => base,
Err(e) => {
tracing::warn!(
target: "rustango_cms::admin",
error = %e,
"headless preview setting lookup failed",
);
None
}
};
let headless_preview_url = if site_preview_base.is_some() || !page.preview_path.trim().is_empty()
{
let token = crate::preview_token::mint(
&tenant.org.slug,
id,
chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS,
);
crate::preview_url::for_page(
site_preview_base.as_deref(),
&page.preview_path,
&token,
id,
&page.url_path,
)
} else {
None
};
ctx.insert("headless_preview_url", &headless_preview_url);
let ancestor_crumbs: Vec<serde_json::Value> = ancestors
.iter()
.map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title }))
.collect();
ctx.insert("ancestors", &ancestor_crumbs);
ctx.insert(
"parent_crumb",
&ancestors
.last()
.map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title })),
);
ctx.insert(
"plugin_page_action_menu_items",
&crate::hooks::page_action_menu_items(id),
);
ctx.insert(
"plugin_page_header_buttons",
&crate::hooks::page_header_buttons(id),
);
let is_subscribed = match session_user.as_ref().and_then(|u| u.id.get().copied()) {
Some(uid) => crate::page_subscription::is_subscribed(tenant.pool(), id, uid)
.await
.unwrap_or(false),
None => false,
};
ctx.insert("is_subscribed", &is_subscribed);
let page_tags: Vec<String> = crate::page_tag::tags_for_page(tenant.pool(), id)
.await
.unwrap_or_default()
.into_iter()
.map(|t| t.name)
.collect();
let page_tags_csv = page_tags.join(", ");
ctx.insert("page_tags", &page_tags);
ctx.insert("page_tags_csv", &page_tags_csv);
let all_tags = crate::page_tag::all_tags(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.map(|(name, count)| serde_json::json!({ "name": name, "count": count }))
.collect::<Vec<_>>();
ctx.insert("all_tags", &all_tags);
insert_category_choices(&mut ctx, tenant.pool(), Some(id)).await;
let usage =
crate::reference_index::usage_summary(tenant.pool(), crate::reference_index::KIND_PAGE, id)
.await;
ctx.insert("usage", &usage);
let a11y_violations = crate::a11y::check_page(&page, None);
let (a11y_errors, a11y_warnings, a11y_infos) = crate::a11y::count_by_severity(&a11y_violations);
ctx.insert("a11y_violations", &a11y_violations);
ctx.insert("a11y_errors", &a11y_errors);
ctx.insert("a11y_warnings", &a11y_warnings);
ctx.insert("a11y_infos", &a11y_infos);
let mut content_findings = crate::content_checks::run_all(&page);
if content_findings.iter().any(|f| f.code == "missing_og_image")
&& crate::meta_tags::fallback_share_image(tenant.pool(), &page).await.is_some()
{
content_findings.retain(|f| f.code != "missing_og_image");
}
let (content_errors, content_warnings, content_infos) =
crate::content_checks::count_by_severity(&content_findings);
ctx.insert("content_findings", &content_findings);
ctx.insert("content_errors", &content_errors);
ctx.insert("content_warnings", &content_warnings);
ctx.insert("content_infos", &content_infos);
ctx.insert("revisions", &revisions);
let log_entries = crate::page_log::for_page(tenant.pool(), id, Some(100))
.await
.unwrap_or_default();
let log_user_ids: std::collections::BTreeSet<i64> =
log_entries.iter().filter_map(|e| e.actor_id).collect();
let log_users: std::collections::HashMap<i64, String> = if log_user_ids.is_empty() {
std::collections::HashMap::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(
rustango::tenancy::auth::User::id
.is_in(log_user_ids.into_iter().collect::<Vec<_>>()),
)
.fetch(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect()
};
let log_view: Vec<serde_json::Value> = log_entries
.iter()
.map(|e| {
serde_json::json!({
"id": e.id.get().copied(),
"action": e.action,
"actor_id": e.actor_id,
"actor_username": e.actor_id.and_then(|uid| log_users.get(&uid).cloned()),
"message": e.message,
"created_at": e.created_at.get().copied(),
})
})
.collect();
ctx.insert("page_log", &log_view);
ctx.insert("locales", &locales);
ctx.insert("editing_locale", &editing_locale);
ctx.insert("translation_mode", &translation_mode);
ctx.insert("core_translations", &core_translations);
ctx.insert("extra_translations", &extra_translations);
ctx.insert("themes_for_picker", &themes_for_picker);
let resolved_handler: Option<Box<dyn crate::page_type::PageTypeHandler>> =
find_handler(&chosen_type.type_name);
let preview_mode = {
let kind = crate::page_view::kind_for(&chosen_type);
let template_renders = !chosen_type.default_template.trim().is_empty()
&& state
.tera
.get_template_names()
.any(|n| n == chosen_type.default_template);
if kind.serves_json() && !kind.serves_html() {
"json"
} else if template_renders {
"html"
} else {
"none"
}
};
ctx.insert("preview_mode", preview_mode);
let raw_widgets: Vec<crate::widget::Widget> = match &resolved_handler {
Some(h) => h.widgets(tenant.pool(), id).await.unwrap_or_default(),
None => Vec::new(),
};
let content_metrics =
crate::metrics::analyze(&crate::metrics::collect_widget_text(&raw_widgets));
ctx.insert("content_metrics", &content_metrics);
if translation_mode {
let mut stream_translations: Vec<serde_json::Value> = Vec::new();
let mut leaf_paths: std::collections::HashSet<String> = std::collections::HashSet::new();
for w in &raw_widgets {
if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
continue;
}
let base: serde_json::Value = serde_json::from_str(&w.value)
.unwrap_or_else(|_| serde_json::Value::Array(Vec::new()));
let leaves = crate::block::translate::collect_translatable_leaves(&w.name, &base);
if leaves.is_empty() {
continue;
}
let mut groups: Vec<serde_json::Value> = Vec::new();
let mut cur_id = String::new();
for leaf in &leaves {
leaf_paths.insert(leaf.path.clone());
let row = serde_json::json!({
"path": leaf.path,
"widget_kind": leaf.widget_kind.as_tag(),
"field_label": leaf.field_label,
"canonical": leaf.canonical_text,
"canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
"value": existing_translations.get(&leaf.path).cloned().unwrap_or_default(),
});
if leaf.block_id != cur_id {
cur_id.clone_from(&leaf.block_id);
groups.push(serde_json::json!({
"block_type": leaf.block_type,
"block_label": leaf.block_label,
"block_id": leaf.block_id,
"depth": leaf.depth,
"leaves": [row],
}));
} else if let Some(arr) = groups
.last_mut()
.and_then(|g| g.get_mut("leaves"))
.and_then(|v| v.as_array_mut())
{
arr.push(row);
}
}
stream_translations.push(serde_json::json!({ "field": w.name, "label": w.label, "groups": groups }));
}
let field_rows: Vec<serde_json::Value> = raw_widgets
.iter()
.filter(|w| {
use crate::widget::WidgetKind as K;
matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
&& !w.name.starts_with(crate::page_builder::compile::FIELD_PREFIX)
})
.map(|w| {
leaf_paths.insert(w.name.clone());
serde_json::json!({
"path": w.name,
"widget_kind": w.kind.as_tag(),
"field_label": w.label,
"canonical": w.value,
"canonical_html": translation_canonical_html(w.kind.as_tag(), &w.value),
"value": existing_translations.get(&w.name).cloned().unwrap_or_default(),
})
})
.collect();
if !field_rows.is_empty() {
stream_translations.insert(
0,
serde_json::json!({
"field": "fields",
"label": super::i18n::tr(&headers, "Fields", &[]),
"groups": [{
"block_type": "fields",
"block_label": "",
"block_id": "fields",
"depth": 0,
"leaves": field_rows,
}],
}),
);
}
let (builder_groups, builder_paths) =
builder_translation_groups(&tenant, id, page.page_type_id, &existing_translations)
.await;
if !builder_groups.is_empty() {
leaf_paths.extend(builder_paths);
stream_translations
.push(serde_json::json!({
"field": "builder",
"label": super::i18n::tr(&headers, "Fields", &[]),
"groups": builder_groups,
}));
}
extra_translations.retain(|(k, _)| !leaf_paths.contains(k));
ctx.insert("stream_translations", &stream_translations);
ctx.insert("extra_translations", &extra_translations);
}
let display_fields: Vec<crate::page_type::DisplayField> = match &resolved_handler {
Some(h) => h
.display_fields(tenant.pool(), id)
.await
.unwrap_or_default(),
None => Vec::new(),
};
ctx.insert("display_fields", &display_fields);
let mut raw_extra_tabs: Vec<crate::page_type::TabSpec> = match &resolved_handler {
Some(h) => h.extra_tabs(tenant.pool(), id).await.unwrap_or_default(),
None => Vec::new(),
};
let all_roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
{
let grants: Vec<crate::permissions::PagePermission> =
crate::permissions::PagePermission::objects()
.where_(crate::permissions::PagePermission::page_id.eq(id))
.fetch(tenant.pool())
.await
.unwrap_or_default();
let granted: std::collections::HashSet<(i64, String)> = grants
.iter()
.map(|g| (g.role_id, g.permission.clone()))
.collect();
let actions: Vec<&str> = crate::permissions::Action::all()
.iter()
.map(|a| a.as_str())
.collect();
let perm_grid: Vec<serde_json::Value> = all_roles
.iter()
.map(|r| {
let rid = r.id.get().copied().unwrap_or_default();
let row_cells: Vec<serde_json::Value> = actions
.iter()
.map(|a| {
serde_json::json!({
"action": a,
"granted": granted.contains(&(rid, (*a).to_owned())),
})
})
.collect();
serde_json::json!({
"role_id": rid,
"role_name": r.name,
"role_description": r.description,
"cells": row_cells,
})
})
.collect();
let perm_tab = crate::page_type::TabSpec::template(
"permissions",
"Permissions",
"rcms_admin/_permissions_tab.html",
)
.with_icon("admin_panel_settings")
.with_context_value(
"perm_actions",
serde_json::to_value(&actions).unwrap_or_default(),
)
.with_context_value(
"perm_grid",
serde_json::to_value(&perm_grid).unwrap_or_default(),
)
.with_context_value("perm_page_id", serde_json::Value::Number(id.into()));
raw_extra_tabs.insert(0, perm_tab);
}
let extra_tabs: Vec<serde_json::Value> =
render_extra_tabs(raw_extra_tabs, &state.tera, &ctx, &headers);
ctx.insert("extra_tabs", &extra_tabs);
let pending_form = pending.as_ref().filter(|_| !translation_mode).map(crate::pending_change::PendingChange::form_map);
insert_type_fields(
&mut ctx,
&state.tera,
tenant.pool(),
resolved_handler.as_deref(),
raw_widgets,
id,
page.page_type_id,
pending_form.as_ref(),
)
.await;
ctx.insert(
"picker_options",
&crate::block::admin::picker_options(&state.tera),
);
let mut lock_banner: Option<serde_json::Value> = None;
let mut lock_owned_by_me = false;
let reviewing_elsewhere = match session_user.as_ref() {
Some(u) => read_only_under_review(tenant.pool(), id, u).await?,
None => false,
};
if let Some(viewer_id) = session_user
.as_ref()
.and_then(|u| u.id.get().copied())
.filter(|_| !reviewing_elsewhere)
{
match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
lock_owned_by_me = true;
}
Ok(crate::lock::AcquireOutcome::Held(other)) => {
let holder_name = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(other.user_id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|u| u.username)
.unwrap_or_else(|| format!("user#{}", other.user_id));
lock_banner = Some(serde_json::json!({
"holder_username": holder_name,
"holder_id": other.user_id,
"acquired_at": other.acquired_at.get().copied(),
"expires_at": other.expires_at,
}));
}
Err(e) => {
tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock acquire failed");
}
}
}
ctx.insert("lock_banner", &lock_banner);
ctx.insert("lock_owned_by_me", &lock_owned_by_me);
ctx.insert("lock_heartbeat_secs", &crate::lock::HEARTBEAT_INTERVAL_SECS);
let workflow_slug: Option<String> = chosen_type.workflow_name();
let mut workflow_ctx: Option<serde_json::Value> = None;
let mut workflow_state_ctx: Option<serde_json::Value> = None;
let mut workflow_current_task_ctx: Option<serde_json::Value> = None;
let mut workflow_history_ctx: Vec<serde_json::Value> = Vec::new();
let mut workflow_viewer_can_decide = false;
if let Some(slug) = workflow_slug.as_deref() {
let workflow = crate::workflow::find_by_name(tenant.pool(), slug)
.await
.unwrap_or(None);
if let Some(wf) = workflow {
let wf_id = wf.id.get().copied().unwrap_or_default();
let tasks = crate::workflow::tasks_for(tenant.pool(), wf_id)
.await
.unwrap_or_default();
workflow_ctx = Some(serde_json::json!({
"id": wf_id,
"name": wf.name,
"description": wf.description,
"task_count": tasks.len(),
}));
if let Some(state_row) = crate::workflow::latest_state_for_page(tenant.pool(), id)
.await
.unwrap_or(None)
{
let state_id = state_row.id.get().copied().unwrap_or_default();
if let Some(current) = state_row
.current_task_id
.and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
{
workflow_current_task_ctx = Some(serde_json::json!({
"id": current.id.get().copied(),
"name": current.name,
"role_id": current.role_id,
}));
if let Some(viewer) = session_user.as_ref() {
let viewer_id = viewer.id.get().copied().unwrap_or_default();
workflow_viewer_can_decide = viewer.is_superuser
|| user_is_in_role(tenant.pool(), viewer_id, current.role_id)
.await
.unwrap_or(false);
}
}
workflow_state_ctx = Some(serde_json::json!({
"id": state_id,
"status": state_row.status,
"requested_by": state_row.requested_by,
"requested_at": state_row.requested_at.get().copied(),
"finished_at": state_row.finished_at,
}));
if let Ok(history) = crate::workflow::history_for_page(tenant.pool(), id).await {
let reviewer_ids: Vec<i64> =
history.iter().filter_map(|h| h.decided_by).collect();
let reviewers: std::collections::HashMap<i64, String> =
if reviewer_ids.is_empty() {
std::collections::HashMap::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(reviewer_ids))
.fetch(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
.collect()
};
let task_name_by_id: std::collections::HashMap<i64, String> = tasks
.iter()
.filter_map(|t| t.id.get().copied().map(|tid| (tid, t.name.clone())))
.collect();
workflow_history_ctx = history
.iter()
.map(|h| {
serde_json::json!({
"task_name": task_name_by_id
.get(&h.task_id)
.cloned()
.unwrap_or_else(|| format!("task #{}", h.task_id)),
"status": h.status,
"comment": h.comment,
"decided_by_username": h
.decided_by
.and_then(|uid| reviewers.get(&uid).cloned()),
"decided_at": h.decided_at,
})
})
.collect();
}
}
}
}
let workflow_locked = workflow_state_ctx
.as_ref()
.and_then(|s| s.get("status"))
.and_then(|v| v.as_str())
.map(|s| s == crate::workflow::WorkflowStatus::InProgress.as_str())
.unwrap_or(false)
&& !workflow_viewer_can_decide;
ctx.insert("workflow_slug", &workflow_slug);
ctx.insert("workflow", &workflow_ctx);
ctx.insert("workflow_state", &workflow_state_ctx);
ctx.insert("workflow_current_task", &workflow_current_task_ctx);
ctx.insert("workflow_history", &workflow_history_ctx);
ctx.insert("workflow_viewer_can_decide", &workflow_viewer_can_decide);
ctx.insert("workflow_locked", &workflow_locked);
let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
&& crate::workflow::review_workflow_for_type(tenant.pool(), page.page_type_id).await?.is_some();
ctx.insert("review_required", &review_required);
if let (Some(held), Some(form)) = (pending.as_ref(), pending_form.as_ref()) {
ctx.insert("page", &overlay_pending_page(&page, form));
let by = match held.created_by {
Some(uid) => rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.first(tenant.pool())
.await?
.map(|u| u.username),
None => None,
};
ctx.insert(
"pending_change",
&serde_json::json!({ "by": by, "updated_at": held.updated_at.get().copied() }),
);
}
let view_restriction = crate::view_restriction::direct_for_page(tenant.pool(), id)
.await
.unwrap_or(None);
let restriction_kind = view_restriction
.as_ref()
.map(|r| r.kind.clone())
.unwrap_or_else(|| "none".to_owned());
let restriction_groups = view_restriction
.as_ref()
.map(|r| r.parsed_groups())
.unwrap_or_default();
let restriction_groups_str = restriction_groups
.iter()
.map(i64::to_string)
.collect::<Vec<_>>()
.join(",");
let role_choices: Vec<serde_json::Value> = all_roles
.iter()
.map(|r| {
serde_json::json!({
"id": r.id.get().copied(),
"name": r.name,
"checked": r.id.get().copied().is_some_and(|rid| restriction_groups.contains(&rid)),
})
})
.collect();
let restriction_codenames = view_restriction
.as_ref()
.map(|r| r.parsed_codenames())
.unwrap_or_default();
let restriction_codenames_str = restriction_codenames.join(",");
let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
.into_iter()
.map(|(codename, label)| {
serde_json::json!({
"codename": codename,
"label": label,
"checked": restriction_codenames.contains(&codename),
})
})
.collect();
ctx.insert("restriction_kind", &restriction_kind);
ctx.insert("restriction_groups_str", &restriction_groups_str);
ctx.insert("restriction_role_choices", &role_choices);
ctx.insert("restriction_codenames_str", &restriction_codenames_str);
ctx.insert("restriction_codename_choices", &codename_choices);
ctx.insert(
"restriction_has_password",
&view_restriction
.as_ref()
.map(|r| !r.password_hash.is_empty())
.unwrap_or(false),
);
let threads = crate::comment::threads_for_page(tenant.pool(), id)
.await
.unwrap_or_default();
let thread_ids: Vec<i64> = threads.iter().filter_map(|c| c.id.get().copied()).collect();
let replies_by_thread = crate::comment::replies_for_threads(tenant.pool(), &thread_ids)
.await
.unwrap_or_default();
let mut comment_user_ids: std::collections::BTreeSet<i64> =
threads.iter().map(|c| c.author_id).collect();
for replies in replies_by_thread.values() {
for r in replies {
comment_user_ids.insert(r.author_id);
}
}
let comment_users: std::collections::HashMap<i64, String> = if comment_user_ids.is_empty() {
std::collections::HashMap::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(comment_user_ids.iter().copied()))
.fetch(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
.collect()
};
let comment_threads: Vec<serde_json::Value> = threads
.iter()
.map(|c| {
let tid = c.id.get().copied().unwrap_or_default();
let replies = replies_by_thread.get(&tid).cloned().unwrap_or_default();
let rendered_replies: Vec<serde_json::Value> = replies
.iter()
.map(|r| {
serde_json::json!({
"id": r.id.get().copied(),
"author_username": comment_users.get(&r.author_id).cloned(),
"body": r.body,
"created_at": r.created_at.get().copied(),
})
})
.collect();
serde_json::json!({
"id": tid,
"field_path": c.field_path,
"author_username": comment_users.get(&c.author_id).cloned(),
"body": c.body,
"created_at": c.created_at.get().copied(),
"resolved_at": c.resolved_at,
"replies": rendered_replies,
"reply_count": replies.len(),
})
})
.collect();
ctx.insert("comment_threads", &comment_threads);
ctx.insert(
"comment_open_count",
&comment_threads
.iter()
.filter(|t| t.get("resolved_at").map(|v| v.is_null()).unwrap_or(true))
.count(),
);
ctx.insert(
"comment_resolved_count",
&comment_threads
.iter()
.filter(|t| t.get("resolved_at").map(|v| !v.is_null()).unwrap_or(false))
.count(),
);
ctx.insert(
"comment_field_choices",
&serde_json::json!([
{"value": "title", "label": "Title"},
{"value": "slug", "label": "Slug"},
{"value": "seo_title", "label": "SEO title"},
{"value": "seo_description", "label": "SEO description"},
{"value": "body", "label": "Body / stream content"},
{"value": "general", "label": "General — whole page"},
]),
);
render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
}
pub async fn page_autosave_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form_map): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
use rustango::sql::FetcherPool as _;
let mut page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
if let Ok(Some(lock)) = crate::lock::current(tenant.pool(), id).await {
if lock.user_id != viewer_id {
return Ok((axum::http::StatusCode::CONFLICT, "locked").into_response());
}
}
}
if page.status != crate::page::PageStatus::Draft.as_str() {
return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
}
if let Some(u) = session_user.as_ref() {
if read_only_under_review(tenant.pool(), id, u).await? {
return Ok((axum::http::StatusCode::CONFLICT, "under review").into_response());
}
}
if let Some(v) = form_map.get("title") {
page.title = v.clone();
}
if let Some(v) = form_map.get("seo_title") {
page.seo_title = v.clone();
}
if let Some(v) = form_map.get("seo_description") {
page.seo_description = v.clone();
}
let posted_status = form_map.get("status").cloned();
page.save_pool(tenant.pool()).await?;
let pts: Vec<PageType> = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.fetch(tenant.pool())
.await?;
if let Some(pt) = pts.into_iter().next() {
if let Some(handler) = find_handler(&pt.type_name) {
let ext_form =
sanitized_extension_form(handler.as_ref(), tenant.pool(), id, &form_map).await;
handler.save_extension(tenant.pool(), id, &ext_form).await?;
}
}
save_page_builder_values(tenant.pool(), page.page_type_id, id, &form_map).await?;
let by = session_user.as_ref().and_then(|u| u.id.get().copied());
if let Ok(mut rev) = crate::revision::capture(tenant.pool(), &page, by).await {
if let serde_json::Value::Object(ref mut map) = rev.snapshot {
map.insert("__autosave".to_owned(), serde_json::Value::Bool(true));
if let Some(status) = posted_status {
map.insert(
"__autosave_posted_status".to_owned(),
serde_json::Value::String(status),
);
}
rev.save_pool(tenant.pool()).await.log_warn("autosave revision not stored");
}
}
Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
}
const PENDING_TEXT_KEYS: &[&str] = &[
"title",
"slug",
"seo_title",
"seo_description",
"og_title",
"og_description",
"preview_path",
];
fn overlay_pending_page(
page: &Page,
form: &std::collections::HashMap<String, String>,
) -> serde_json::Value {
let mut value = serde_json::to_value(page).unwrap_or_default();
if let Some(obj) = value.as_object_mut() {
for key in PENDING_TEXT_KEYS {
if let Some(v) = form.get(*key) {
obj.insert((*key).to_owned(), serde_json::Value::String(v.clone()));
}
}
}
value
}
fn overlay_pending_widgets(
widgets: &mut [crate::widget::Widget],
form: &std::collections::HashMap<String, String>,
) {
for w in widgets {
match form.get(&w.name) {
Some(v) => w.value.clone_from(v),
None if matches!(w.kind, crate::widget::WidgetKind::Boolean) => w.value.clear(),
None => {}
}
}
}
const PAGE_FORM_CANONICAL_KEYS: &[&str] = &[
"title",
"slug",
"status",
"seo_title",
"seo_description",
"robots_index",
"sitemap_priority",
"parent_id",
"theme_id",
"go_live_at",
"expire_at",
"show_in_menus",
"preview_path",
"template_override",
"og_title",
"og_description",
"og_image_media_id",
"twitter_card",
"tags",
];
pub(crate) struct PageEditActor {
pub id: i64,
pub username: String,
pub is_superuser: bool,
}
pub(crate) enum PageEditRefusal {
WorkflowReview { task_name: String },
LockedBy { holder: String },
ArchivedUnpublish,
PublishDenied,
ReviewRequired { workflow: String },
}
pub(crate) struct PageEditOutcome {
pub page: Page,
pub redirects_created: usize,
pub reapproval_kicked: bool,
pub held_for_review: bool,
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn apply_page_edit(
pool: &rustango::sql::Pool,
org_slug: &str,
invalidator: &std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
mailer: Option<&dyn rustango::email::Mailer>,
mailer_from: &str,
notify: bool,
id: i64,
form_map: &std::collections::HashMap<String, String>,
actor: Option<&PageEditActor>,
) -> Result<Result<PageEditOutcome, PageEditRefusal>, AdminError> {
if let Some(actor) = actor {
if let Some(active) = crate::workflow::active_state_for_page(pool, id).await? {
if active.status == crate::workflow::WorkflowStatus::InProgress.as_str()
&& !actor.is_superuser
{
let tasks = crate::workflow::tasks_for(pool, active.workflow_id).await?;
if let Some(current_task) = active
.current_task_id
.and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
{
if !user_is_in_role(pool, actor.id, current_task.role_id).await? {
return Ok(Err(PageEditRefusal::WorkflowReview {
task_name: current_task.name.clone(),
}));
}
}
}
}
}
if let Some(actor) = actor {
match crate::lock::current(pool, id).await {
Ok(Some(lock)) if lock.user_id != actor.id => {
let holder = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(lock.user_id))
.fetch(pool)
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|u| u.username)
.unwrap_or_else(|| format!("user#{}", lock.user_id));
return Ok(Err(PageEditRefusal::LockedBy { holder }));
}
_ => {}
}
}
let canonical_keys = PAGE_FORM_CANONICAL_KEYS;
let mut canonical_only: std::collections::HashMap<&str, String> = form_map
.iter()
.filter(|(k, _)| canonical_keys.contains(&k.as_str()))
.map(|(k, v)| (k.as_str(), v.clone()))
.collect();
let mut page = Page::objects()
.where_(Page::id.eq(id))
.first(pool)
.await?
.ok_or(AdminError::NotFound(id))?;
let frozen_type_id = page.page_type_id.to_string();
canonical_only.insert("page_type_id", frozen_type_id);
let canonical_view: std::collections::HashMap<&str, &str> = canonical_only
.iter()
.map(|(k, v)| (*k, v.as_str()))
.collect();
let form: PageForm = serde_urlencoded::from_str(
&serde_urlencoded::to_string(&canonical_view).unwrap_or_default(),
)
.map_err(|e| AdminError::Validation(format!("canonical form: {e}")))?;
if let Some(actor) = actor.filter(|a| !a.is_superuser) {
if page.status == crate::page::PageStatus::Published.as_str() {
if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id)
.await?
.filter(|wf| wf.require_reapproval_on_edit)
{
crate::pending_change::hold(pool, id, form_map, Some(actor.id)).await?;
let mut started = false;
if crate::workflow::active_state_for_page(pool, id).await?.is_none() {
let tasks =
crate::workflow::tasks_for(pool, wf.id.get().copied().unwrap_or_default())
.await?;
crate::workflow::submit_for_review(pool, id, &wf, &tasks, actor.id).await?;
started = true;
}
return Ok(Ok(PageEditOutcome {
page,
redirects_created: 0,
reapproval_kicked: started,
held_for_review: true,
}));
}
}
}
page.title = form.title.clone();
let new_slug = if form.slug.trim().is_empty() {
String::new()
} else {
slugify(&form.slug)
};
let slug_changed = page.slug != new_slug;
if slug_changed && !new_slug.is_empty() {
let sibling = Page::objects()
.where_(Page::slug.eq(new_slug.clone()))
.where_(Page::id.ne(id));
let sibling = match page.parent_id {
Some(pid) => sibling.where_(Page::parent_id.eq(pid)),
None => sibling.where_(Page::parent_id.is_null()),
};
if sibling.first(pool).await?.is_some() {
return Err(AdminError::Validation(format!(
"another page under the same parent already uses the slug “{new_slug}”"
)));
}
}
let old_url_path = page.url_path.clone();
page.slug = new_slug;
let was_published = page.status == crate::page::PageStatus::Published.as_str();
let was_archived = page.status == crate::page::PageStatus::Archived.as_str();
let old_status = page.status.clone();
page.status = form.parsed_status().as_str().to_owned();
page.seo_title = form.seo_title.clone();
page.seo_description = form.seo_description.clone();
page.robots_index = form.parsed_robots_index();
page.sitemap_priority = form.parsed_sitemap_priority();
if let Some(theme_id) = form.theme_id {
page.theme_id = theme_id;
}
let new_go_live = form.parsed_go_live_at();
if page.go_live_at != new_go_live {
page.notification_pre_published_sent = false;
}
page.go_live_at = new_go_live;
page.expire_at = form.parsed_expire_at();
page.status = derive_scheduled_status(&page.status, page.go_live_at);
page.show_in_menus = form.parsed_show_in_menus();
page.preview_path = form.preview_path.trim().to_owned();
page.template_override = form.template_override.trim().to_owned();
if page.status == crate::page::PageStatus::Published.as_str() {
let now = chrono::Utc::now();
if page.published_at.is_none() {
page.published_at = Some(now);
}
page.last_published_at = Some(now);
}
if was_archived && page.status == crate::page::PageStatus::Draft.as_str() {
return Ok(Err(PageEditRefusal::ArchivedUnpublish));
}
if let Some(actor) = actor {
if crate::page::PageStatus::str_goes_live(&old_status, &page.status) {
if !actor.is_superuser {
if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id).await? {
return Ok(Err(PageEditRefusal::ReviewRequired { workflow: wf.name }));
}
}
let req = super::route_perms::Requirement {
codename: "cms_page.publish".to_owned(),
page: Some((id, crate::permissions::Action::Publish)),
};
if !super::route_perms::allows_id(pool, actor.id, actor.is_superuser, &req).await {
return Ok(Err(PageEditRefusal::PublishDenied));
}
}
}
page.og_title = form.og_title.clone();
page.og_description = form.og_description.clone();
page.og_image_media_id = form.og_image_media_id;
if let Some(tc) = form.twitter_card.as_deref() {
if matches!(tc, "summary" | "summary_large_image") {
page.twitter_card = tc.to_owned();
}
}
if slug_changed {
let parent_url_path = match page.parent_id {
None => None,
Some(pid) => Page::objects()
.where_(Page::id.eq(pid))
.first(pool)
.await?
.map(|p| p.url_path),
};
page.url_path = crate::tree_ops::compute_url_path(parent_url_path.as_deref(), &page.slug);
}
let new_url_path = page.url_path.clone();
let invalidator = invalidator.clone();
let tenant_slug = org_slug.to_owned();
let purge_new = new_url_path.clone();
let purge_old = old_url_path.clone();
let (page, descendant_urls) = crate::tree_ops::atomic_tree(pool, move |tx| {
Box::pin(async move {
page.save_tx(tx).await?;
let descendants: Vec<Page> = if slug_changed {
crate::tree_ops::cascade_url_path_to_descendants(tx, &page).await?;
Page::objects()
.where_(Page::path.like(crate::tree::descendants_like(&page.path)))
.where_(Page::path.ne(page.path.clone()))
.fetch_tx(tx)
.await?
} else {
Vec::new()
};
if slug_changed {
let public = |p: &Page| matches!(p.status.as_str(), "published" | "archived");
let mut moves = Vec::with_capacity(1 + descendants.len());
if public(&page) {
moves.push((page.id.get().copied().unwrap_or_default(), purge_old.clone(), purge_new.clone()));
}
for d in descendants.iter().filter(|d| public(d)) {
if let Some(old) = crate::redirect::rebase_path(&d.url_path, &purge_new, &purge_old) {
moves.push((d.id.get().copied().unwrap_or_default(), old, d.url_path.clone()));
}
}
crate::redirect::record_renames_tx(tx, &moves).await?;
}
let descendant_urls: Vec<String> = descendants.into_iter().map(|d| d.url_path).collect();
let mut urls = Vec::with_capacity(2 + descendant_urls.len());
urls.push(purge_new.clone());
if slug_changed && purge_old != purge_new && !purge_old.is_empty() {
urls.push(purge_old);
}
urls.extend(descendant_urls.iter().cloned());
crate::cache_invalidate::invalidate_urls_on_commit(invalidator, tenant_slug, urls);
Ok((page, descendant_urls))
})
})
.await?;
if let Some(tags_raw) = form_map.get("tags") {
let names: Vec<String> = if tags_raw.is_empty() {
Vec::new()
} else {
tags_raw.split(',').map(|s| s.to_owned()).collect()
};
crate::page_tag::replace_tags(pool, id, &names).await?;
}
crate::category::assign::save_from_form(
pool,
id,
form_map.get(crate::category::assign::FORM_KEY).map(String::as_str),
)
.await?;
let pt_opt: Option<PageType> = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.first(pool)
.await?;
save_type_content(pool, pt_opt.as_ref(), page.page_type_id, id, form_map).await?;
crate::revision::capture(pool, &page, actor.map(|a| a.id))
.await
.log_warn("revision not captured; the history has a gap");
reindex_from_form(pool, org_slug, id, form_map).await;
crate::task_queue::sync_page_search(org_slug, &page).await;
let actor_id = actor.map(|a| a.id);
if page.status == crate::page::PageStatus::Published.as_str() {
crate::hooks::fire_after_publish_page(&page);
if notify {
let actor_name = actor.map(|a| a.username.as_str());
crate::page_subscription::notify_publish(
mailer,
mailer_from,
pool,
org_slug,
page.id.get().copied().unwrap_or_default(),
&page.title,
&page.url_path,
actor_name,
)
.await;
}
crate::page_log::record_or_warn(
pool,
id,
crate::page_log::ACTION_PUBLISH,
actor_id,
format!("Published “{}”.", page.title),
None,
)
.await;
} else {
crate::page_log::record_or_warn(
pool,
id,
crate::page_log::ACTION_EDIT,
actor_id,
format!("Edited “{}”.", page.title),
Some(serde_json::json!({ "status": page.status })),
)
.await;
}
let mut redirects_created = 0usize;
if slug_changed && old_url_path != new_url_path && !old_url_path.is_empty() {
let new_prefix = if new_url_path == "/" {
String::new()
} else {
new_url_path.clone()
};
let old_prefix = if old_url_path == "/" {
String::new()
} else {
old_url_path.clone()
};
let mut pairs: Vec<(String, String)> = vec![(old_url_path.clone(), new_url_path.clone())];
for new_d in &descendant_urls {
if let Some(suffix) = new_d.strip_prefix(new_prefix.as_str()) {
let old_d = format!("{old_prefix}{suffix}");
if old_d != *new_d {
pairs.push((old_d, new_d.clone()));
}
}
}
let now = chrono::Utc::now().to_rfc3339();
for (old_path, new_path) in pairs {
let existing: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::from_path.eq(old_path.clone()))
.fetch(pool)
.await
.unwrap_or_default();
if let Some(mut r) = existing.into_iter().next() {
if r.to_path != new_path {
r.to_path = new_path.clone();
r.is_permanent = true;
r.note = format!("auto-updated on page rename at {now}");
if r.from_page_id.is_none() {
r.from_page_id = Some(id);
}
r.save_pool(pool).await.log_warn("redirect not linked to its source page");
}
continue;
}
let stale_chain: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::to_path.eq(old_path.clone()))
.fetch(pool)
.await
.unwrap_or_default();
for mut r in stale_chain {
if r.from_path == new_path {
r.delete_pool(pool)
.await
.log_warn("self-redirect left after a rename back not deleted");
continue;
}
r.to_path = new_path.clone();
r.note = format!("auto-chained on page rename at {now}");
r.save_pool(pool).await.log_warn("redirect chain not updated after a rename");
}
let mut row = crate::redirect::Redirect {
id: rustango::sql::Auto::Unset,
from_path: old_path,
to_path: new_path,
is_permanent: true,
note: format!("auto-created on page rename at {now}"),
hit_count: 0,
overrides_live: false,
from_page_id: Some(id),
to_page_id: None,
is_active: true,
disabled_reason: String::new(),
last_hit_at: None,
created_at: rustango::sql::Auto::Unset,
updated_at: rustango::sql::Auto::Unset,
};
if row.insert_pool(pool).await.is_ok() {
redirects_created += 1;
}
}
}
let mut reapproval_kicked = false;
if let (Some(viewer_id), Some(pt)) = (actor.map(|a| a.id), pt_opt.as_ref()) {
if let Some(slug) = pt.workflow_name() {
if let Some(workflow) = crate::workflow::find_by_name(pool, &slug).await? {
if workflow.require_reapproval_on_edit
&& crate::workflow::active_state_for_page(pool, id)
.await?
.is_none()
&& crate::workflow::has_prior_approval(pool, id).await?
{
let tasks = crate::workflow::tasks_for(
pool,
workflow.id.get().copied().unwrap_or_default(),
)
.await?;
if !tasks.is_empty() {
crate::workflow::submit_for_review(
pool, id, &workflow, &tasks, viewer_id,
)
.await?;
reapproval_kicked = true;
}
}
}
}
}
let _ = (&new_url_path, slug_changed, &old_url_path, &descendant_urls);
if was_published && page.status != crate::page::PageStatus::Published.as_str() {
match crate::redirect::disable_for_page(
pool,
id,
&format!("Linked page “{}” was unpublished", page.title),
)
.await
{
Ok(0) => {}
Ok(n) => {
tracing::info!(
page_id = id,
disabled = n,
"disabled redirects for unpublished page"
);
}
Err(e) => {
tracing::warn!(page_id = id, error = %e, "failed to disable redirects for unpublished page");
}
}
}
if actor.is_some() {
crate::pending_change::discard(pool, id).await?;
}
Ok(Ok(PageEditOutcome {
page,
redirects_created,
reapproval_kicked,
held_for_review: false,
}))
}
pub async fn page_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form_map): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let actor = session_user.as_ref().map(|u| PageEditActor {
id: u.id.get().copied().unwrap_or_default(),
username: u.username.clone(),
is_superuser: u.is_superuser,
});
let outcome = apply_page_edit(
tenant.pool(),
&tenant.org.slug,
&_state.cache_invalidator,
_state.mailer.as_deref(),
&_state.mailer_from,
true,
id,
&form_map,
actor.as_ref(),
)
.await?;
let PageEditOutcome {
page,
redirects_created,
reapproval_kicked,
held_for_review,
} = match outcome {
Ok(o) => o,
Err(PageEditRefusal::WorkflowReview { task_name }) => {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Couldn't save — page is under review on “{name}”. Only reviewers of that step can edit during review.",
&[("name", task_name.as_str())],
&headers,
);
}
Err(PageEditRefusal::LockedBy { holder }) => {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Couldn't save — “{holder}” is editing this page right now. Force-unlock to take over.",
&[("holder", holder.as_str())],
&headers,
);
}
Err(PageEditRefusal::ArchivedUnpublish) => {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Can't unpublish an archived page. Set it back to Published to unarchive, or delete it after unarchiving.",
&[],
&headers,
);
}
Err(PageEditRefusal::PublishDenied) => {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"You don't have permission to publish this page — save it as a draft or submit it for review.",
&headers,
);
}
Err(PageEditRefusal::ReviewRequired { workflow }) => {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Pages of this type go live after review (“{workflow}”). Save it as a draft and click Submit for review.",
&[("workflow", workflow.as_str())],
&headers,
);
}
};
if held_for_review {
return redirect_after_page_save(
form_map.get("_action").map_or("save", String::as_str),
id,
page.parent_id,
&super::i18n::tr(
&headers,
"Your changes to “{title}” wait for review. Visitors see the live page until they are approved.",
&[("title", page.title.as_str())],
),
&headers,
);
}
let mut message = if redirects_created > 0 {
let count = redirects_created.to_string();
super::i18n::tr_plural(
&headers,
"Saved “{title}”. Auto-created {count} redirect(s) from the old URL(s).",
redirects_created as i64,
&[("title", page.title.as_str()), ("count", count.as_str())],
)
} else {
super::i18n::tr(
&headers,
"Saved “{title}”.",
&[("title", page.title.as_str())],
)
};
if reapproval_kicked {
message.push(' ');
message.push_str(&super::i18n::tr(
&headers,
"Workflow restarted — page enters review again.",
&[],
));
}
redirect_after_page_save(
form_map.get("_action").map_or("save", String::as_str),
id,
page.parent_id,
&message,
&headers,
)
}
pub(crate) async fn upsert_page_translations(
pool: &rustango::sql::Pool,
page_id: i64,
locale_id: i64,
updates: Vec<(String, String)>,
) -> Result<(), rustango::sql::ExecError> {
rustango::atomic!(pool, |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for (path, value) in updates {
if value.is_empty() {
let rows: Vec<crate::translation::Translation> =
crate::translation::Translation::objects()
.where_(crate::translation::Translation::page_id.eq(page_id))
.where_(crate::translation::Translation::locale_id.eq(locale_id))
.where_(crate::translation::Translation::field_path.eq(path.clone()))
.fetch_tx(tx)
.await?;
for row in rows {
row.delete_tx(tx).await?;
}
} else {
let existing: Vec<crate::translation::Translation> =
crate::translation::Translation::objects()
.where_(crate::translation::Translation::page_id.eq(page_id))
.where_(crate::translation::Translation::locale_id.eq(locale_id))
.where_(crate::translation::Translation::field_path.eq(path.clone()))
.fetch_tx(tx)
.await?;
if let Some(mut row) = existing.into_iter().next() {
row.value = value;
row.save_tx(tx).await?;
} else {
let mut row = crate::translation::Translation {
id: rustango::sql::Auto::Unset,
page_id,
locale_id,
field_path: path,
value,
updated_at: rustango::sql::Auto::Unset,
};
row.save_tx(tx).await?;
}
}
}
Ok::<_, rustango::sql::ExecError>(())
})
.await
}
pub async fn page_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let code = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
let locale = Locale::objects()
.where_(Locale::code.eq(code.to_owned()))
.where_(Locale::active.eq(true))
.first(tenant.pool())
.await?
.ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
if locale.is_default {
return Ok((
axum::http::StatusCode::BAD_REQUEST,
"cannot translate INTO the default locale; canonical content lives on cms_page",
)
.into_response());
}
let locale_id = locale
.id
.get()
.copied()
.ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
let _page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut updates: Vec<(String, String)> = Vec::new();
for (k, v) in &form {
if let Some(path) = k.strip_prefix("tr__") {
if path.is_empty() {
continue;
}
updates.push((path.to_owned(), v.clone()));
}
}
let new_path = form
.get("new_field_path")
.map(|s| s.trim().to_owned())
.unwrap_or_default();
if !new_path.is_empty() {
let new_value = form.get("new_field_value").cloned().unwrap_or_default();
if let Ok(path) = crate::translation::validate_field_path(&new_path) {
updates.push((path, new_value));
}
}
upsert_page_translations(tenant.pool(), id, locale_id, updates).await?;
let page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let _ = (page, &code);
Ok(Redirect::to(&format!("/cms-admin/pages/{id}/edit?locale={code}")).into_response())
}
pub async fn page_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if page.status == crate::page::PageStatus::Archived.as_str() {
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Can't delete “{title}” while archived — unarchive it first.",
&[("title", page.title.as_str())],
&headers,
);
}
let child_count: Vec<Page> = Page::objects()
.where_(Page::parent_id.eq(id))
.fetch(tenant.pool())
.await?;
if !child_count.is_empty() {
let count = child_count.len().to_string();
return redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Error,
"Can't delete “{title}” — it has {count} child page(s). Delete or move them first.",
child_count.len() as i64,
&[("title", page.title.as_str()), ("count", count.as_str())],
&headers,
);
}
let serving_hosts = crate::site::hosts_for_root(tenant.pool(), id).await?;
if !serving_hosts.is_empty() {
let hosts = serving_hosts.join(", ");
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Can't delete “{title}” — it is the root served by {hosts}. Change that on the Sites screen first.",
&[("title", page.title.as_str()), ("hosts", hosts.as_str())],
&headers,
);
}
let aliases: Vec<Page> = Page::objects()
.where_(Page::alias_of.eq(id))
.fetch(tenant.pool())
.await?;
let alias_count = aliases.len();
let title = page.title.clone();
let url_path = page.url_path.clone();
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
let purge_url = url_path.clone();
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for mut alias in aliases {
alias.alias_of = None;
alias.title = page.title.clone();
alias.seo_title = page.seo_title.clone();
alias.seo_description = page.seo_description.clone();
alias.status = page.status.clone();
alias.published_at = page.published_at;
alias.last_published_at = page.last_published_at;
alias.theme_id = page.theme_id;
alias.show_in_menus = page.show_in_menus;
alias.save_tx(tx).await?;
}
crate::page_delete::clear_page_references_tx(tx, id).await?;
page.delete_tx(tx).await?;
crate::cache_invalidate::invalidate_urls_on_commit(
invalidator,
tenant_slug,
vec![purge_url],
);
Ok(())
})
.await?;
crate::task_queue::remove_page_search(&tenant.org.slug, id).await;
if let Err(e) = crate::redirect::disable_for_page(
tenant.pool(),
id,
&format!("Linked page “{title}” was deleted"),
)
.await
{
tracing::warn!(page_id = id, error = %e, "failed to disable redirects for deleted page");
}
if alias_count > 0 {
redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Success,
"Deleted “{title}”. Promoted {count} alias(es) to standalone page(s) with the source's last content.",
alias_count as i64,
&[("title", title.as_str()), ("count", &alias_count.to_string())],
&headers,
)
} else {
redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Success,
"Deleted “{title}”.",
&[("title", title.as_str())],
&headers,
)
}
}
#[derive(Debug, Deserialize)]
pub struct MoveForm {
pub new_parent: i64,
}
pub async fn page_move_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<MoveForm>,
) -> Result<Response, AdminError> {
let mut page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let new_parent: Option<Page> = if form.new_parent > 0 {
Page::objects()
.where_(Page::id.eq(form.new_parent))
.first(tenant.pool())
.await?
} else {
None
};
let old_url_path = page.url_path.clone();
let old_descendant_urls: Vec<String> =
page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path).collect();
page.move_to(&tenant, new_parent.as_ref()).await?;
let new_url_path = page.url_path.clone();
let mut urls = old_descendant_urls;
urls.push(old_url_path.clone());
urls.push(new_url_path.clone());
urls.extend(page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path));
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
rustango::__private_runtime::tokio::spawn(async move {
crate::task_queue::purge_urls(invalidator, tenant_slug, urls).await;
});
let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_MOVE,
actor_id,
format!(
"Moved “{}” from {old_url_path} to {new_url_path}.",
page.title
),
Some(serde_json::json!({
"old_url_path": old_url_path,
"new_url_path": new_url_path,
"new_parent_id": form.new_parent,
})),
)
.await;
Ok((axum::http::StatusCode::OK, "ok").into_response())
}
pub async fn page_clone_submit(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let source = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let title = format!("{} (copy)", source.title);
let base_slug = source.slug.trim_matches('-').to_owned();
let slug = unique_sibling_slug(
tenant.pool(),
source.parent_id,
&format!("{base_slug}-copy"),
)
.await?;
let new = crate::tree_ops::NewPage::new(source.page_type_id, title, slug)
.with_status(crate::page::PageStatus::Draft)
.with_seo(source.seo_title.clone(), source.seo_description.clone());
let clone = match source.parent_id {
Some(pid) => {
let parent = Page::objects()
.where_(Page::id.eq(pid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(pid))?;
Page::create_child(&tenant, &parent, new).await?
}
None => Page::create_root(&tenant, new).await?,
};
let new_id = clone.id.get().copied().unwrap_or_default();
let mut form = crate::page_form::prefill(tenant.pool(), &source).await;
form.insert("title".into(), clone.title.clone());
form.insert("slug".into(), clone.slug.clone());
form.insert(
"status".into(),
crate::page::PageStatus::Draft.as_str().to_owned(),
);
form.remove("go_live_at");
form.remove("expire_at");
let actor = session_user.as_ref().map(|u| PageEditActor {
id: u.id.get().copied().unwrap_or_default(),
username: u.username.clone(),
is_superuser: u.is_superuser,
});
let saved = apply_page_edit(
tenant.pool(),
&tenant.org.slug,
&state.cache_invalidator,
None,
"",
false,
new_id,
&form,
actor.as_ref(),
)
.await?;
if saved.is_err() {
return Err(AdminError::Validation(
"the copy was created but its content could not be saved".to_owned(),
));
}
let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_log::record_or_warn(
tenant.pool(),
new_id,
crate::page_log::ACTION_COPY,
actor_id,
format!("Cloned from “{}” (page #{id}).", source.title),
Some(serde_json::json!({ "source_page_id": id })),
)
.await;
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_COPY,
actor_id,
format!("Cloned to new draft page #{new_id}."),
Some(serde_json::json!({ "clone_page_id": new_id })),
)
.await;
redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", new_id.to_string())],
MsgLevel::Success,
"Cloned “{title}” as a draft. Review before publishing.",
&[("title", source.title.as_str())],
&headers,
)
}
#[derive(Deserialize)]
pub struct PrivacyForm {
pub kind: String,
#[serde(default)]
pub password: String,
#[serde(default)]
pub group_ids: String,
#[serde(default)]
pub codenames: String,
}
pub async fn page_privacy_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<PrivacyForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let existing = crate::view_restriction::direct_for_page(tenant.pool(), id).await?;
if form.kind == "none" {
if let Some(row) = existing {
row.delete_pool(tenant.pool()).await?;
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Removed view restriction — page is now public.",
&headers,
);
}
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Info,
"No restriction to remove.",
&headers,
);
}
let Some(kind) = crate::view_restriction::RestrictionKind::parse(&form.kind) else {
return Err(AdminError::Validation(format!(
"unknown restriction kind `{}`",
form.kind
)));
};
let password_hash = match kind {
crate::view_restriction::RestrictionKind::Password => {
if form.password.is_empty() {
if let Some(row) = &existing {
if row.kind == kind.as_str() {
row.password_hash.clone()
} else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Password is required when switching the restriction kind to password.",
&headers,
);
}
} else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Password is required for password-protected pages.",
&headers,
);
}
} else {
crate::passwords::hash(&form.password).await
.map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
}
}
_ => String::new(),
};
let group_ids: Vec<i64> = if matches!(kind, crate::view_restriction::RestrictionKind::Groups) {
form.group_ids
.split(',')
.filter_map(|s| s.trim().parse::<i64>().ok())
.collect()
} else {
Vec::new()
};
let group_json = serde_json::json!(group_ids);
let codenames: Vec<String> =
if matches!(kind, crate::view_restriction::RestrictionKind::Permission) {
form.codenames
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned)
.collect()
} else {
Vec::new()
};
let codenames_json = serde_json::json!(codenames);
match existing {
Some(mut row) => {
row.kind = kind.as_str().to_owned();
row.password_hash = password_hash;
row.group_ids = group_json;
row.codenames = codenames_json;
row.save_pool(tenant.pool()).await?;
}
None => {
let mut row = crate::view_restriction::PageViewRestriction {
id: Auto::Unset,
page_id: id,
kind: kind.as_str().to_owned(),
password_hash,
group_ids: group_json,
codenames: codenames_json,
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
}
}
redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
match kind {
crate::view_restriction::RestrictionKind::Login => "Only signed-in people can see this page now.",
crate::view_restriction::RestrictionKind::Groups => "Only the chosen roles can see this page now.",
crate::view_restriction::RestrictionKind::Permission => "Only people with the chosen permissions can see this page now.",
crate::view_restriction::RestrictionKind::Password => "This page asks for a password now.",
},
&[],
&headers,
)
}
#[derive(Debug, Deserialize)]
pub struct CommentNewForm {
pub field_path: String,
pub body: String,
}
pub async fn comment_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<CommentNewForm>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let body = form.body.trim();
let field_path = form.field_path.trim();
if body.is_empty() || field_path.is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Warning,
"Comment body and field are both required.",
&headers,
);
}
let mut row = crate::comment::Comment {
id: rustango::sql::Auto::Unset,
page_id: id,
field_path: field_path.to_owned(),
author_id: viewer_id,
body: body.to_owned(),
resolved_at: None,
resolved_by: None,
created_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Comment posted.",
&headers,
)
}
#[derive(Debug, Deserialize)]
pub struct CommentReplyForm {
pub body: String,
}
pub async fn comment_reply_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((id, comment_id)): Path<(i64, i64)>,
Form(form): Form<CommentReplyForm>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let body = form.body.trim();
if body.is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Warning,
"Reply body is required.",
&headers,
);
}
let mut row = crate::comment::CommentReply {
id: rustango::sql::Auto::Unset,
comment_id,
author_id: viewer_id,
body: body.to_owned(),
created_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Reply posted.",
&headers,
)
}
pub async fn comment_resolve_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((id, comment_id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let mut row = crate::comment::Comment::objects()
.where_(crate::comment::Comment::id.eq(comment_id))
.where_(crate::comment::Comment::page_id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(comment_id))?;
row.resolved_at = Some(chrono::Utc::now());
row.resolved_by = Some(viewer_id);
row.save_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Comment resolved.",
&headers,
)
}
pub async fn comment_reopen_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((id, comment_id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
let mut row = crate::comment::Comment::objects()
.where_(crate::comment::Comment::id.eq(comment_id))
.where_(crate::comment::Comment::page_id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(comment_id))?;
row.resolved_at = None;
row.resolved_by = None;
row.save_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Info,
"Comment reopened.",
&headers,
)
}
pub async fn page_alias_submit(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let source = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(src_id) = source.alias_of {
let src_id_str = src_id.to_string();
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Can't alias an alias — point your new alias at the underlying source page (#{source_id}) instead.",
&[("source_id", src_id_str.as_str())],
&headers,
);
}
let base_slug = source.slug.trim_matches('-').to_owned();
let slug = unique_sibling_slug(
tenant.pool(),
source.parent_id,
&if base_slug.is_empty() {
"alias".to_owned()
} else {
format!("{base_slug}-alias")
},
)
.await?;
let new = crate::tree_ops::NewPage::new(source.page_type_id, source.title.clone(), slug)
.with_status(crate::page::PageStatus::Draft)
.with_seo(source.seo_title.clone(), source.seo_description.clone());
let mut alias = match source.parent_id {
Some(pid) => {
let parent = Page::objects()
.where_(Page::id.eq(pid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(pid))?;
Page::create_child(&tenant, &parent, new).await?
}
None => Page::create_root(&tenant, new).await?,
};
alias.alias_of = Some(id);
alias.status = source.status.clone();
alias.published_at = source.published_at;
alias.last_published_at = source.last_published_at;
alias.theme_id = source.theme_id;
alias.show_in_menus = source.show_in_menus;
alias.save_pool(tenant.pool()).await?;
crate::revision::capture(tenant.pool(), &alias, None)
.await
.log_warn("revision not captured; the history has a gap");
let new_id = alias.id.get().copied().unwrap_or_default();
let _ = state;
let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_log::record_or_warn(
tenant.pool(),
new_id,
crate::page_log::ACTION_ALIAS_CREATE,
actor_id,
format!("Alias of “{}” (page #{id}).", source.title),
Some(serde_json::json!({ "alias_of": id })),
)
.await;
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_ALIAS_CREATE,
actor_id,
format!("New alias #{new_id} pointing here."),
Some(serde_json::json!({ "alias_page_id": new_id })),
)
.await;
redirect_named_with_params_and_message_args(
"rcms-admin:pages:list",
&[],
MsgLevel::Success,
"Created alias of “{title}”. Edits to the source will propagate to every alias's URL.",
&[("title", source.title.as_str())],
&headers,
)
}
fn copy_fields_for(p: &Page) -> Vec<(&'static str, String)> {
copy_translatable_fields(&p.title, &p.seo_title, &p.seo_description)
}
fn copy_translatable_fields(
title: &str,
seo_title: &str,
seo_description: &str,
) -> Vec<(&'static str, String)> {
[
("title", title),
("seo_title", seo_title),
("seo_description", seo_description),
]
.into_iter()
.filter(|(_, v)| !v.trim().is_empty())
.map(|(k, v)| (k, v.to_owned()))
.collect()
}
pub async fn page_bulk_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
let action = form
.iter()
.find(|(k, _)| k == "action")
.map(|(_, v)| v.clone())
.unwrap_or_default();
let ids: Vec<i64> = form
.iter()
.filter(|(k, _)| k == "ids" || k == "id")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
let new_parent_raw = form
.iter()
.find(|(k, _)| k == "new_parent")
.and_then(|(_, v)| v.parse::<i64>().ok());
let archive_cascade = form.iter().any(|(k, v)| {
k == "archive_cascade" && matches!(v.as_str(), "1" | "on" | "subtree" | "true")
});
if action.is_empty() || ids.is_empty() {
return redirect_named_with_message(
"rcms-admin:pages:list",
MsgLevel::Warning,
"Pick at least one row + an action before submitting.",
&headers,
);
}
let pool = tenant.pool();
let pages: Vec<Page> = {
let mut out = Vec::with_capacity(ids.len());
for id in &ids {
if let Some(p) = Page::objects().where_(Page::id.eq(*id)).first(pool).await? {
out.push(p);
}
}
out
};
if pages.is_empty() {
return redirect_named_with_message(
"rcms-admin:pages:list",
MsgLevel::Warning,
"None of the selected ids matched a live page.",
&headers,
);
}
let needs = match action.as_str() {
"publish" | "unpublish" => crate::permissions::Action::Publish,
"delete" => crate::permissions::Action::Delete,
_ => crate::permissions::Action::Edit,
};
if let Some(user) = session_user.as_ref() {
for p in &pages {
let req = super::route_perms::Requirement {
codename: format!("cms_page.{}", needs.as_str()),
page: p.id.get().copied().map(|id| (id, needs)),
};
if !super::route_perms::allows(pool, user, &req).await {
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"You don't have permission to {action} “{title}”.",
&[("action", action.as_str()), ("title", p.title.as_str())],
&headers,
);
}
}
}
match action.as_str() {
"publish" | "unpublish" => {
let target = if action == "publish" {
crate::page::PageStatus::Published
} else {
crate::page::PageStatus::Draft
};
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
let pages_for_tx = pages.clone();
let touched = rustango::atomic!(pool, |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
let mut touched = 0usize;
for mut p in pages_for_tx {
if matches!(target, crate::page::PageStatus::Draft)
&& p.status == crate::page::PageStatus::Archived.as_str()
{
continue;
}
if p.status != target.as_str() {
p.status = target.as_str().to_owned();
if matches!(target, crate::page::PageStatus::Published) {
let now = chrono::Utc::now();
if p.published_at.is_none() {
p.published_at = Some(now);
}
p.last_published_at = Some(now);
}
p.save_tx(tx).await?;
touched += 1;
}
}
crate::cache_invalidate::invalidate_urls_on_commit(
invalidator,
tenant_slug,
purge_urls,
);
Ok::<usize, rustango::sql::ExecError>(touched)
})
.await?;
for p in &pages {
crate::revision::capture(pool, p, None)
.await
.log_warn("revision not captured; the history has a gap");
}
if !matches!(target, crate::page::PageStatus::Published) {
for p in &pages {
if p.status != crate::page::PageStatus::Published.as_str() {
continue;
}
let pid = p.id.get().copied().unwrap_or_default();
if let Err(e) = crate::redirect::disable_for_page(
pool,
pid,
&format!("Linked page “{}” was unpublished", p.title),
)
.await
{
tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for unpublished page");
}
}
}
if matches!(target, crate::page::PageStatus::Published) {
for p in &pages {
crate::hooks::fire_after_publish_page(p);
}
let actor = session_user.as_ref().map(|u| u.username.as_str());
for p in &pages {
crate::page_subscription::notify_publish(
_state.mailer.as_deref(),
&_state.mailer_from,
pool,
&tenant.org.slug,
p.id.get().copied().unwrap_or_default(),
&p.title,
&p.url_path,
actor,
)
.await;
}
}
let already = (pages.len() - touched).to_string();
let key = if action == "publish" {
"Published {count} page(s) ({already} already in the target state)."
} else {
"Unpublished {count} page(s) ({already} already in the target state)."
};
redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Success,
key,
touched as i64,
&[("count", &touched.to_string()), ("already", already.as_str())],
&headers,
)
}
"delete" => {
let archived_names: Vec<String> = pages
.iter()
.filter(|p| p.status == crate::page::PageStatus::Archived.as_str())
.map(|p| format!("“{}”", p.title))
.collect();
if !archived_names.is_empty() {
let list = archived_names.join(", ");
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Can't delete archived page(s) {names} — unarchive them first.",
&[("names", list.as_str())],
&headers,
);
}
let id_set: std::collections::HashSet<i64> =
pages.iter().filter_map(|p| p.id.get().copied()).collect();
let mut offenders: Vec<String> = Vec::new();
for p in &pages {
let pid = p.id.get().copied().unwrap_or_default();
let children: Vec<Page> = Page::objects()
.where_(Page::parent_id.eq(pid))
.fetch(pool)
.await?;
let external_children = children
.iter()
.filter(|c| !id_set.contains(&c.id.get().copied().unwrap_or_default()))
.count();
if external_children > 0 {
offenders.push(format!("#{pid} “{}” ({external_children})", p.title));
}
}
if !offenders.is_empty() {
let offenders_list = offenders.join(", ");
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Bulk delete blocked — these page(s) still have external children: {offenders}.",
&[("offenders", offenders_list.as_str())],
&headers,
);
}
let mut ordered = pages.clone();
ordered.sort_by(|a, b| b.depth.cmp(&a.depth));
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
rustango::atomic!(pool, |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for p in &ordered {
let pid = p.id.get().copied().unwrap_or_default();
crate::page_delete::clear_page_references_tx(tx, pid).await?;
}
for p in ordered {
p.delete_tx(tx).await?;
}
crate::cache_invalidate::invalidate_urls_on_commit(
invalidator,
tenant_slug,
purge_urls,
);
Ok::<(), rustango::sql::ExecError>(())
})
.await?;
for p in &pages {
let pid = p.id.get().copied().unwrap_or_default();
if let Err(e) = crate::redirect::disable_for_page(
pool,
pid,
&format!("Linked page “{}” was deleted", p.title),
)
.await
{
tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for deleted page");
}
}
redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Success,
"Deleted {count} page(s).",
pages.len() as i64,
&[("count", &pages.len().to_string())],
&headers,
)
}
"move" => {
let Some(new_parent_id) = new_parent_raw else {
return redirect_named_with_message(
"rcms-admin:pages:list",
MsgLevel::Warning,
"Bulk move requires a destination — pick a parent page.",
&headers,
);
};
let new_parent: Option<Page> = if new_parent_id > 0 {
Page::objects()
.where_(Page::id.eq(new_parent_id))
.first(pool).await?
} else {
None
};
if let Some(np) = &new_parent {
for p in &pages {
if np.path.starts_with(&p.path) {
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Can't move “{title}” under “{parent}” — destination is itself or a descendant.",
&[("title", p.title.as_str()), ("parent", np.title.as_str())],
&headers,
);
}
}
}
if let Some(np) = &new_parent {
for p in &pages {
if let Err(e) =
crate::tree_ops::validate_child_placement(pool, np.page_type_id, p.page_type_id)
.await
{
let err = e.to_string();
return redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Error,
"Move blocked — “{title}” can't live under “{parent}”: {error}",
&[("title", p.title.as_str()), ("parent", np.title.as_str()), ("error", err.as_str())],
&headers,
);
}
}
}
let mut to_move: Vec<(Page, Vec<Page>)> = Vec::with_capacity(pages.len());
for p in pages.iter().cloned() {
let subtree = p.descendants(pool).await?;
to_move.push((p, subtree));
}
let moved = to_move.len();
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
let np_for_tx = new_parent.clone();
crate::tree_ops::atomic_tree(pool, move |tx| {
Box::pin(async move {
let mut purge: Vec<String> = Vec::new();
for (mut p, subtree) in to_move {
let old_url = p.url_path.clone();
let descendant_old_urls: Vec<String> =
subtree.iter().map(|d| d.url_path.clone()).collect();
p.move_to_in_tx(np_for_tx.as_ref(), subtree, tx).await?;
purge.push(old_url);
purge.push(p.url_path.clone());
purge.extend(descendant_old_urls);
}
crate::cache_invalidate::invalidate_urls_on_commit(
invalidator,
tenant_slug,
purge,
);
Ok(())
})
})
.await?;
redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Success,
"Moved {count} page(s) under “{parent}”.",
moved as i64,
&[
("count", &moved.to_string()),
(
"parent",
&new_parent.map(|p| p.title).unwrap_or_else(|| "Root".to_owned()),
),
],
&headers,
)
}
"copy-to-locale" => {
let code = form
.iter()
.find(|(k, _)| k == "locale")
.map(|(_, v)| v.as_str())
.unwrap_or("");
let locale = Locale::objects()
.where_(Locale::code.eq(code.to_owned()))
.where_(Locale::active.eq(true))
.first(pool)
.await?;
let Some(locale) = locale.filter(|l| !l.is_default) else {
return redirect_named_with_message(
"rcms-admin:pages:list",
MsgLevel::Warning,
"Copy to locale needs a target locale (and not the default — canonical content already lives there).",
&headers,
);
};
let locale_id = locale.id.get().copied().unwrap_or_default();
let pages_for_tx = pages.clone();
let (seeded_pages, seeded_fields) = rustango::atomic!(pool, |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
let mut sp = 0usize;
let mut sf = 0usize;
for p in &pages_for_tx {
let Some(pid) = p.id.get().copied() else {
continue;
};
let existing: Vec<crate::translation::Translation> =
crate::translation::Translation::objects()
.where_(crate::translation::Translation::page_id.eq(pid))
.where_(crate::translation::Translation::locale_id.eq(locale_id))
.fetch_tx(tx)
.await?;
let have: std::collections::HashSet<String> =
existing.into_iter().map(|t| t.field_path).collect();
let mut touched = false;
for (path, value) in copy_fields_for(p) {
if have.contains(path) {
continue;
}
let mut row = crate::translation::Translation {
id: rustango::sql::Auto::Unset,
page_id: pid,
locale_id,
field_path: path.to_owned(),
value,
updated_at: rustango::sql::Auto::Unset,
};
row.save_tx(tx).await?;
sf += 1;
touched = true;
}
if touched {
sp += 1;
}
}
Ok::<_, rustango::sql::ExecError>((sp, sf))
})
.await?;
let fields = super::i18n::tr_plural(
&headers,
"{count} field(s)",
seeded_fields as i64,
&[("count", &seeded_fields.to_string())],
);
let pages_ph = super::i18n::tr_plural(
&headers,
"{count} page(s)",
seeded_pages as i64,
&[("count", &seeded_pages.to_string())],
);
redirect_named_with_message_args(
"rcms-admin:pages:list",
MsgLevel::Success,
"Seeded {fields} across {pages} into “{locale}”. Existing translations were left untouched.",
&[
("fields", fields.as_str()),
("pages", pages_ph.as_str()),
("locale", locale.name.as_str()),
],
&headers,
)
}
"archive" | "unarchive" => {
let archive = action == "archive";
let plan =
crate::page::plan_archive(pool, &pages, archive, archive_cascade).await?;
let invalidator = _state.cache_invalidator.clone();
let tenant_slug = tenant.org.slug.clone();
let purge = plan.changed_urls.clone();
let flips = plan.to_flip.clone();
let touched = rustango::atomic!(pool, |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
let mut n = 0usize;
for mut p in flips {
p.save_tx(tx).await?;
n += 1;
}
crate::cache_invalidate::invalidate_urls_on_commit(
invalidator,
tenant_slug,
purge,
);
Ok::<usize, rustango::sql::ExecError>(n)
})
.await?;
for p in &plan.to_flip {
crate::revision::capture(pool, p, None)
.await
.log_warn("revision not captured; the history has a gap");
crate::task_queue::sync_page_search(&tenant.org.slug, p).await;
}
let key = if archive {
"Archived {count} page(s)."
} else {
"Unarchived {count} page(s)."
};
redirect_named_with_message_plural(
"rcms-admin:pages:list",
MsgLevel::Success,
key,
touched as i64,
&[("count", &touched.to_string())],
&headers,
)
}
other => Err(AdminError::Validation(format!(
"unknown bulk action `{other}` (expected publish / unpublish / archive / unarchive / delete / move / copy-to-locale)"
))),
}
}
pub async fn page_lock_release(
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
crate::lock::release(tenant.pool(), id, viewer_id).await?;
Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
}
pub async fn page_unlock_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let released = crate::lock::force_release(tenant.pool(), id).await?;
let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
let message = if let Some(row) = released {
let holder = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(row.user_id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|u| u.username)
.unwrap_or_else(|| format!("user#{}", row.user_id));
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_FORCE_UNLOCK,
actor_id,
format!("Force-unlocked — “{holder}” no longer holds the editor lock."),
Some(serde_json::json!({ "previous_holder_user_id": row.user_id })),
)
.await;
format!("Lock released — “{holder}” no longer holds the editor lock on this page.")
} else {
"Lock was already released.".to_owned()
};
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
&message,
&headers,
)
}
pub async fn page_subscribe_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
crate::page_subscription::subscribe(tenant.pool(), id, viewer_id).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Subscribed — you'll get an email when this page publishes.",
&headers,
)
}
pub async fn page_unsubscribe_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
crate::page_subscription::unsubscribe(tenant.pool(), id, viewer_id).await?;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Unsubscribed — you won't get future publish notifications for this page.",
&headers,
)
}
async fn read_only_under_review(
pool: &rustango::sql::Pool,
page_id: i64,
user: &rustango::tenancy::auth::User,
) -> Result<bool, AdminError> {
if user.is_superuser {
return Ok(false);
}
let Some(state) = crate::workflow::active_state_for_page(pool, page_id).await? else {
return Ok(false);
};
if state.status != crate::workflow::WorkflowStatus::InProgress.as_str() {
return Ok(false);
}
let tasks = crate::workflow::tasks_for(pool, state.workflow_id).await?;
let Some(task) = state
.current_task_id
.and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
else {
return Ok(false);
};
let uid = user.id.get().copied().unwrap_or_default();
Ok(!user_is_in_role(pool, uid, task.role_id).await?)
}
#[derive(Debug, Deserialize)]
pub struct HeartbeatQuery {
#[serde(default)]
pub is_editing: Option<String>,
}
pub async fn page_lock_heartbeat(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<HeartbeatQuery>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let is_editing = q.is_editing.as_deref() == Some("1");
if let Err(e) = crate::editing_session::touch(tenant.pool(), id, viewer_id, is_editing).await {
tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "editing-session touch failed (continuing)");
}
if rand::random::<u8>() < 5 {
crate::editing_session::gc_stale(tenant.pool())
.await
.log_warn("stale editing sessions not collected");
}
if let Some(u) = session_user.as_ref() {
if read_only_under_review(tenant.pool(), id, u).await? {
return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
}
}
match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
}
Ok(crate::lock::AcquireOutcome::Held(_)) => Ok((
axum::http::StatusCode::CONFLICT,
"lock held by another editor",
)
.into_response()),
Err(e) => {
tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock heartbeat failed");
Err(e.into())
}
}
}
pub async fn page_sessions_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let others = crate::editing_session::others_on_page(tenant.pool(), id, viewer_id)
.await
.unwrap_or_default();
if others.is_empty() {
return Ok(([(header::CONTENT_TYPE, "application/json")], "[]").into_response());
}
let user_ids: Vec<i64> = others.iter().map(|s| s.user_id).collect();
let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids))
.fetch(tenant.pool())
.await
.unwrap_or_default();
let username_by_id: std::collections::HashMap<i64, String> = users
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect();
let payload: Vec<serde_json::Value> = others
.iter()
.map(|s| {
serde_json::json!({
"user_id": s.user_id,
"username": username_by_id.get(&s.user_id).cloned(),
"last_seen_at": s.last_seen_at,
"is_editing": s.is_editing,
})
})
.collect();
let body = serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_owned());
Ok(([(header::CONTENT_TYPE, "application/json")], body).into_response())
}
async fn unique_sibling_slug(
pool: &rustango::sql::Pool,
parent_id: Option<i64>,
desired: &str,
) -> Result<String, AdminError> {
use rustango::core::Column as _;
let qs = Page::objects().order_by(&[("slug", false)]);
let siblings: Vec<Page> = match parent_id {
Some(pid) => qs.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
None => qs.where_(Page::parent_id.is_null()).fetch(pool).await?,
};
let taken: std::collections::HashSet<String> = siblings.into_iter().map(|p| p.slug).collect();
if !taken.contains(desired) {
return Ok(desired.to_owned());
}
for n in 2..=100 {
let candidate = format!("{desired}-{n}");
if !taken.contains(&candidate) {
return Ok(candidate);
}
}
Err(AdminError::Validation(
"Could not allocate a unique slug for the clone — over 100 siblings share the same base."
.to_owned(),
))
}
pub async fn page_revert_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((id, rev_id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
let mut page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let rev = crate::revision::Revision::objects()
.where_(crate::revision::Revision::id.eq(rev_id))
.where_(crate::revision::Revision::page_id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(rev_id))?;
let snapshot: Page = match serde_json::from_value(rev.snapshot.clone()) {
Ok(p) => p,
Err(e) => {
return Ok((
axum::http::StatusCode::BAD_REQUEST,
format!("revision snapshot could not be decoded: {e}"),
)
.into_response());
}
};
let old_url_path = page.url_path.clone();
page.title = snapshot.title;
page.page_type_id = snapshot.page_type_id;
page.status = snapshot.status;
page.published_at = snapshot.published_at;
page.go_live_at = snapshot.go_live_at;
page.expire_at = snapshot.expire_at;
page.seo_title = snapshot.seo_title;
page.seo_description = snapshot.seo_description;
page.robots_index = snapshot.robots_index;
page.sitemap_priority = snapshot.sitemap_priority;
let mut tx = transaction_pool(tenant.pool()).await?;
page.save_tx(&mut tx).await?;
tx.commit().await?;
crate::revision::capture(tenant.pool(), &page, None)
.await
.log_warn("revision not captured; the history has a gap");
let _ = old_url_path; let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_RESTORE,
actor_id,
format!("Reverted to revision #{}.", rev.sequence),
Some(serde_json::json!({ "revision_id": rev_id, "sequence": rev.sequence })),
)
.await;
let sequence_str = rev.sequence.to_string();
redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Reverted to revision #{sequence}.",
&[("sequence", sequence_str.as_str())],
&headers,
)
}
fn stamp_no_cache(mut response: Response) -> Response {
let h = response.headers_mut();
h.insert(
header::CACHE_CONTROL,
HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
);
h.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
h.insert(header::EXPIRES, HeaderValue::from_static("0"));
h.insert(header::VARY, HeaderValue::from_static("*"));
h.insert(
header::X_FRAME_OPTIONS,
HeaderValue::from_static("SAMEORIGIN"),
);
response
}
async fn inject_axe_into_preview(response: Response) -> Response {
let is_html = response
.headers()
.get(header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok())
.is_some_and(|ct| ct.to_ascii_lowercase().contains("text/html"));
if !is_html {
return response;
}
let (parts, body) = response.into_parts();
let bytes = match axum::body::to_bytes(body, 4 * 1024 * 1024).await {
Ok(b) => b,
Err(_) => {
return (
axum::http::StatusCode::INTERNAL_SERVER_ERROR,
"preview body read failed",
)
.into_response();
}
};
let body_str = match std::str::from_utf8(&bytes) {
Ok(s) => s,
Err(_) => {
return axum::http::Response::from_parts(parts, axum::body::Body::from(bytes));
}
};
let new_body = inject_axe_into_body_str(body_str);
let mut resp = axum::http::Response::from_parts(parts, axum::body::Body::from(new_body));
resp.headers_mut().remove(header::CONTENT_LENGTH);
resp
}
fn inject_axe_into_body_str(body: &str) -> String {
let v = super::cms_asset_version();
let scripts = format!(
"<script src=\"/cms-admin/static/vendor/axe-core.min.js?v={v}\" defer></script>\n\
<script src=\"/cms-admin/static/cms-preview-guard.js?v={v}\" defer></script>\n\
<script src=\"/cms-admin/static/cms-axe-preview.js?v={v}\" defer></script>\n"
);
let lower = body.to_ascii_lowercase();
if let Some(idx) = lower.rfind("</body>") {
let mut out = String::with_capacity(body.len() + scripts.len());
out.push_str(&body[..idx]);
out.push_str(&scripts);
out.push_str(&body[idx..]);
out
} else {
let mut out = String::with_capacity(body.len() + scripts.len());
out.push_str(body);
out.push_str(&scripts);
out
}
}
#[cfg(test)]
mod axe_injection_tests {
use super::inject_axe_into_body_str;
#[test]
fn splices_before_lowercase_body_close() {
let html = "<html><body><h1>hi</h1></body></html>";
let out = inject_axe_into_body_str(html);
assert!(out.contains("axe-core.min.js"), "axe script missing: {out}");
assert!(
out.contains("cms-axe-preview.js"),
"glue script missing: {out}"
);
assert!(
out.contains("cms-preview-guard.js"),
"preview-guard script missing: {out}"
);
let close = out.find("</body>").expect("body close kept");
assert!(
out[..close].contains("axe-core.min.js"),
"axe script should be before </body>: {out}"
);
assert!(
out[..close].contains("cms-axe-preview.js"),
"glue script should be before </body>: {out}"
);
}
#[test]
fn splices_before_uppercase_body_close() {
let html = "<HTML><BODY><h1>hi</h1></BODY></HTML>";
let out = inject_axe_into_body_str(html);
let close = out.find("</BODY>").expect("uppercase body close kept");
assert!(out[..close].contains("axe-core.min.js"));
}
#[test]
fn appends_when_no_body_close() {
let html = "<html><h1>hi</h1>";
let out = inject_axe_into_body_str(html);
assert!(out.contains("cms-axe-preview.js?v="));
assert!(out.trim_end().ends_with("defer></script>"));
assert!(out.contains("axe-core.min.js"));
assert!(out.starts_with("<html><h1>hi</h1>"));
}
#[test]
fn uses_rfind_for_nested_body_close_text() {
let html = "<html><body><pre>literal: </body></pre></body></html>";
let out = inject_axe_into_body_str(html);
let close = out.rfind("</body>").unwrap();
assert!(out[..close].contains("axe-core.min.js"));
assert!(out.contains("literal: </body>"));
}
#[test]
fn empty_body_renders_clean() {
let out = inject_axe_into_body_str("");
assert!(out.contains("axe-core.min.js"));
assert!(out.contains("cms-axe-preview.js"));
}
}
#[derive(serde::Deserialize, Default)]
pub struct PreviewLocaleQuery {
#[serde(default)]
locale: Option<String>,
#[serde(default)]
format: Option<String>,
}
fn preview_tera(state: &super::AdminState, tenant: &Tenant) -> std::sync::Arc<tera::Tera> {
crate::tenant_templates::installed()
.map(|tt| tt.for_tenant(&tenant.org.slug))
.unwrap_or_else(|| state.tera.clone())
}
pub async fn page_preview(
State(state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
) -> Result<Response, AdminError> {
let page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let response = crate::render::render(
&tenant,
&preview_tera(&state, &tenant),
&page,
"",
"",
q.locale.as_deref(),
None,
None,
)
.await;
Ok(stamp_no_cache(inject_axe_into_preview(response).await))
}
pub async fn page_preview_token(
tenant: Tenant,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let exists = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.is_some();
if !exists {
return Err(AdminError::NotFound(id));
}
let expires = chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS;
let token = crate::preview_token::mint(&tenant.org.slug, id, expires);
Ok(Json(serde_json::json!({
"token": token,
"expires_at": expires,
"api_path": format!("/api/v2/pages/{id}/?preview_token={token}"),
}))
.into_response())
}
pub async fn page_preview_draft(
State(state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
headers: HeaderMap,
Form(form_map): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let mut page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(v) = form_map.get("title") {
page.title = v.clone();
}
if let Some(v) = form_map.get("slug") {
page.slug = v.clone();
}
if let Some(v) = form_map
.get("page_type_id")
.and_then(|s| s.parse::<i64>().ok())
{
page.page_type_id = v;
}
if let Some(v) = form_map.get("status") {
page.status = v.clone();
}
if let Some(v) = form_map.get("seo_title") {
page.seo_title = v.clone();
}
if let Some(v) = form_map.get("seo_description") {
page.seo_description = v.clone();
}
page.robots_index = form_map
.get("robots_index")
.map(|v| matches!(v.as_str(), "on" | "true" | "1"))
.unwrap_or(page.robots_index);
if let Some(v) = form_map
.get("sitemap_priority")
.and_then(|s| s.parse::<f32>().ok())
{
page.sitemap_priority = v;
}
if let Some(raw) = form_map.get("theme_id") {
page.theme_id = if raw.is_empty() || raw == "0" {
None
} else {
raw.parse::<i64>().ok()
};
}
let accept = crate::page_view::parse_accept(
headers
.get(axum::http::header::ACCEPT)
.and_then(|v| v.to_str().ok()),
);
let force_json = q.format.as_deref() == Some("json");
let response = crate::render::render_preview(
&tenant,
&preview_tera(&state, &tenant),
&page,
"",
"",
q.locale.as_deref(),
&form_map,
accept,
force_json,
)
.await;
Ok(stamp_no_cache(inject_axe_into_preview(response).await))
}
#[derive(Debug, Deserialize, Default)]
pub struct LibraryListQuery {
#[serde(default)]
pub r#type: Option<String>,
#[serde(default)]
pub folder: Option<String>,
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub page: Option<u32>,
#[serde(default)]
pub per_page: Option<usize>,
#[serde(flatten)]
pub raw_filters: std::collections::HashMap<String, String>,
}
pub async fn library_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<LibraryListQuery>,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
) -> Result<Response, AdminError> {
let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
.order_by(&[("type_name", false)])
.fetch(tenant.pool())
.await?
.into_iter()
.filter(|t| t.type_name != "form")
.collect();
let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.fetch(tenant.pool())
.await?;
let mut counts_by_type: std::collections::HashMap<String, i64> =
std::collections::HashMap::new();
for s in &all_snippets {
*counts_by_type.entry(s.type_name.clone()).or_default() += 1;
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("query_string", &raw_query.unwrap_or_default());
ctx.insert("types", &types);
ctx.insert("counts_by_type", &counts_by_type);
let Some(type_name) = q.r#type.as_deref().filter(|s| !s.is_empty()) else {
ctx.insert("mode", "overview");
return render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx);
};
let handler = crate::library::find_handler(type_name);
let list_display = handler
.as_ref()
.map(|h| h.list_display())
.unwrap_or_else(|| {
vec![
crate::library::ListColumn::Field {
column: "title",
label: "Title",
},
crate::library::ListColumn::Field {
column: "slug",
label: "Slug",
},
crate::library::ListColumn::Field {
column: "updated_at",
label: "Updated",
},
]
});
let search_fields = handler
.as_ref()
.map(|h| h.search_fields())
.unwrap_or_else(|| vec!["title", "slug"]);
let filter_keys = handler
.as_ref()
.map(|h| h.list_filter())
.unwrap_or_default();
let folder = crate::snippet::normalize_folder(q.folder.as_deref().unwrap_or(""));
let child_folders = crate::snippet::child_folders(tenant.pool(), &folder)
.await
.unwrap_or_default();
let mut filtered: Vec<crate::snippet::Snippet> = all_snippets
.iter()
.filter(|s| s.type_name == type_name && s.folder_path == folder)
.filter(|s| handler.as_ref().map(|h| h.can_view(s)).unwrap_or(true))
.cloned()
.collect();
let search_q = q.q.as_deref().map(|s| s.trim()).filter(|s| !s.is_empty());
if let Some(needle) = search_q {
let needle_lower = needle.to_lowercase();
filtered.retain(|s| {
search_fields.iter().any(|field| {
let hay = match *field {
"title" => s.title.to_lowercase(),
"slug" => s.slug.to_lowercase(),
"body_markdown" => s.body_markdown.to_lowercase(),
other => s
.data
.get(other)
.and_then(serde_json::Value::as_str)
.map(str::to_lowercase)
.unwrap_or_default(),
};
hay.contains(&needle_lower)
})
});
}
let mut active_filters: std::collections::HashMap<String, String> =
std::collections::HashMap::new();
for (k, v) in &q.raw_filters {
if let Some(stripped) = k.strip_prefix("filter_") {
if !v.is_empty() {
active_filters.insert(stripped.to_owned(), v.clone());
}
}
}
if !active_filters.is_empty() {
filtered.retain(|s| {
active_filters.iter().all(|(key, want)| {
let got = s
.data
.get(key)
.map(|v| match v {
serde_json::Value::String(s) => s.clone(),
other => other.to_string(),
})
.unwrap_or_default();
got == *want
})
});
}
let filter_options: std::collections::HashMap<String, Vec<String>> = filter_keys
.iter()
.map(|k| {
let mut opts: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
for s in &all_snippets {
if s.type_name != type_name {
continue;
}
if let Some(v) = s.data.get(*k) {
let s = match v {
serde_json::Value::String(s) => s.clone(),
other => other.to_string(),
};
if !s.is_empty() {
opts.insert(s);
}
}
}
((*k).to_owned(), opts.into_iter().collect())
})
.collect();
let total = filtered.len();
let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
let paginator = rustango::pagination::Paginator::new(total, page_size);
let requested_page = q.page.unwrap_or(1).max(1) as i64;
let page_obj = paginator.get_page(requested_page);
let page = page_obj.number;
let total_pages = paginator.num_pages().max(1);
let page_rows: Vec<crate::snippet::Snippet> = if total == 0 {
Vec::new()
} else {
let start = page_obj.start_index().saturating_sub(1);
let end = page_obj.end_index();
filtered[start..end].to_vec()
};
let column_headers: Vec<serde_json::Value> = list_display
.iter()
.map(|c| {
serde_json::json!({
"key": c.key(),
"label": c.label(),
})
})
.collect();
let rows_html: Vec<serde_json::Value> = page_rows
.iter()
.map(|row| {
let cells: Vec<String> = list_display
.iter()
.map(|c| render_list_cell(c, row, handler.as_deref()))
.collect();
serde_json::json!({
"id": row.id.get().copied().unwrap_or_default(),
"slug": row.slug,
"cells": cells,
})
})
.collect();
let active_filters_json: Vec<serde_json::Value> = active_filters
.iter()
.map(|(k, v)| serde_json::json!({ "key": k, "value": v }))
.collect();
let bulk_actions: Vec<serde_json::Value> = handler
.as_ref()
.map(|h| h.bulk_actions())
.unwrap_or_default()
.iter()
.map(serialize_bulk_action)
.collect();
let row_actions: Vec<serde_json::Value> = handler
.as_ref()
.map(|h| h.row_actions())
.unwrap_or_default()
.iter()
.map(serialize_bulk_action)
.collect();
let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_snippet")
.into_iter()
.map(|a| {
serde_json::json!({
"key": a.key,
"label": a.label,
"icon": a.icon,
"danger": a.danger,
"confirm_message": a.confirm_message,
"action_url": a.action_url,
})
})
.collect();
let folder_tree_paths = crate::snippet::folder_tree_for_type(tenant.pool(), type_name)
.await
.unwrap_or_default();
let folder_tree: Vec<serde_json::Value> = folder_tree_paths
.iter()
.map(|p| {
let depth = p.matches('/').count(); let display = if p.is_empty() {
"Root".to_owned()
} else {
p.trim_end_matches('/')
.rsplit('/')
.next()
.unwrap_or("")
.to_owned()
};
serde_json::json!({
"path": p,
"name": display,
"depth": depth,
"active": *p == folder,
})
})
.collect();
ctx.insert("mode", "type");
ctx.insert("active_type", type_name);
ctx.insert("folder", &folder);
ctx.insert("child_folders", &child_folders);
ctx.insert("folder_tree", &folder_tree);
ctx.insert("column_headers", &column_headers);
ctx.insert("rows", &rows_html);
ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
ctx.insert("page", &page);
ctx.insert("total_pages", &total_pages);
ctx.insert(
"pagination",
&crate::admin::pagination::context(page as i64, page_size, total),
);
ctx.insert("total", &total);
ctx.insert("page_size", &page_size);
ctx.insert("search_q", &search_q.unwrap_or(""));
ctx.insert("filter_keys", &filter_keys);
ctx.insert("filter_options", &filter_options);
ctx.insert("active_filters", &active_filters_json);
ctx.insert("bulk_actions", &bulk_actions);
ctx.insert("row_actions", &row_actions);
render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx)
}
fn serialize_bulk_action(a: &crate::library::BulkAction) -> serde_json::Value {
use crate::library::BulkActionStyle;
let style_class = match a.style {
BulkActionStyle::Primary => "btn",
BulkActionStyle::Outlined => "btn btn-outlined",
BulkActionStyle::Danger => "btn btn-danger",
};
serde_json::json!({
"name": a.name,
"label": a.label,
"icon": a.icon,
"confirm_message": a.confirm_message,
"style_class": style_class,
})
}
pub async fn library_bulk_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(type_name): Path<String>,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
let action = form
.iter()
.find(|(k, _)| k == "action")
.map(|(_, v)| v.clone())
.unwrap_or_default();
let ids: Vec<i64> = form
.iter()
.filter(|(k, _)| k == "ids" || k == "id")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
if action.is_empty() || ids.is_empty() {
return redirect_named_with_message(
"rcms-admin:library:list",
MsgLevel::Warning,
"Pick at least one row + a bulk action before submitting.",
&headers,
);
}
let Some(handler) = crate::library::find_handler(&type_name) else {
return Err(AdminError::Validation(format!(
"unknown library type `{type_name}`"
)));
};
let declared: std::collections::HashSet<&'static str> = handler
.bulk_actions()
.iter()
.chain(handler.row_actions().iter())
.map(|a| a.name)
.collect();
if !declared.contains(action.as_str()) {
return Err(AdminError::Validation(format!(
"library type `{type_name}` doesn't declare bulk action `{action}`"
)));
}
let touched = handler
.handle_bulk_action(tenant.pool(), &action, &ids)
.await?;
let count = touched.to_string();
redirect_named_with_message_plural(
"rcms-admin:library:list",
MsgLevel::Success,
"{action}: touched {count} row(s) in `{type_name}`.",
touched as i64,
&[
("action", action.as_str()),
("count", count.as_str()),
("type_name", type_name.as_str()),
],
&headers,
)
}
fn render_list_cell(
col: &crate::library::ListColumn,
row: &crate::snippet::Snippet,
handler: Option<&dyn crate::library::LibraryTypeHandler>,
) -> String {
use crate::library::{ListColumn, ListColumnKind};
match col {
ListColumn::Field { column, .. } => match *column {
"id" => row.id.get().copied().unwrap_or_default().to_string(),
"type_name" => html_escape(&row.type_name),
"slug" => format!("<code>{}</code>", html_escape(&row.slug)),
"folder_path" => html_escape(&row.folder_path),
"title" => format!("<strong>{}</strong>", html_escape(&row.title)),
"body_markdown" => {
let preview: String = row.body_markdown.chars().take(80).collect();
format!("<span>{}</span>", html_escape(&preview))
}
"created_at" => row
.created_at
.get()
.map(|d| d.format("%Y-%m-%d").to_string())
.unwrap_or_default(),
"updated_at" => row
.updated_at
.get()
.map(|d| d.format("%Y-%m-%d").to_string())
.unwrap_or_default(),
other => format!("<em>(unknown field: {})</em>", html_escape(other)),
},
ListColumn::JsonField { key, kind, .. } => {
let val = row.data.get(*key);
match (kind, val) {
(ListColumnKind::Bool, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
(_, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
(ListColumnKind::Integer, Some(serde_json::Value::Number(n)))
| (ListColumnKind::Float, Some(serde_json::Value::Number(n))) => {
html_escape(&n.to_string())
}
(_, Some(serde_json::Value::String(s))) => html_escape(s),
(_, Some(other)) => html_escape(&other.to_string()),
(_, None) => String::new(),
}
}
ListColumn::Method { name, .. } | ListColumn::Computed { name, .. } => handler
.map(|h| h.render_cell(name, row))
.unwrap_or_default(),
}
}
fn html_escape(s: &str) -> String {
s.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
}
fn bool_checkbox_html(b: bool) -> String {
if b {
r#"<span class="material-symbols-rounded sm filled" style="color: var(--accent);" aria-label="true">check_box</span>"#.to_owned()
} else {
r#"<span class="material-symbols-rounded sm" style="color: var(--muted-2);" aria-label="false">check_box_outline_blank</span>"#.to_owned()
}
}
#[derive(Debug, Deserialize)]
pub struct SnippetNewQuery {
#[serde(default)]
pub r#type: Option<String>,
#[serde(default)]
pub folder: Option<String>,
}
pub async fn snippet_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<SnippetNewQuery>,
) -> Result<Response, AdminError> {
let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
.order_by(&[("type_name", false)])
.fetch(tenant.pool())
.await?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert("types", &types);
ctx.insert("preselect_type", &q.r#type.unwrap_or_default());
let folder = q.folder.unwrap_or_default();
ctx.insert(
"snippet",
&serde_json::json!({
"type_name": "",
"slug": "",
"title": "",
"body_markdown": "",
"folder_path": folder,
}),
);
render_with_csrf(&state, &headers, "rcms_admin/snippet_form.html", &mut ctx)
}
pub async fn snippet_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if snippet.type_name == "form" {
let url = rustango::urls::reverse_owned(
"rcms-admin:forms:build",
&std::collections::HashMap::from([("id".to_owned(), id.to_string())]),
)
.map_err(|e| AdminError::Validation(format!("url reversal failed: {e}")))?;
return Ok(axum::response::Redirect::to(&url).into_response());
}
let handler = crate::library::find_handler(&snippet.type_name);
if let Some(h) = handler.as_ref() {
if !h.can_view(&snippet) {
return Err(AdminError::NotFound(id));
}
}
let read_only = handler
.as_ref()
.map(|h| !h.can_edit(&snippet))
.unwrap_or(false);
let can_delete = handler
.as_ref()
.map(|h| h.can_delete(&snippet))
.unwrap_or(true);
let template_path = handler
.as_ref()
.and_then(|h| h.edit_template())
.unwrap_or("rcms_admin/snippet_form.html");
let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
.order_by(&[("type_name", false)])
.fetch(tenant.pool())
.await?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert("types", &types);
ctx.insert("snippet", &snippet);
ctx.insert("read_only", &read_only);
ctx.insert("can_delete", &can_delete);
ctx.insert(
"allows_element_template",
&handler
.as_ref()
.map(|h| h.allows_element_template())
.unwrap_or(false),
);
let revisions_enabled = handler.as_ref().is_some_and(|h| h.revisions_enabled());
let preview_enabled = handler.as_ref().is_some_and(|h| h.preview_enabled());
let revisions: Vec<crate::snippet::SnippetRevision> = if revisions_enabled {
crate::snippet::revisions_for(tenant.pool(), id)
.await
.unwrap_or_default()
} else {
Vec::new()
};
ctx.insert("revisions_enabled", &revisions_enabled);
ctx.insert("preview_enabled", &preview_enabled);
ctx.insert("snippet_revisions", &revisions);
let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let editing_locale = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.and_then(|code| locales.iter().find(|l| l.code == code).cloned());
let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
let mut core_translations: std::collections::HashMap<String, String> =
std::collections::HashMap::new();
let mut extra_translations: Vec<(String, String)> = Vec::new();
if translation_mode {
let lid = editing_locale
.as_ref()
.and_then(|l| l.id.get().copied())
.unwrap_or_default();
let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
.await
.unwrap_or_default();
let core_keys = ["title", "body_markdown"];
core_translations = core_keys
.iter()
.map(|k| {
(
(*k).to_owned(),
existing.get(*k).cloned().unwrap_or_default(),
)
})
.collect();
extra_translations = existing
.iter()
.filter(|(k, _)| !core_keys.contains(&k.as_str()))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
}
ctx.insert("locales", &locales);
ctx.insert("editing_locale", &editing_locale);
ctx.insert("translation_mode", &translation_mode);
ctx.insert("core_translations", &core_translations);
ctx.insert("extra_translations", &extra_translations);
render_with_csrf(&state, &headers, template_path, &mut ctx)
}
pub async fn snippet_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
use crate::snippet_translation::SnippetTranslation;
let code = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
let locale = crate::locale::Locale::objects()
.where_(crate::locale::Locale::code.eq(code.to_owned()))
.where_(crate::locale::Locale::active.eq(true))
.first(tenant.pool())
.await?
.ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
if locale.is_default {
return Ok((
axum::http::StatusCode::BAD_REQUEST,
"cannot translate INTO the default locale; canonical content lives on cms_snippet",
)
.into_response());
}
let locale_id = locale
.id
.get()
.copied()
.ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut updates: Vec<(String, String)> = Vec::new();
for (k, v) in &form {
if let Some(path) = k.strip_prefix("tr__") {
if !path.is_empty() {
updates.push((path.to_owned(), v.clone()));
}
}
}
let new_path_raw = form.get("new_field_path").map(String::as_str).unwrap_or("");
if !new_path_raw.trim().is_empty() {
if let Ok(path) = crate::snippet_translation::validate_field_path(new_path_raw) {
let value = form.get("new_field_value").cloned().unwrap_or_default();
updates.push((path, value));
}
}
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for (path, value) in updates {
let existing: Vec<SnippetTranslation> = SnippetTranslation::objects()
.where_(SnippetTranslation::snippet_id.eq(id))
.where_(SnippetTranslation::locale_id.eq(locale_id))
.where_(SnippetTranslation::field_path.eq(path.clone()))
.fetch_tx(tx)
.await?;
if value.is_empty() {
for row in existing {
row.delete_tx(tx).await?;
}
} else if let Some(mut row) = existing.into_iter().next() {
row.value = value;
row.save_tx(tx).await?;
} else {
let mut row = SnippetTranslation {
id: rustango::sql::Auto::Unset,
snippet_id: id,
locale_id,
field_path: path,
value,
updated_at: rustango::sql::Auto::Unset,
};
row.save_tx(tx).await?;
}
}
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
let back = if snippet.type_name == "form" {
format!("/cms-admin/forms/{id}/build?locale={code}")
} else {
format!("/cms-admin/library/{id}/edit?locale={code}")
};
Ok(Redirect::to(&back).into_response())
}
pub async fn snippet_revert_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((id, sequence)): Path<(i64, i32)>,
) -> Result<Response, AdminError> {
let Some(rev) = crate::snippet::revision_by_sequence(tenant.pool(), id, sequence).await? else {
return Err(AdminError::NotFound(id));
};
let mut snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let snap = &rev.snapshot;
if let Some(v) = snap.get("title").and_then(|v| v.as_str()) {
snippet.title = v.to_owned();
}
if let Some(v) = snap.get("slug").and_then(|v| v.as_str()) {
snippet.slug = v.to_owned();
}
if let Some(v) = snap.get("body_markdown").and_then(|v| v.as_str()) {
snippet.body_markdown = v.to_owned();
}
if let Some(v) = snap.get("folder_path").and_then(|v| v.as_str()) {
snippet.folder_path = v.to_owned();
}
if let Some(v) = snap.get("type_name").and_then(|v| v.as_str()) {
snippet.type_name = v.to_owned();
}
if let Some(v) = snap.get("data") {
snippet.data = v.clone();
}
snippet.save_pool(tenant.pool()).await?;
if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
if handler.revisions_enabled() {
let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by)
.await
.log_warn("revision not captured; the history has a gap");
}
}
let sequence_str = sequence.to_string();
redirect_named_with_params_and_message_args(
"rcms-admin:library:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Reverted to revision #{sequence}.",
&[("sequence", sequence_str.as_str())],
&headers,
)
}
pub async fn snippet_create_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let type_name = form.get("type_name").cloned().unwrap_or_default();
let slug = form.get("slug").cloned().unwrap_or_default();
let title = form.get("title").cloned().unwrap_or_default();
let body = form.get("body_markdown").cloned().unwrap_or_default();
let folder_path = form
.get("folder_path")
.map(|s| crate::snippet::normalize_folder(s))
.unwrap_or_default();
if type_name.is_empty() || slug.is_empty() || title.is_empty() {
return Err(AdminError::Validation(
"type, slug, and title are all required".to_owned(),
));
}
let mut row = crate::snippet::Snippet {
id: rustango::sql::Auto::Unset,
type_name,
slug,
folder_path,
title,
body_markdown: body,
data: serde_json::Value::Object(serde_json::Map::new()),
created_at: rustango::sql::Auto::Unset,
updated_at: rustango::sql::Auto::Unset,
};
row.save_pool(tenant.pool()).await?;
if row.type_name == "form" {
let id = row.id.get().copied().unwrap_or_default();
return redirect_named_with_params_and_message(
"rcms-admin:forms:build",
&[("id", id.to_string())],
MsgLevel::Success,
&super::i18n::tr(
&headers,
"Created snippet “{title}”.",
&[("title", row.title.as_str())],
),
&headers,
);
}
redirect_named_with_message_args(
"rcms-admin:library:list",
MsgLevel::Success,
"Created snippet “{title}”.",
&[("title", row.title.as_str())],
&headers,
)
}
pub async fn snippet_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let mut snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
if !handler.can_edit(&snippet) {
return Err(AdminError::Validation(format!(
"Library type `{}` denies edit on this row.",
snippet.type_name
)));
}
if let Err(errors) = handler.validate(&form) {
let summary: Vec<String> = errors
.into_iter()
.map(|(field, msg)| format!("{field}: {msg}"))
.collect();
return Err(AdminError::Validation(summary.join("; ")));
}
}
if let Some(v) = form.get("type_name") {
if !v.is_empty() {
snippet.type_name = v.clone();
}
}
if let Some(v) = form.get("slug") {
if !v.is_empty() {
snippet.slug = v.clone();
}
}
if let Some(v) = form.get("title") {
snippet.title = v.clone();
}
if let Some(v) = form.get("body_markdown") {
snippet.body_markdown = v.clone();
}
if let Some(v) = form.get("folder_path") {
snippet.folder_path = crate::snippet::normalize_folder(v);
}
if crate::library::find_handler(&snippet.type_name)
.is_some_and(|h| h.allows_element_template())
{
if let Some(v) = form.get("data__template") {
crate::snippet::set_element_template(&mut snippet.data, v.trim());
}
}
snippet.save_pool(tenant.pool()).await?;
if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
if handler.revisions_enabled() {
let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
if let Err(e) =
crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by).await
{
tracing::warn!(
target: "rustango_cms::admin",
snippet_id = id,
type_name = %snippet.type_name,
error = %e,
"snippet revision capture failed",
);
}
}
}
{
let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
for (key, value) in &form {
let mut found = crate::reference_index::scan(value, key);
refs.append(&mut found);
}
if let Err(e) = crate::reference_index::reindex_source(
tenant.pool(),
crate::reference_index::KIND_SNIPPET,
id,
refs,
)
.await
{
tracing::warn!(
target: "rustango_cms::reference_index",
snippet_id = id, error = %e,
"snippet reindex failed (best-effort)"
);
}
}
redirect_named_with_message_args(
"rcms-admin:library:list",
MsgLevel::Success,
"Saved snippet “{title}”.",
&[("title", snippet.title.as_str())],
&headers,
)
}
pub async fn snippet_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
if !handler.can_delete(&snippet) {
return Err(AdminError::Validation(format!(
"Library type `{}` denies delete on this row.",
snippet.type_name
)));
}
}
let title = snippet.title.clone();
let is_form = snippet.type_name == "form";
snippet.delete_pool(tenant.pool()).await?;
if is_form {
let body = super::i18n::tr(&headers, "Deleted snippet “{title}”.", &[("title", title.as_str())]);
return Ok(rustango::messages::redirect_with_message(
messages_secret(),
&headers,
MsgLevel::Success,
&body,
"/cms-admin/forms",
));
}
redirect_named_with_message_args(
"rcms-admin:library:list",
MsgLevel::Success,
"Deleted snippet “{title}”.",
&[("title", title.as_str())],
&headers,
)
}
fn parse_date_floor(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
let raw = raw?.trim();
if raw.is_empty() {
return None;
}
chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
.ok()
.map(|d| {
chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
d.and_hms_opt(0, 0, 0).unwrap_or_default(),
chrono::Utc,
)
})
}
fn parse_date_ceil(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
let raw = raw?.trim();
if raw.is_empty() {
return None;
}
chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
.ok()
.map(|d| {
chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
d.and_hms_opt(23, 59, 59).unwrap_or_default(),
chrono::Utc,
)
})
}
#[derive(Debug, Deserialize)]
pub struct MediaListQuery {
#[serde(default)]
pub page: Option<i64>,
#[serde(default)]
pub per_page: Option<usize>,
#[serde(default)]
pub collection: Option<i64>,
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub from: Option<String>,
#[serde(default)]
pub to: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct CropForm {
pub crop_x: u32,
pub crop_y: u32,
pub crop_w: u32,
pub crop_h: u32,
pub mode: String,
}
pub async fn media_crop_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<CropForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let mut media = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if media.kind != "image" {
return Err(AdminError::Validation(
"Crop applies to images only.".to_owned(),
));
}
let bytes = crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(
&tenant.org.slug,
&media.storage_key,
))
.await
.map_err(|e| AdminError::Validation(format!("read source: {e}")))?;
let (cropped_bytes, out_mime) = crate::rendition::crop_image_off_runtime(
bytes,
media.mime.clone(),
(form.crop_x, form.crop_y, form.crop_w, form.crop_h),
)
.await
.map_err(AdminError::Validation)?;
let new_hash = {
use sha2::Digest;
let mut hasher = sha2::Sha256::new();
hasher.update(&cropped_bytes);
let digest = hasher.finalize();
let mut hex = String::with_capacity(digest.len() * 2);
for b in digest.iter() {
hex.push_str(&format!("{b:02x}"));
}
hex
};
match form.mode.as_str() {
"apply" => {
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &media.storage_key),
&cropped_bytes,
)
.await
.map_err(|e| AdminError::Validation(format!("write crop: {e}")))?;
let old_hash = media.content_hash.clone();
media.content_hash = new_hash;
media.size = cropped_bytes.len() as i64;
media.mime = out_mime;
media.width = Some(form.crop_w as i32);
media.height = Some(form.crop_h as i32);
media.focal_point_x = None;
media.focal_point_y = None;
media.save_pool(tenant.pool()).await?;
for r in crate::rendition::MediaRendition::objects()
.where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
.fetch(tenant.pool())
.await?
{
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
.await
.log_warn("stored file not deleted; the blob is orphaned");
r.delete_pool(tenant.pool()).await?;
}
let crop_w = form.crop_w.to_string();
let crop_h = form.crop_h.to_string();
redirect_named_with_params_and_message_args(
"rcms-admin:media:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Crop applied. New dimensions {width}×{height}; renditions purged.",
&[("width", crop_w.as_str()), ("height", crop_h.as_str())],
&headers,
)
}
"clone" => {
let ext = match out_mime.as_str() {
"image/jpeg" => "jpg",
"image/webp" => "webp",
_ => "png",
};
let new_key = format!("{}-crop-{}.{ext}", &new_hash[..16.min(new_hash.len())], id);
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &new_key),
&cropped_bytes,
)
.await
.map_err(|e| AdminError::Validation(format!("write clone: {e}")))?;
let clone_title = if media.title.contains(" — crop") {
media.title.clone()
} else {
format!("{} — crop", media.title)
};
let mut clone = Media {
id: Auto::Unset,
filename: format!(
"{}.crop.{ext}",
std::path::Path::new(&media.filename)
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "crop".to_owned())
),
content_hash: new_hash,
mime: out_mime,
size: cropped_bytes.len() as i64,
kind: "image".to_owned(),
width: Some(form.crop_w as i32),
height: Some(form.crop_h as i32),
storage_key: new_key,
title: clone_title,
alt_text: media.alt_text.clone(),
description: media.description.clone(),
uploaded_by: media.uploaded_by,
collection_id: media.collection_id,
focal_point_x: None,
focal_point_y: None,
uploaded_at: Auto::Unset,
};
clone.insert_pool(tenant.pool()).await?;
let new_id = clone.id.get().copied().unwrap_or_default();
let new_id_str = new_id.to_string();
let crop_w = form.crop_w.to_string();
let crop_h = form.crop_h.to_string();
redirect_named_with_params_and_message_args(
"rcms-admin:media:edit",
&[("id", new_id.to_string())],
MsgLevel::Success,
"Saved cropped clone as new media #{id} ({width}×{height}).",
&[
("id", new_id_str.as_str()),
("width", crop_w.as_str()),
("height", crop_h.as_str()),
],
&headers,
)
}
other => Err(AdminError::Validation(format!(
"Unknown crop mode `{other}` — expected `apply` or `clone`."
))),
}
}
pub async fn media_replace_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
use sha2::{Digest, Sha256};
let mut media = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut filename = String::new();
let mut bytes: Vec<u8> = Vec::new();
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
if field.name().unwrap_or("") == "file" {
if let Some(fname) = field.file_name() {
filename = sanitize_filename(fname);
}
bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
.to_vec();
} else {
let _ = field.bytes().await;
}
}
if filename.is_empty() || bytes.is_empty() {
return Err(AdminError::Upload("no file submitted".into()));
}
let new_mime = mime_guess::from_path(&filename)
.first_or_octet_stream()
.essence_str()
.to_owned();
refuse_active_upload(&new_mime)?;
let new_kind = Media::classify_mime(&new_mime).to_owned();
if new_kind != media.kind {
return Err(AdminError::Validation(format!(
"Replacement kind `{new_kind}` does not match existing `{}` — replace must keep the media type.",
media.kind
)));
}
let (stored, decoded_dims) =
crate::rendition::strip_exif_off_runtime(bytes, new_mime.clone()).await;
bytes = stored;
let mut hasher = Sha256::new();
hasher.update(&bytes);
let digest = hasher.finalize();
let new_hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
use std::fmt::Write as _;
let _ = write!(acc, "{b:02x}");
acc
});
let new_storage_key = format!("{}-{}", &new_hash[..16.min(new_hash.len())], filename);
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &new_storage_key),
&bytes,
)
.await
.map_err(|e| AdminError::Upload(format!("write: {e}")))?;
let old_storage_key = media.storage_key.clone();
let old_hash = media.content_hash.clone();
let (new_w, new_h): (Option<i32>, Option<i32>) = decoded_dims
.map(|(w, h)| (Some(w as i32), Some(h as i32)))
.unwrap_or((None, None));
media.filename = filename;
media.storage_key = new_storage_key;
media.content_hash = new_hash;
media.mime = new_mime;
media.size = bytes.len() as i64;
media.width = new_w;
media.height = new_h;
media.save_pool(tenant.pool()).await?;
if old_storage_key != media.storage_key {
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(
&tenant.org.slug,
&old_storage_key,
))
.await
.log_warn("stored file not deleted; the blob is orphaned");
}
if old_hash != media.content_hash {
for r in crate::rendition::MediaRendition::objects()
.where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
.fetch(tenant.pool())
.await?
{
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
.await
.log_warn("stored file not deleted; the blob is orphaned");
r.delete_pool(tenant.pool()).await?;
}
}
redirect_named_with_params_and_message(
"rcms-admin:media:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Replaced. Old renditions purged; every page referencing this image now serves the new bytes.",
&headers,
)
}
async fn pages_referencing_media(
pool: &rustango::sql::Pool,
media_id: i64,
) -> Result<Vec<(i64, String, String, String)>, rustango::sql::ExecError> {
let pages: Vec<Page> = Page::objects().fetch(pool).await?;
let mut hits: Vec<(i64, String, String, String)> = Vec::new();
for p in &pages {
let page_id = p.id.get().copied().unwrap_or_default();
if page_id == 0 {
continue;
}
let mut ids = std::collections::BTreeSet::new();
if let Ok(v) = serde_json::to_value(p) {
harvest_media_ids(&v, &mut ids);
}
if let Ok(pts) = PageType::objects()
.where_(PageType::id.eq(p.page_type_id))
.fetch(pool)
.await
{
if let Some(pt_row) = pts.into_iter().next() {
if let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) {
if let Ok(ext) = handler.load_extension(pool, page_id).await {
harvest_media_ids(&ext, &mut ids);
}
}
}
}
if ids.contains(&media_id) {
hits.push((
page_id,
p.title.clone(),
p.url_path.clone(),
p.status.clone(),
));
}
}
Ok(hits)
}
pub async fn media_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let media = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if media.kind != "image" {
return Err(AdminError::NotFound(id));
}
let usages = pages_referencing_media(tenant.pool(), id)
.await
.unwrap_or_default();
let usage_rows: Vec<serde_json::Value> = usages
.iter()
.map(|(pid, title, url_path, status)| {
serde_json::json!({
"id": pid,
"title": title,
"url_path": url_path,
"status": status,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert(
"media",
&serde_json::json!({
"id": media.id.get().copied(),
"title": media.title,
"filename": media.filename,
"alt_text": media.alt_text,
"description": media.description,
"mime": media.mime,
"size": media.size,
"width": media.width,
"height": media.height,
"focal_point_x": media.focal_point_x,
"focal_point_y": media.focal_point_y,
"uploaded_at": media.uploaded_at.get().copied(),
"content_hash": media.content_hash,
}),
);
ctx.insert("usages", &usage_rows);
ctx.insert("usage_count", &(usage_rows.len() as i64));
render_with_csrf(&state, &headers, "rcms_admin/media_edit.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct MediaEditForm {
pub title: String,
pub alt_text: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub focal_point_x: Option<String>,
#[serde(default)]
pub focal_point_y: Option<String>,
}
pub async fn media_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<MediaEditForm>,
) -> Result<Response, AdminError> {
let mut media = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if media.kind != "image" {
return Err(AdminError::NotFound(id));
}
media.title = form.title.trim().to_owned();
media.alt_text = form.alt_text.trim().to_owned();
media.description = form.description.trim().to_owned();
let parse_fraction = |raw: Option<&str>| -> Option<f32> {
raw.map(str::trim)
.filter(|s| !s.is_empty())
.and_then(|s| s.parse::<f32>().ok())
.map(|f| f.clamp(0.0, 1.0))
};
let new_x = parse_fraction(form.focal_point_x.as_deref());
let new_y = parse_fraction(form.focal_point_y.as_deref());
let focal_changed = media.focal_point_x != new_x || media.focal_point_y != new_y;
media.focal_point_x = new_x;
media.focal_point_y = new_y;
media.save_pool(tenant.pool()).await?;
if focal_changed {
let renditions: Vec<crate::rendition::MediaRendition> =
crate::rendition::MediaRendition::objects()
.where_(
crate::rendition::MediaRendition::content_hash.eq(media.content_hash.clone()),
)
.fetch(tenant.pool())
.await?;
for r in renditions {
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
.await
.log_warn("stored file not deleted; the blob is orphaned");
r.delete_pool(tenant.pool()).await?;
}
}
redirect_named_with_params_and_message(
"rcms-admin:media:edit",
&[("id", id.to_string())],
MsgLevel::Success,
if focal_changed {
"Saved. Renditions purged — next request regenerates with the new focal point."
} else {
"Saved."
},
&headers,
)
}
fn json_contains_needle(value: &serde_json::Value, needle: &str) -> bool {
match value {
serde_json::Value::String(s) => {
if s.to_lowercase().contains(needle) {
return true;
}
let trimmed = s.trim_start();
if trimmed.starts_with('[') || trimmed.starts_with('{') {
if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
return json_contains_needle(&parsed, needle);
}
}
false
}
serde_json::Value::Array(arr) => arr.iter().any(|v| json_contains_needle(v, needle)),
serde_json::Value::Object(map) => map.values().any(|v| json_contains_needle(v, needle)),
_ => false,
}
}
fn harvest_media_ids(value: &serde_json::Value, out: &mut std::collections::BTreeSet<i64>) {
use serde_json::Value;
match value {
Value::Object(map) => {
for (key, child) in map {
let is_media_key = key == "media_id" || key.ends_with("_media_id");
if is_media_key {
match child {
Value::Number(n) => {
if let Some(id) = n.as_i64() {
if id > 0 {
out.insert(id);
}
}
}
Value::String(s) => {
if let Ok(id) = s.parse::<i64>() {
if id > 0 {
out.insert(id);
}
}
}
_ => harvest_media_ids(child, out),
}
} else {
harvest_media_ids(child, out);
}
}
}
Value::Array(arr) => {
for item in arr {
harvest_media_ids(item, out);
}
}
Value::String(s) => {
let trimmed = s.trim_start();
if trimmed.starts_with('[') || trimmed.starts_with('{') {
if let Ok(parsed) = serde_json::from_str::<Value>(s) {
harvest_media_ids(&parsed, out);
}
}
}
_ => {}
}
}
pub async fn media_unused_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let all_media: Vec<Media> = Media::objects()
.order_by(&[("uploaded_at", true)])
.fetch(tenant.pool())
.await?;
let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
let mut used: std::collections::BTreeSet<i64> = std::collections::BTreeSet::new();
for p in &pages {
if let Ok(v) = serde_json::to_value(p) {
harvest_media_ids(&v, &mut used);
}
}
for p in &pages {
let page_id = p.id.get().copied().unwrap_or_default();
let pt: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(p.page_type_id))
.fetch(tenant.pool())
.await?;
let Some(pt_row) = pt.into_iter().next() else {
continue;
};
let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) else {
continue;
};
if let Ok(ext_value) = handler.load_extension(tenant.pool(), page_id).await {
harvest_media_ids(&ext_value, &mut used);
}
}
let unused: Vec<&Media> = all_media
.iter()
.filter(|m| m.id.get().copied().is_some_and(|id| !used.contains(&id)))
.collect();
let unused_view: Vec<serde_json::Value> = unused
.iter()
.map(|m| {
serde_json::json!({
"id": m.id.get().copied(),
"title": m.title,
"filename": m.filename,
"kind": m.kind,
"mime": m.mime,
"size": m.size,
"uploaded_at": m.uploaded_at.get().copied(),
"uploaded_by": m.uploaded_by,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "media-unused", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("unused", &unused_view);
ctx.insert("total_media", &all_media.len());
ctx.insert("used_count", &used.len());
render_with_csrf(&state, &headers, "rcms_admin/media_unused.html", &mut ctx)
}
pub async fn media_unused_bulk_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let ids: Vec<i64> = form
.iter()
.filter(|(k, _)| k == "id" || k == "ids")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
let mut deleted = 0usize;
for id in ids {
let row = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?;
if let Some(m) = row {
let _ = Auto::Unset::<i64>; m.delete_pool(tenant.pool()).await?;
deleted += 1;
}
}
redirect_named_with_message_plural(
"rcms-admin:media:unused",
MsgLevel::Success,
"Deleted {count} unused media item(s).",
deleted as i64,
&[("count", &deleted.to_string())],
&headers,
)
}
pub async fn media_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<MediaListQuery>,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
) -> Result<Response, AdminError> {
if rand::random::<u8>() < 5 {
if let Ok(unlinked) = crate::uploaded_file::gc_stale(tenant.pool()).await {
for key in unlinked {
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(&tenant.org.slug, &key))
.await
.log_warn("stored file not deleted; the blob is orphaned");
}
}
}
render_media_list(
&state,
&tenant,
&headers,
session_user.as_ref(),
"image",
q,
raw_query,
)
.await
}
pub async fn documents_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<MediaListQuery>,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
) -> Result<Response, AdminError> {
render_media_list(
&state,
&tenant,
&headers,
session_user.as_ref(),
"document",
q,
raw_query,
)
.await
}
async fn render_media_list(
state: &super::AdminState,
tenant: &Tenant,
headers: &HeaderMap,
session_user: Option<&rustango::tenancy::auth::User>,
kind: &str,
filters: MediaListQuery,
raw_query: Option<String>,
) -> Result<Response, AdminError> {
let collection_filter = filters.collection;
let search = filters
.q
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_lowercase);
let from_filter = parse_date_floor(filters.from.as_deref());
let to_filter = parse_date_ceil(filters.to.as_deref());
let all: Vec<Media> = Media::objects()
.order_by(&[("uploaded_at", true)])
.fetch(tenant.pool())
.await?;
let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
.order_by(&[("sort_order", false), ("name", false)])
.fetch(tenant.pool())
.await?;
let items: Vec<&Media> = all
.iter()
.filter(|m| {
let kind_match = if kind == "image" {
m.kind == "image"
} else {
m.kind != "image"
};
let collection_match = match collection_filter {
None => true,
Some(cid) => m.collection_id == Some(cid),
};
let search_match = match &search {
None => true,
Some(needle) => {
m.title.to_lowercase().contains(needle)
|| m.filename.to_lowercase().contains(needle)
|| m.alt_text.to_lowercase().contains(needle)
}
};
let date_match = m.uploaded_at.get().is_none_or(|when| {
let after_from = from_filter.is_none_or(|floor| *when >= floor);
let before_to = to_filter.is_none_or(|ceil| *when <= ceil);
after_from && before_to
});
kind_match && collection_match && search_match && date_match
})
.collect();
let per_page = crate::admin::pagination::clamp_per_page(filters.per_page);
let requested_page = filters.page.unwrap_or(1);
let total_items = items.len();
let pagination = crate::admin::pagination::context(requested_page, per_page, total_items);
let current_page = pagination["page"].as_i64().unwrap_or(1);
let skip = crate::admin::pagination::offset(current_page, per_page) as usize;
let items: Vec<&Media> = items.into_iter().skip(skip).take(per_page).collect();
let mut counts: std::collections::HashMap<Option<i64>, i64> = std::collections::HashMap::new();
for m in &all {
let in_kind = if kind == "image" {
m.kind == "image"
} else {
m.kind != "image"
};
if in_kind {
*counts.entry(m.collection_id).or_insert(0) += 1;
}
}
let collections_view: Vec<serde_json::Value> = collections
.iter()
.map(|c| {
let id = c.id.get().copied();
serde_json::json!({
"id": id,
"name": c.name,
"parent_id": c.parent_id,
"count": id.and_then(|i| counts.get(&Some(i)).copied()).unwrap_or(0),
})
})
.collect();
let uncategorized_count = counts.get(&None).copied().unwrap_or(0);
let mut ctx = Context::new();
let active_tab = if kind == "image" {
"media"
} else {
"documents"
};
add_chrome(&mut ctx, tenant, active_tab, session_user).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("items", &items);
ctx.insert("collections", &collections_view);
ctx.insert("collection_filter", &collection_filter);
ctx.insert("uncategorized_count", &uncategorized_count);
ctx.insert("search_q", &filters.q);
ctx.insert("date_from", &filters.from);
ctx.insert("date_to", &filters.to);
ctx.insert(
"is_filtered",
&(collection_filter.is_some()
|| search.is_some()
|| from_filter.is_some()
|| to_filter.is_some()),
);
ctx.insert("filtered_count", &total_items);
ctx.insert("pagination", &pagination);
ctx.insert(
"kind_label",
if kind == "image" {
"Media (images)"
} else {
"Documents"
},
);
ctx.insert(
"upload_kind",
if kind == "image" { "image" } else { "document" },
);
ctx.insert(
"self_url",
if kind == "image" {
"/cms-admin/media"
} else {
"/cms-admin/documents"
},
);
ctx.insert("query_string", &raw_query.unwrap_or_default());
ctx.insert("qs_none", &serde_json::Value::Null);
render_with_csrf(state, headers, "rcms_admin/media_list.html", &mut ctx)
}
pub async fn media_upload_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<UploadFormQuery>,
) -> Result<Response, AdminError> {
let kind_label = if q.kind.as_deref() == Some("document") {
"Documents"
} else {
"Media (images)"
};
let mut ctx = Context::new();
add_chrome(
&mut ctx,
&tenant,
if q.kind.as_deref() == Some("document") {
"documents"
} else {
"media"
},
session_user.as_ref(),
)
.await;
let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
.order_by(&[("sort_order", false), ("name", false)])
.fetch(tenant.pool())
.await?;
let collections_view: Vec<serde_json::Value> = collections
.iter()
.map(|c| {
serde_json::json!({
"id": c.id.get().copied(),
"name": c.name,
})
})
.collect();
ctx.insert("collections", &collections_view);
ctx.insert("kind_label", kind_label);
ctx.insert("upload_kind", &q.kind.as_deref().unwrap_or("image"));
render_with_csrf(&state, &headers, "rcms_admin/media_upload.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct UploadFormQuery {
#[serde(default)]
pub kind: Option<String>,
}
pub async fn media_upload_staged(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
use sha2::{Digest, Sha256};
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session_for(Some(&headers)));
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
let mut filename = String::new();
let mut bytes: Vec<u8> = Vec::new();
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
if field.name().unwrap_or("") == "file" {
if let Some(fname) = field.file_name() {
filename = sanitize_filename(fname);
}
bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
.to_vec();
} else {
let _ = field.bytes().await;
}
}
if filename.is_empty() || bytes.is_empty() {
return Err(AdminError::Upload("no file submitted".into()));
}
let mut hasher = Sha256::new();
hasher.update(&bytes);
let digest = hasher.finalize();
let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
use std::fmt::Write as _;
let _ = write!(acc, "{b:02x}");
acc
});
let mime = mime_guess::from_path(&filename)
.first_or_octet_stream()
.essence_str()
.to_owned();
refuse_active_upload(&mime)?;
{
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let existing: Vec<crate::media::Media> = crate::media::Media::objects()
.where_(crate::media::Media::content_hash.eq(hash.clone()))
.fetch(tenant.pool())
.await
.unwrap_or_default();
if let Some(existing_media) = existing.into_iter().next() {
let existing_id = existing_media.id.get().copied().unwrap_or_default();
let payload = serde_json::json!({
"id": null,
"duplicate_of": existing_id,
"duplicate_title": existing_media.title,
"duplicate_filename": existing_media.filename,
"filename": filename,
"mime": existing_media.mime,
"size": existing_media.size,
});
return Ok((
[(axum::http::header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response());
}
}
let storage_key = format!("scratch/{}-{filename}", &hash[..16]);
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &storage_key),
&bytes,
)
.await
.map_err(|e| AdminError::Upload(format!("write: {e}")))?;
let size = bytes.len() as i64;
let row = crate::uploaded_file::create(
tenant.pool(),
viewer_id,
storage_key,
filename,
mime,
size,
hash,
)
.await?;
let payload = serde_json::json!({
"id": row.id.get().copied().unwrap_or_default(),
"filename": row.original_filename,
"mime": row.mime,
"size": row.size,
});
Ok((
[(axum::http::header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct StagedCommitItem {
pub uploaded_file_id: i64,
#[serde(default)]
pub title: String,
#[serde(default)]
pub alt_text: String,
#[serde(default)]
pub collection_id: Option<i64>,
}
#[derive(Debug, Deserialize)]
pub struct StagedCommitPayload {
pub items: Vec<StagedCommitItem>,
}
pub async fn media_upload_staged_commit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Json(payload): Json<StagedCommitPayload>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session_for(Some(&headers)));
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
let media_slug = tenant.org.slug.clone();
let mut committed: Vec<i64> = Vec::new();
let mut failed: Vec<serde_json::Value> = Vec::new();
for item in payload.items {
let result: Result<i64, String> = async {
let row = crate::uploaded_file::get(tenant.pool(), item.uploaded_file_id)
.await
.map_err(|e| format!("lookup: {e}"))?
.ok_or_else(|| "scratch row missing".to_owned())?;
if row.user_id != viewer_id && !viewer.is_superuser {
return Err("not your upload".to_owned());
}
let scratch_key = crate::media_storage::key(&media_slug, &row.storage_key);
let mut bytes = crate::media_storage::disk_for(&media_slug)
.load(&scratch_key)
.await
.map_err(|e| format!("read scratch: {e}"))?;
let (stored, decoded_dims) =
crate::rendition::strip_exif_off_runtime(bytes, row.mime.clone()).await;
bytes = stored;
let final_key = format!(
"{}-{}",
&row.content_hash[..16.min(row.content_hash.len())],
row.original_filename
);
crate::media_storage::disk_for(&media_slug)
.save(&crate::media_storage::key(&media_slug, &final_key), &bytes)
.await
.map_err(|e| format!("write final: {e}"))?;
let kind = Media::classify_mime(&row.mime).to_owned();
let (width, height): (Option<i32>, Option<i32>) = decoded_dims
.map(|(w, h)| (Some(w as i32), Some(h as i32)))
.unwrap_or((None, None));
let title = if item.title.trim().is_empty() {
row.original_filename
.rsplit_once('.')
.map(|(stem, _)| stem.to_owned())
.unwrap_or_else(|| row.original_filename.clone())
} else {
item.title.trim().to_owned()
};
let mut media_row = Media {
id: Auto::Unset,
filename: row.original_filename.clone(),
content_hash: row.content_hash.clone(),
mime: row.mime.clone(),
size: bytes.len() as i64,
kind,
width,
height,
storage_key: final_key,
title,
alt_text: item.alt_text.trim().to_owned(),
description: String::new(),
uploaded_by: Some(viewer_id),
collection_id: item.collection_id,
focal_point_x: None,
focal_point_y: None,
uploaded_at: Auto::Unset,
};
media_row
.insert_pool(tenant.pool())
.await
.map_err(|e| format!("insert media: {e}"))?;
let new_id = media_row.id.get().copied().unwrap_or_default();
crate::media_storage::disk_for(&media_slug)
.delete(&scratch_key)
.await
.log_warn("stored file not deleted; the blob is orphaned");
crate::uploaded_file::delete(tenant.pool(), item.uploaded_file_id)
.await
.map_err(|e| format!("delete scratch: {e}"))?;
Ok(new_id)
}
.await;
match result {
Ok(id) => committed.push(id),
Err(e) => {
failed.push(serde_json::json!({
"uploaded_file_id": item.uploaded_file_id,
"error": e,
}));
}
}
}
let body = serde_json::json!({
"committed": committed,
"failed": failed,
});
Ok((
[(axum::http::header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
pub async fn media_upload_staged_cancel(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session_for(Some(&headers)));
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
let Some(row) = crate::uploaded_file::get(tenant.pool(), id).await? else {
return Ok((axum::http::StatusCode::NOT_FOUND, "not found").into_response());
};
if row.user_id != viewer_id && !viewer.is_superuser {
return Ok((axum::http::StatusCode::FORBIDDEN, "not your upload").into_response());
}
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(
&tenant.org.slug,
&row.storage_key,
))
.await
.log_warn("stored file not deleted; the blob is orphaned");
crate::uploaded_file::delete(tenant.pool(), id).await?;
Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
}
fn refuse_active_upload(mime: &str) -> Result<(), AdminError> {
let active = matches!(
mime,
"text/html"
| "application/xhtml+xml"
| "text/javascript"
| "application/javascript"
| "application/ecmascript"
| "text/xml"
| "application/xml"
| "text/xsl"
| "application/xslt+xml"
);
if active {
return Err(AdminError::Upload(format!(
"files of type {mime} can't be uploaded: a browser would run them as a page"
)));
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn store_media(
pool: &rustango::sql::Pool,
org_slug: &str,
mut bytes: Vec<u8>,
raw_filename: &str,
title: Option<&str>,
alt_text: &str,
collection_id: Option<i64>,
uploaded_by: Option<i64>,
dedupe: bool,
) -> Result<Media, AdminError> {
use rustango::sql::Auto;
use sha2::{Digest, Sha256};
let filename = sanitize_filename(raw_filename);
if filename.is_empty() || bytes.is_empty() {
return Err(AdminError::Upload("no file submitted".into()));
}
let mime = mime_guess::from_path(&filename)
.first_or_octet_stream()
.essence_str()
.to_owned();
refuse_active_upload(&mime)?;
let kind = Media::classify_mime(&mime).to_owned();
let (stored, decoded_dims) = crate::rendition::strip_exif_off_runtime(bytes, mime.clone()).await;
bytes = stored;
let mut hasher = Sha256::new();
hasher.update(&bytes);
let digest = hasher.finalize();
let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
use std::fmt::Write as _;
let _ = write!(acc, "{b:02x}");
acc
});
if dedupe {
if let Some(existing) = Media::objects()
.where_(Media::content_hash.eq(hash.clone()))
.first(pool)
.await?
{
return Ok(existing);
}
}
let storage_key = format!("{}-{}", &hash[..16], filename);
crate::media_storage::disk_for(&org_slug)
.save(&crate::media_storage::key(org_slug, &storage_key), &bytes)
.await
.map_err(|e| AdminError::Upload(format!("write: {e}")))?;
let title = match title {
Some(t) if !t.is_empty() => t.to_owned(),
_ => filename
.rsplit_once('.')
.map(|(stem, _)| stem.to_owned())
.unwrap_or_else(|| filename.clone()),
};
let (width, height): (Option<i32>, Option<i32>) = decoded_dims
.map(|(w, h)| (Some(w as i32), Some(h as i32)))
.unwrap_or((None, None));
let mut row = Media {
id: Auto::Unset,
filename,
content_hash: hash,
mime,
size: bytes.len() as i64,
kind,
width,
height,
storage_key,
title,
alt_text: alt_text.to_owned(),
description: String::new(),
uploaded_by,
collection_id,
focal_point_x: None,
focal_point_y: None,
uploaded_at: Auto::Unset,
};
row.insert_pool(pool).await?;
Ok(row)
}
pub async fn media_upload_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
let mut filename = String::new();
let mut bytes: Vec<u8> = Vec::new();
let mut title = String::new();
let mut alt_text = String::new();
let mut crop_x: Option<u32> = None;
let mut crop_y: Option<u32> = None;
let mut crop_w: Option<u32> = None;
let mut crop_h: Option<u32> = None;
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
let name = field.name().unwrap_or("").to_owned();
match name.as_str() {
"file" => {
if let Some(fname) = field.file_name() {
filename = sanitize_filename(fname);
}
bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
.to_vec();
}
"title" => {
title = field
.text()
.await
.map_err(|e| AdminError::Upload(format!("read title: {e}")))?;
}
"alt_text" => {
alt_text = field
.text()
.await
.map_err(|e| AdminError::Upload(format!("read alt_text: {e}")))?;
}
"crop_x" | "crop_y" | "crop_w" | "crop_h" => {
let value = field
.text()
.await
.map_err(|e| AdminError::Upload(format!("read {name}: {e}")))?;
let parsed: Option<u32> = value.trim().parse().ok();
match name.as_str() {
"crop_x" => crop_x = parsed,
"crop_y" => crop_y = parsed,
"crop_w" => crop_w = parsed,
"crop_h" => crop_h = parsed,
_ => {}
}
}
_ => {
let _ = field.bytes().await;
}
}
}
if filename.is_empty() || bytes.is_empty() {
return Err(AdminError::Upload("no file submitted".into()));
}
if let (Some(x), Some(y), Some(w), Some(h)) = (crop_x, crop_y, crop_w, crop_h) {
if w > 0 && h > 0 {
let detected_mime = mime_guess::from_path(&filename)
.first_or_octet_stream()
.essence_str()
.to_owned();
refuse_active_upload(&detected_mime)?;
if detected_mime == "image/svg+xml" {
return Err(AdminError::Validation(
"Cropping SVG sources isn't supported; upload uncropped, then edit the markup."
.to_owned(),
));
}
if detected_mime.starts_with("image/") {
let (cropped, _out_mime) = crate::rendition::crop_image_off_runtime(
bytes,
detected_mime.clone(),
(x, y, w, h),
)
.await
.map_err(AdminError::Validation)?;
bytes = cropped;
}
}
}
let row = store_media(
tenant.pool(),
&tenant.org.slug,
bytes,
&filename,
(!title.is_empty()).then_some(title.as_str()),
&alt_text,
None,
None,
false,
)
.await?;
let redirect = if row.kind == "image" {
"/cms-admin/media"
} else {
"/cms-admin/documents"
};
Ok(Redirect::to(redirect).into_response())
}
pub async fn media_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = Media::objects()
.where_(Media::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
crate::media_storage::disk_for(&tenant.org.slug)
.delete(&crate::media_storage::key(
&tenant.org.slug,
&row.storage_key,
))
.await
.log_warn("stored file not deleted; the blob is orphaned");
let redirect = if row.kind == "image" {
"/cms-admin/media"
} else {
"/cms-admin/documents"
};
row.delete_pool(tenant.pool()).await?;
Ok(Redirect::to(redirect).into_response())
}
fn sanitize_filename(raw: &str) -> String {
raw.chars()
.map(|c| {
if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
c
} else {
'_'
}
})
.collect()
}
pub async fn model_admin_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
) -> Result<Response, AdminError> {
let Some(ma) = super::model_admin::find(&slug) else {
return Ok((axum::http::StatusCode::NOT_FOUND, "unknown model admin").into_response());
};
let rows_json = (ma.list_rows)(tenant.pool().clone()).await;
let columns = super::model_admin::list_columns(ma.schema);
let header_labels: Vec<&str> = columns.iter().map(|(_, l)| l.as_str()).collect();
let body_rows: Vec<Vec<String>> = rows_json
.iter()
.map(|r| {
columns
.iter()
.map(|(name, _)| super::model_admin::row_cell(r, name))
.collect()
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "model-admin", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("model_label", ma.label);
ctx.insert("model_slug", &slug);
ctx.insert("columns", &header_labels);
ctx.insert("rows", &body_rows);
ctx.insert("total", &body_rows.len());
render_with_csrf(
&state,
&headers,
"rcms_admin/model_admin_list.html",
&mut ctx,
)
}
#[derive(serde::Deserialize, Default)]
pub struct ReportQuery {
pub format: Option<String>,
}
pub async fn report_view(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(slug): Path<String>,
Query(q): Query<ReportQuery>,
) -> Result<Response, AdminError> {
let Some(report) = super::report::find_report(&slug) else {
return Ok((axum::http::StatusCode::NOT_FOUND, "unknown report").into_response());
};
let user_id = session_user.as_ref().and_then(|u| u.id.get().copied());
let columns = report.columns();
let rows = report.rows(tenant.pool(), user_id).await;
if q.format.as_deref() == Some("csv") {
let mut out = String::with_capacity(128 + rows.len() * 64);
let header: Vec<String> = columns.iter().map(|c| csv_escape(c.label)).collect();
out.push_str(&header.join(","));
out.push('\n');
for row in &rows {
let line: Vec<String> = columns
.iter()
.map(|c| csv_escape(&report_cell_string(row.get(c.key))))
.collect();
out.push_str(&line.join(","));
out.push('\n');
}
return Ok(csv_response(&slug, &out));
}
let header_labels: Vec<&str> = columns.iter().map(|c| c.label).collect();
let view_rows: Vec<serde_json::Value> = rows
.iter()
.map(|row| {
let cells: Vec<serde_json::Value> = columns
.iter()
.map(|c| {
serde_json::json!({
"kind": c.kind.as_str(),
"value": report_cell_string(row.get(c.key)),
})
})
.collect();
serde_json::json!({
"edit_url": row.get("edit_url").and_then(|v| v.as_str()),
"cells": cells,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(
&mut ctx,
&tenant,
&format!("report:{slug}"),
session_user.as_ref(),
)
.await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("report_title", report.title());
ctx.insert("report_slug", &slug);
ctx.insert("report_description", &report.description());
ctx.insert("columns", &header_labels);
ctx.insert("rows", &view_rows);
ctx.insert("total", &view_rows.len());
render_with_csrf(&state, &headers, "rcms_admin/report.html", &mut ctx)
}
pub async fn forms_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let pool = tenant.pool();
let rows = forms_list_rows(pool).await?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
add_admin_theme(&mut ctx, pool).await;
ctx.insert("rows", &rows);
ctx.insert("total", &rows.len());
render_with_csrf(&state, &headers, "rcms_admin/forms_list.html", &mut ctx)
}
pub(crate) async fn forms_list_rows(
pool: &rustango::sql::Pool,
) -> Result<Vec<serde_json::Value>, AdminError> {
let mut forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
.fetch(pool)
.await?;
forms.sort_by(|a, b| {
b.updated_at
.get()
.cloned()
.cmp(&a.updated_at.get().cloned())
});
let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
.fetch(pool)
.await?;
let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
let mut last_at: std::collections::HashMap<i64, String> = std::collections::HashMap::new();
for e in &entries {
*counts.entry(e.form_snippet_id).or_default() += 1;
if let Some(at) = e.submitted_at.get() {
let s = at.format("%Y-%m-%d %H:%M").to_string();
let slot = last_at.entry(e.form_snippet_id).or_default();
if s > *slot {
*slot = s;
}
}
}
let rows: Vec<serde_json::Value> = forms
.iter()
.map(|s| {
let id = s.id.get().copied().unwrap_or_default();
let parsed = crate::forms::schema::parse(&s.data).unwrap_or_default();
serde_json::json!({
"id": id,
"title": s.title,
"slug": s.slug,
"fields": parsed.field_count(),
"submissions": counts.get(&id).copied().unwrap_or(0),
"last_submission": last_at.get(&id).cloned().unwrap_or_default(),
"updated_at": s.updated_at.get().map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default(),
"build_url": format!("/cms-admin/forms/{id}/build"),
"submissions_url": format!("/cms-admin/forms/{id}/submissions"),
"delete_url": format!("/cms-admin/library/{id}/delete"),
})
})
.collect();
Ok(rows)
}
pub async fn form_build_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if snippet.type_name != "form" {
return Err(AdminError::NotFound(id));
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("title", &snippet.title);
ctx.insert("form_id", &id);
ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.where_(crate::locale::Locale::is_default.eq(false))
.fetch(tenant.pool())
.await
.unwrap_or_default();
ctx.insert(
"locales",
&locales
.iter()
.map(|l| serde_json::json!({"code": l.code, "name": l.name}))
.collect::<Vec<_>>(),
);
if let Some(code) = q.locale.as_deref().filter(|c| !c.is_empty()) {
if let Some(loc) = locales.iter().find(|l| l.code == code) {
let lid = loc.id.get().copied().unwrap_or(0);
let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
let leaves = crate::forms::schema::translatable_leaves(&form);
let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
.await
.unwrap_or_default();
let mut groups: Vec<serde_json::Value> = Vec::new();
for l in &leaves {
let row = serde_json::json!({
"path": l.path,
"part": l.part,
"n": l.n.to_string(),
"canonical": l.text,
"value": existing.get(&l.path).cloned().unwrap_or_default(),
});
let same = groups
.last()
.is_some_and(|g| g["name"].as_str() == Some(l.group.as_str()));
if same {
if let Some(arr) = groups
.last_mut()
.and_then(|g| g.get_mut("leaves"))
.and_then(|v| v.as_array_mut())
{
arr.push(row);
}
} else {
groups.push(serde_json::json!({ "name": l.group, "leaves": [row] }));
}
}
ctx.insert("editing_locale", &loc.name);
ctx.insert("editing_code", &code);
ctx.insert("trans_groups", &groups);
ctx.insert(
"translate_url",
&format!("/cms-admin/library/{id}/translate"),
);
return render_with_csrf(&state, &headers, "rcms_admin/form_translate.html", &mut ctx);
}
}
ctx.insert("list_url", "/cms-admin/forms");
ctx.insert("publish_url", &format!("/cms-admin/forms/{id}/publish"));
ctx.insert(
"has_unpublished",
&crate::forms::schema::has_unpublished_changes(&snippet.data),
);
let mut draft = crate::forms::schema::parse_draft(&snippet.data);
draft.sanitize_rich_text();
let schema_json = serde_json::to_string(&crate::forms::schema::to_value(&draft))
.unwrap_or_else(|_| "{}".to_owned());
ctx.insert("schema_json", &schema_json);
render_with_csrf(&state, &headers, "rcms_admin/form_builder.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct FormBuildSubmit {
pub schema: String,
}
#[derive(Debug, Deserialize)]
pub struct FormPageTypeCreate {
#[serde(default)]
pub verbose_name: String,
#[serde(default)]
pub type_name: String,
#[serde(default)]
pub allowed_parents: String,
#[serde(default)]
pub allowed_children: String,
#[serde(default)]
pub view_mode: String,
#[serde(default)]
pub workflow: String,
}
#[derive(Debug, Deserialize)]
pub struct FormComponentSubmit {
#[serde(default)]
pub slug: String,
#[serde(default)]
pub label: String,
#[serde(default)]
pub icon: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub schema: String,
}
pub async fn form_preview(
tenant: Tenant,
Path(id): Path<i64>,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let snippet = load_form_snippet(&tenant, id).await?;
let form = crate::forms::schema::parse_draft(&snippet.data);
Ok(render_form_preview(id, &form))
}
pub async fn form_preview_draft(
tenant: Tenant,
Path(id): Path<i64>,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(body): Form<FormBuildSubmit>,
) -> Result<Response, AdminError> {
let snippet = load_form_snippet(&tenant, id).await?;
let form = crate::forms::schema::parse_str(&body.schema)
.unwrap_or_else(|_| crate::forms::schema::parse_draft(&snippet.data));
Ok(render_form_preview(id, &form))
}
async fn load_form_snippet(
tenant: &Tenant,
id: i64,
) -> Result<crate::snippet::Snippet, AdminError> {
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if snippet.type_name != "form" {
return Err(AdminError::NotFound(id));
}
Ok(snippet)
}
fn render_form_preview(id: i64, form: &crate::forms::schema::Form) -> Response {
let inner = crate::forms::render::render_form_html(form, id, "");
let html = format!(
"<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
<title>Form preview</title>\
<style>body{{margin:0;padding:24px;font:14px/1.5 system-ui,sans-serif;}}</style>\
</head><body>{inner}</body></html>"
);
stamp_no_cache(
(
[(
axum::http::header::CONTENT_TYPE,
axum::http::HeaderValue::from_static("text/html; charset=utf-8"),
)],
html,
)
.into_response(),
)
}
pub async fn form_build_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<FormBuildSubmit>,
) -> Result<Response, AdminError> {
let mut snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if snippet.type_name != "form" {
return Err(AdminError::NotFound(id));
}
let mut parsed = crate::forms::schema::parse_str(&form.schema)
.map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
parsed.sanitize_rich_text();
let mut warnings = crate::forms::schema::validate(&parsed);
snippet.data = crate::forms::schema::save_draft_value(&snippet.data, &parsed);
snippet.save_pool(tenant.pool()).await?;
if let Err(e) = crate::notify::targets::sync_form_email(
tenant.pool(),
id,
&snippet.title,
&parsed.settings.notify_emails,
)
.await
{
tracing::warn!(
target: "rustango_cms::notify",
error = %e, form_id = id,
"could not sync the form's email notification target"
);
warnings.push(format!("Email notifications are off: {e}."));
}
let (level, msg) = if warnings.is_empty() {
(MsgLevel::Success, "Draft saved.".to_owned())
} else {
(
MsgLevel::Warning,
format!("Draft saved with warnings: {}", warnings.join(" ")),
)
};
redirect_named_with_params_and_message(
"rcms-admin:forms:build",
&[("id", id.to_string())],
level,
&msg,
&headers,
)
}
pub async fn form_publish_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<FormBuildSubmit>,
) -> Result<Response, AdminError> {
let mut snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if snippet.type_name != "form" {
return Err(AdminError::NotFound(id));
}
let mut parsed = crate::forms::schema::parse_str(&form.schema)
.map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
parsed.sanitize_rich_text();
snippet.data = crate::forms::schema::publish_value(&parsed);
snippet.save_pool(tenant.pool()).await?;
if let Some(h) = crate::library::find_handler(&snippet.type_name) {
if h.revisions_enabled() {
let uid = session_user.as_ref().and_then(|u| u.id.get().copied());
crate::snippet::capture_revision(tenant.pool(), &snippet, uid)
.await
.log_warn("revision not captured; the history has a gap");
}
}
redirect_named_with_params_and_message(
"rcms-admin:forms:build",
&[("id", id.to_string())],
MsgLevel::Success,
"Form published — the live form is now up to date.",
&headers,
)
}
async fn load_form_submissions(
pool: &rustango::sql::Pool,
form_id: i64,
) -> Result<
(
crate::snippet::Snippet,
Vec<(String, String)>,
Vec<crate::forms::submit::FormEntry>,
std::collections::HashMap<i64, String>,
),
AdminError,
> {
let snippet = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.eq(form_id))
.where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
.first(pool)
.await?
.ok_or(AdminError::NotFound(form_id))?;
let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
let columns: Vec<(String, String)> = form
.fields()
.filter(|f| f.field_type.collects_value() && !f.key.is_empty())
.map(|f| {
(
f.key.clone(),
if f.label.is_empty() {
f.key.clone()
} else {
f.label.clone()
},
)
})
.collect();
let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
.where_(crate::forms::submit::FormEntry::form_snippet_id.eq(form_id))
.order_by(&[("submitted_at", true)])
.fetch(pool)
.await?;
let mut page_urls = std::collections::HashMap::new();
let ids: Vec<i64> = entries
.iter()
.map(|e| e.source_page_id)
.filter(|i| *i != 0)
.collect();
if !ids.is_empty() {
if let Ok(pages) = crate::page::Page::objects().fetch(pool).await {
for p in pages {
if let Some(pid) = p.id.get().copied() {
if ids.contains(&pid) {
page_urls.insert(pid, p.url_path.clone());
}
}
}
}
}
Ok((snippet, columns, entries, page_urls))
}
fn submission_cell(data: &serde_json::Value, key: &str) -> String {
match data.get(key) {
Some(serde_json::Value::Array(items)) => items
.iter()
.filter_map(|v| v.as_str().map(str::to_owned))
.collect::<Vec<_>>()
.join("; "),
Some(serde_json::Value::String(s)) => s.clone(),
Some(other) => other.to_string(),
None => String::new(),
}
}
pub async fn form_submissions_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
let parsed = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
let file_keys: std::collections::HashSet<String> = parsed
.fields()
.filter(|f| matches!(f.field_type, crate::forms::schema::FieldType::File))
.map(|f| f.key.clone())
.collect();
let rows: Vec<serde_json::Value> = entries
.iter()
.map(|e| {
let cells: Vec<serde_json::Value> = columns
.iter()
.map(|(k, _)| {
let v = submission_cell(&e.data_json, k);
if file_keys.contains(k) && !v.is_empty() {
let name = v.splitn(2, '-').nth(1).unwrap_or(&v).to_owned();
serde_json::json!({
"value": name,
"url": format!("/cms-admin/forms/{id}/submissions/file/{v}"),
})
} else {
serde_json::json!({ "value": v })
}
})
.collect();
serde_json::json!({
"submitted_at": e
.submitted_at
.get()
.map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
.unwrap_or_default(),
"submitted_at_text": e
.submitted_at
.get()
.map(|t| t.format("%Y-%m-%d %H:%M UTC").to_string())
.unwrap_or_default(),
"ip": e.ip,
"source_page": if e.source_page_id == 0 {
serde_json::Value::Null
} else {
serde_json::json!({
"id": e.source_page_id,
"url": page_urls.get(&e.source_page_id).cloned().unwrap_or_default(),
})
},
"cells": cells,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("form_title", &snippet.title);
ctx.insert("form_id", &id);
ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
ctx.insert(
"csv_url",
&format!("/cms-admin/forms/{id}/submissions/export.csv"),
);
ctx.insert(
"columns",
&columns.iter().map(|(_, l)| l).collect::<Vec<_>>(),
);
ctx.insert("rows", &rows);
ctx.insert("total", &entries.len());
render_with_csrf(
&state,
&headers,
"rcms_admin/form_submissions.html",
&mut ctx,
)
}
pub async fn form_submissions_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
let mut out = String::new();
out.push_str("submitted_at,source_page,ip");
for (_, label) in &columns {
out.push(',');
out.push_str(&csv_escape(label));
}
out.push('\n');
for e in &entries {
let when = e
.submitted_at
.get()
.map(ToString::to_string)
.unwrap_or_default();
let src = if e.source_page_id == 0 {
String::new()
} else {
page_urls
.get(&e.source_page_id)
.cloned()
.unwrap_or_default()
};
out.push_str(&csv_escape(&when));
out.push(',');
out.push_str(&csv_escape(&src));
out.push(',');
out.push_str(&csv_escape(&e.ip));
for (k, _) in &columns {
out.push(',');
out.push_str(&csv_escape(&submission_cell(&e.data_json, k)));
}
out.push('\n');
}
let filename = format!("submissions-{}.csv", snippet.slug);
Ok(csv_response(&filename, &out))
}
pub async fn form_submission_file(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((_id, key)): Path<(i64, String)>,
) -> Result<Response, AdminError> {
if key.contains('/') || key.contains('\\') || key.contains("..") || key.is_empty() {
return Err(AdminError::NotFound(0));
}
let path = std::path::PathBuf::from("./var/form-uploads")
.join(&tenant.org.slug)
.join(&key);
let bytes = std::fs::read(&path).map_err(|_| AdminError::NotFound(0))?;
let mime = mime_guess::from_path(&key)
.first_or_octet_stream()
.essence_str()
.to_owned();
let download = key.splitn(2, '-').nth(1).unwrap_or(&key).to_owned();
Ok((
[
(header::CONTENT_TYPE, mime),
(
header::CONTENT_DISPOSITION,
format!("attachment; filename=\"{download}\""),
),
],
bytes,
)
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct SetLangQuery {
pub lang: String,
}
pub async fn admin_set_language(
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(q): Form<SetLangQuery>,
) -> Response {
let lang = if super::i18n::is_ui_locale(&q.lang) {
q.lang
} else {
"en".to_owned()
};
if let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
persist_user_admin_lang(tenant.pool(), uid, &lang)
.await
.log_warn("admin language preference not saved");
}
let back = headers
.get(header::REFERER)
.and_then(|v| v.to_str().ok())
.and_then(|r| match r.split_once("://") {
Some((_, rest)) => rest.find('/').map(|i| &rest[i..]),
None => Some(r),
})
.and_then(rustango::auth_decorators::safe_next)
.unwrap_or_else(|| "/cms-admin/".to_owned());
let cookie = format!(
"{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
super::i18n::ADMIN_LANG_COOKIE
);
let mut resp = axum::response::Redirect::to(&back).into_response();
if let Ok(v) = HeaderValue::from_str(&cookie) {
resp.headers_mut().append(header::SET_COOKIE, v);
}
resp
}
fn csv_escape(s: &str) -> String {
if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
let mut out = String::with_capacity(s.len() + 2);
out.push('"');
for c in s.chars() {
if c == '"' {
out.push('"');
}
out.push(c);
}
out.push('"');
out
} else {
s.to_owned()
}
}
fn report_cell_string(v: Option<&serde_json::Value>) -> String {
match v {
Some(serde_json::Value::String(s)) => s.clone(),
None | Some(serde_json::Value::Null) => String::new(),
Some(other) => other.to_string(),
}
}
pub async fn locale_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let items: Vec<Locale> = Locale::objects()
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let rows: Vec<serde_json::Value> = items
.iter()
.map(|l| {
let info = rustango::i18n::locale_info(&l.code);
let ui = super::i18n::is_ui_locale(&l.code);
let mut v = serde_json::to_value(l).unwrap_or_default();
v["support"] = serde_json::json!({
"ui_translated": ui,
"known": info.known,
"display_name": info.display_name,
"has_plural_rules": info.has_plural_rules,
"is_rtl": info.is_rtl,
"content_only": !ui,
});
v
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("items", &rows);
render_with_csrf(&state, &headers, "rcms_admin/locale_list.html", &mut ctx)
}
fn insert_known_locales(ctx: &mut Context) {
let known: Vec<serde_json::Value> = rustango::i18n::known_locales()
.map(|(code, name)| serde_json::json!({ "code": code, "name": name }))
.collect();
let meta: serde_json::Map<String, serde_json::Value> = rustango::i18n::known_locales()
.map(|(code, _)| {
let info = rustango::i18n::locale_info(code);
(
code.to_owned(),
serde_json::json!({
"ui": super::i18n::is_ui_locale(code),
"is_rtl": info.is_rtl,
"has_plural_rules": info.has_plural_rules,
}),
)
})
.collect();
ctx.insert("known_locales", &known);
ctx.insert("known_locales_meta", &serde_json::Value::Object(meta));
}
pub async fn locale_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
insert_known_locales(&mut ctx);
ctx.insert("mode", "new");
ctx.insert(
"locale",
&serde_json::json!({
"code": "",
"name": "",
"is_default": false,
"active": true,
"sort_order": 100,
}),
);
render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct LocaleForm {
pub code: String,
pub name: String,
#[serde(default)]
pub is_default: Option<String>,
#[serde(default)]
pub active: Option<String>,
#[serde(default)]
pub sort_order: Option<i32>,
}
impl LocaleForm {
fn parsed_default(&self) -> bool {
self.is_default.is_some()
}
fn parsed_active(&self) -> bool {
self.active.is_some()
}
fn parsed_sort_order(&self) -> i32 {
self.sort_order.unwrap_or(100)
}
}
pub async fn locale_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<LocaleForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let name = form.name.trim().to_owned();
if name.is_empty() {
return Err(AdminError::Validation(
"Display name is required.".to_owned(),
));
}
let mut row = Locale {
id: Auto::Unset,
code: crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?,
name,
is_default: form.parsed_default(),
active: form.parsed_active(),
sort_order: form.parsed_sort_order(),
created_at: Auto::Unset,
};
if row.is_default {
clear_default_flag(&tenant, None).await?;
}
row.insert_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:locales:list",
MsgLevel::Success,
"Added locale {name} ({code}).",
&[("name", row.name.as_str()), ("code", row.code.as_str())],
&headers,
)
}
pub async fn locale_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = Locale::objects()
.where_(Locale::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
insert_known_locales(&mut ctx);
ctx.insert("mode", "edit");
ctx.insert("locale", &row);
render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
}
pub async fn locale_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<LocaleForm>,
) -> Result<Response, AdminError> {
let mut row = Locale::objects()
.where_(Locale::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let name = form.name.trim().to_owned();
if name.is_empty() {
return Err(AdminError::Validation(
"Display name is required.".to_owned(),
));
}
row.code = crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?;
row.name = name;
row.is_default = form.parsed_default();
row.active = form.parsed_active();
row.sort_order = form.parsed_sort_order();
if row.is_default {
clear_default_flag(&tenant, Some(id)).await?;
}
row.save_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:locales:list",
MsgLevel::Success,
"Saved locale {name} ({code}).",
&[("name", row.name.as_str()), ("code", row.code.as_str())],
&headers,
)
}
pub async fn locale_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = Locale::objects()
.where_(Locale::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
if row.is_default {
return redirect_named_with_message(
"rcms-admin:locales:list",
MsgLevel::Error,
"Cannot delete the default locale — promote another locale to default first.",
&headers,
);
}
let label = format!("{} ({})", row.name, row.code);
let pages = crate::translation::Translation::objects()
.where_(crate::translation::Translation::locale_id.eq(id))
.compile_delete()
.map_err(rustango::sql::ExecError::from)?;
let snippets = crate::snippet_translation::SnippetTranslation::objects()
.where_(crate::snippet_translation::SnippetTranslation::locale_id.eq(id))
.compile_delete()
.map_err(rustango::sql::ExecError::from)?;
let menus = crate::menu_item_translation::MenuItemTranslation::objects()
.where_(crate::menu_item_translation::MenuItemTranslation::locale_id.eq(id))
.compile_delete()
.map_err(rustango::sql::ExecError::from)?;
let categories = crate::category_translation::CategoryTranslation::objects()
.where_(crate::category_translation::CategoryTranslation::locale_id.eq(id))
.compile_delete()
.map_err(rustango::sql::ExecError::from)?;
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for q in [&pages, &snippets, &menus, &categories] {
rustango::sql::delete_tx(tx, q).await?;
}
row.delete_tx(tx).await?;
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
redirect_named_with_message_args(
"rcms-admin:locales:list",
MsgLevel::Success,
"Deleted locale {label}.",
&[("label", label.as_str())],
&headers,
)
}
const SSO_KINDS: &[(&str, &str)] = &[
("google", "Google"),
("microsoft", "Microsoft"),
("github", "GitHub"),
("gitlab", "GitLab"),
("discord", "Discord"),
("oidc", "Generic OpenID Connect"),
];
fn sso_provider_json(p: &rustango::admin::SsoProvider) -> serde_json::Value {
serde_json::json!({
"id": p.id.get().copied().unwrap_or_default(),
"slug": p.slug,
"label": p.label,
"kind": p.kind,
"issuer_url": p.issuer_url,
"client_id": p.client_id,
"has_secret": !p.client_secret.is_empty(),
"enabled": p.enabled,
"sort_order": p.sort_order,
"scopes": p.scopes,
})
}
pub async fn sso_provider_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
use rustango::sql::FetcherPool as _;
let mut items: Vec<rustango::admin::SsoProvider> = rustango::admin::SsoProvider::objects()
.fetch(tenant.pool())
.await
.unwrap_or_default();
items.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.slug.cmp(&b.slug)));
let rows: Vec<serde_json::Value> = items.iter().map(sso_provider_json).collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("items", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/sso_provider_list.html",
&mut ctx,
)
}
#[derive(Deserialize)]
pub struct SsoProviderForm {
pub slug: String,
pub label: String,
pub kind: String,
#[serde(default)]
pub issuer_url: String,
pub client_id: String,
#[serde(default)]
pub client_secret: String,
#[serde(default)]
pub scopes: String,
#[serde(default)]
pub enabled: Option<String>,
#[serde(default)]
pub sort_order: Option<i32>,
}
impl SsoProviderForm {
fn validated(&self) -> Result<ValidatedProvider, String> {
let slug = self.slug.trim().to_lowercase();
if slug.is_empty()
|| !slug
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
{
return Err(
"Slug is required and may only contain letters, numbers, - and _.".to_owned(),
);
}
let label = self.label.trim().to_owned();
if label.is_empty() {
return Err("Button label is required.".to_owned());
}
let kind = self.kind.trim().to_lowercase();
if !SSO_KINDS.iter().any(|(k, _)| *k == kind) {
return Err("Pick a provider type.".to_owned());
}
let client_id = self.client_id.trim().to_owned();
if client_id.is_empty() {
return Err("Client ID is required.".to_owned());
}
let issuer = self.issuer_url.trim().to_owned();
if kind == "oidc" && issuer.is_empty() {
return Err("A generic OpenID Connect provider needs an issuer URL.".to_owned());
}
let scopes = self.scopes.trim().to_owned();
Ok(ValidatedProvider {
slug,
label,
kind,
issuer_url: (!issuer.is_empty()).then_some(issuer),
client_id,
scopes: (!scopes.is_empty()).then_some(scopes),
enabled: self.enabled.is_some(),
sort_order: self.sort_order.unwrap_or(0),
})
}
}
struct ValidatedProvider {
slug: String,
label: String,
kind: String,
issuer_url: Option<String>,
client_id: String,
scopes: Option<String>,
enabled: bool,
sort_order: i32,
}
fn render_sso_provider_form(ctx: &mut Context, mode: &str, provider: serde_json::Value) {
let kinds: Vec<serde_json::Value> = SSO_KINDS
.iter()
.map(|(k, name)| serde_json::json!({ "key": k, "name": name }))
.collect();
ctx.insert("mode", mode);
ctx.insert("kinds", &kinds);
ctx.insert("provider", &provider);
}
pub async fn sso_provider_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
render_sso_provider_form(
&mut ctx,
"new",
serde_json::json!({
"slug": "", "label": "", "kind": "google", "issuer_url": null,
"client_id": "", "has_secret": false, "scopes": null,
"enabled": true, "sort_order": 0,
}),
);
render_with_csrf(
&state,
&headers,
"rcms_admin/sso_provider_form.html",
&mut ctx,
)
}
async fn find_sso_provider(
tenant: &Tenant,
id: i64,
) -> Result<rustango::admin::SsoProvider, AdminError> {
use rustango::sql::FetcherPool as _;
rustango::admin::SsoProvider::objects()
.filter("id", id)
.fetch(tenant.pool())
.await
.map_err(|e| AdminError::Validation(format!("db: {e}")))?
.into_iter()
.next()
.ok_or(AdminError::NotFound(id))
}
pub async fn sso_provider_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let row = find_sso_provider(&tenant, id).await?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
render_sso_provider_form(&mut ctx, "edit", sso_provider_json(&row));
render_with_csrf(
&state,
&headers,
"rcms_admin/sso_provider_form.html",
&mut ctx,
)
}
pub async fn sso_provider_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<SsoProviderForm>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let v = form.validated().map_err(AdminError::Validation)?;
let secret = form.client_secret.trim().to_owned();
if secret.is_empty() {
return Err(AdminError::Validation(
"Client secret is required.".to_owned(),
));
}
let mut row = rustango::admin::SsoProvider {
id: rustango::sql::Auto::Unset,
slug: v.slug,
label: v.label,
kind: v.kind,
issuer_url: v.issuer_url,
client_id: v.client_id,
client_secret: rustango::casts::Cast::new(secret),
enabled: v.enabled,
sort_order: v.sort_order,
scopes: v.scopes,
allow_email_link: false,
created_at: rustango::sql::Auto::Unset,
updated_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:sso-providers:list",
MsgLevel::Success,
"Added SSO provider {label}.",
&[("label", row.label.as_str())],
&headers,
)
}
pub async fn sso_provider_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<SsoProviderForm>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut row = find_sso_provider(&tenant, id).await?;
let v = form.validated().map_err(AdminError::Validation)?;
row.slug = v.slug;
row.label = v.label;
row.kind = v.kind;
row.issuer_url = v.issuer_url;
row.client_id = v.client_id;
let new_secret = form.client_secret.trim();
if !new_secret.is_empty() {
row.client_secret = rustango::casts::Cast::new(new_secret.to_owned());
}
row.enabled = v.enabled;
row.sort_order = v.sort_order;
row.scopes = v.scopes;
row.save_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:sso-providers:list",
MsgLevel::Success,
"Saved SSO provider {label}.",
&[("label", row.label.as_str())],
&headers,
)
}
pub async fn sso_provider_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let row = find_sso_provider(&tenant, id).await?;
let label = row.label.clone();
row.delete_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:sso-providers:list",
MsgLevel::Success,
"Deleted SSO provider {label}.",
&[("label", label.as_str())],
&headers,
)
}
async fn clear_default_flag(tenant: &Tenant, except: Option<i64>) -> Result<(), AdminError> {
let rows: Vec<Locale> = Locale::objects()
.where_(Locale::is_default.eq(true))
.fetch(tenant.pool())
.await?;
for mut r in rows {
if let (Some(skip), Some(id)) = (except, r.id.get().copied()) {
if skip == id {
continue;
}
}
r.is_default = false;
r.save_pool(tenant.pool()).await?;
}
Ok(())
}
pub async fn workflows_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let items: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let all_tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
.fetch(tenant.pool())
.await?;
let mut task_counts: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
for t in &all_tasks {
*task_counts.entry(t.workflow_id).or_insert(0) += 1;
}
let rows: Vec<serde_json::Value> = items
.iter()
.map(|w| {
let id = w.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": id,
"name": w.name,
"description": w.description,
"active": w.active,
"require_reapproval_on_edit": w.require_reapproval_on_edit,
"task_count": task_counts.get(&id).copied().unwrap_or(0),
"created_at": w.created_at.get().copied(),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("items", &rows);
render_with_csrf(&state, &headers, "rcms_admin/workflow_list.html", &mut ctx)
}
pub async fn workflow_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert(
"workflow",
&serde_json::json!({
"name": "",
"description": "",
"active": true,
"require_reapproval_on_edit": false,
}),
);
ctx.insert("tasks", &Vec::<serde_json::Value>::new());
ctx.insert("roles", &Vec::<serde_json::Value>::new());
render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct WorkflowForm {
pub name: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub active: Option<String>,
#[serde(default)]
pub require_reapproval_on_edit: Option<String>,
}
impl WorkflowForm {
fn parsed_active(&self) -> bool {
self.active.is_some()
}
fn parsed_reapproval(&self) -> bool {
self.require_reapproval_on_edit.is_some()
}
}
pub async fn workflow_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<WorkflowForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let name = form.name.trim().to_owned();
if name.is_empty() {
return redirect_named_with_message(
"rcms-admin:workflows:list",
MsgLevel::Error,
"Workflow name is required.",
&headers,
);
}
let mut row = crate::workflow::Workflow {
id: Auto::Unset,
name: name.clone(),
description: form.description.trim().to_owned(),
active: form.parsed_active(),
require_reapproval_on_edit: form.parsed_reapproval(),
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
let id = row.id.get().copied().unwrap_or_default();
redirect_named_with_params_and_message_args(
"rcms-admin:workflows:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Created workflow “{name}”. Add review steps below.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn workflow_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
.order_by(&[("sort_order", false), ("id", false)])
.fetch(tenant.pool())
.await?;
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let role_rows: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
serde_json::json!({
"id": r.id.get().copied(),
"name": r.name,
})
})
.collect();
let role_by_id: std::collections::HashMap<i64, String> = roles
.iter()
.filter_map(|r| r.id.get().copied().map(|id| (id, r.name.clone())))
.collect();
let task_rows: Vec<serde_json::Value> = tasks
.iter()
.map(|t| {
serde_json::json!({
"id": t.id.get().copied(),
"name": t.name,
"role_id": t.role_id,
"role_name": role_by_id.get(&t.role_id).cloned().unwrap_or_default(),
"sort_order": t.sort_order,
"kind": t.kind,
"webhook_url": t.webhook_url,
})
})
.collect();
let mut task_kinds: Vec<serde_json::Value> = crate::task_kind::registered_kinds()
.iter()
.map(|k| {
serde_json::json!({
"name": k.kind_name(),
"verbose_name": k.verbose_name(),
})
})
.collect();
task_kinds.sort_by_key(|k| k["name"] != "group_approval");
let kind_label = |name: &str| {
crate::task_kind::registered_kinds()
.iter()
.find(|k| k.kind_name() == name)
.map_or_else(|| name.to_owned(), |k| k.verbose_name().to_owned())
};
let task_rows: Vec<serde_json::Value> = task_rows
.into_iter()
.map(|mut t| {
let label = kind_label(t["kind"].as_str().unwrap_or_default());
t["kind_label"] = serde_json::Value::String(label);
t
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert("workflow", &row);
ctx.insert("tasks", &task_rows);
ctx.insert("roles", &role_rows);
ctx.insert("task_kinds", &task_kinds);
render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
}
pub async fn workflow_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<WorkflowForm>,
) -> Result<Response, AdminError> {
let mut row = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let old_name = row.name.clone();
row.name = form.name.trim().to_owned();
row.description = form.description.trim().to_owned();
row.active = form.parsed_active();
row.require_reapproval_on_edit = form.parsed_reapproval();
row.save_pool(tenant.pool()).await?;
if old_name != row.name {
crate::workflow::rebind_page_types(tenant.pool(), &old_name, &row.name).await?;
}
redirect_named_with_params_and_message_args(
"rcms-admin:workflows:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Saved workflow “{name}”.",
&[("name", row.name.as_str())],
&headers,
)
}
pub async fn workflow_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let users: Vec<String> = crate::workflow::page_types_using(tenant.pool(), &row.name)
.await?
.into_iter()
.map(|pt| pt.verbose_name)
.collect();
if !users.is_empty() {
let types = users.join(", ");
return redirect_named_with_message_args(
"rcms-admin:workflows:list",
MsgLevel::Error,
"Can't delete “{title}” — the page types {types} use it. Choose another workflow for them first.",
&[("title", row.name.as_str()), ("types", types.as_str())],
&headers,
);
}
let in_use: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
.where_(crate::workflow::WorkflowState::workflow_id.eq(id))
.fetch(tenant.pool())
.await?;
if !in_use.is_empty() {
let count = in_use.len().to_string();
return redirect_named_with_message_plural(
"rcms-admin:workflows:list",
MsgLevel::Error,
"Can't delete “{title}” — {count} page(s) have history under it. Toggle Active off instead.",
in_use.len() as i64,
&[("title", row.name.as_str()), ("count", count.as_str())],
&headers,
);
}
let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
.fetch(tenant.pool())
.await?;
for t in tasks {
t.delete_pool(tenant.pool()).await?;
}
let name = row.name.clone();
row.delete_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:workflows:list",
MsgLevel::Success,
"Deleted workflow “{name}”.",
&[("name", name.as_str())],
&headers,
)
}
#[derive(Debug, Deserialize)]
pub struct WorkflowTaskForm {
pub name: String,
pub role_id: i64,
#[serde(default)]
pub kind: Option<String>,
#[serde(default)]
pub webhook_url: Option<String>,
}
pub async fn workflow_task_add(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(workflow_id): Path<i64>,
Form(form): Form<WorkflowTaskForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let name = form.name.trim().to_owned();
if name.is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:workflows:edit",
&[("id", workflow_id.to_string())],
MsgLevel::Error,
"Step name is required.",
&headers,
);
}
let existing: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
.order_by(&[("sort_order", true)]) .fetch(tenant.pool())
.await?;
let next_order = existing.first().map_or(10, |t| t.sort_order + 10);
let kind = form
.kind
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.filter(|s| crate::task_kind::find(s).is_some())
.unwrap_or("group_approval")
.to_owned();
let webhook_url = form
.webhook_url
.as_deref()
.map(str::trim)
.unwrap_or("")
.to_owned();
let mut row = crate::workflow::WorkflowTask {
id: Auto::Unset,
workflow_id,
name: name.clone(),
role_id: form.role_id,
sort_order: next_order,
kind,
webhook_url,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_params_and_message_args(
"rcms-admin:workflows:edit",
&[("id", workflow_id.to_string())],
MsgLevel::Success,
"Added step “{name}”.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn workflow_task_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((workflow_id, task_id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
let row = crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::id.eq(task_id))
.where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(task_id))?;
let name = row.name.clone();
row.delete_pool(tenant.pool()).await?;
redirect_named_with_params_and_message_args(
"rcms-admin:workflows:edit",
&[("id", workflow_id.to_string())],
MsgLevel::Success,
"Removed step “{name}”.",
&[("name", name.as_str())],
&headers,
)
}
#[derive(Debug, Deserialize)]
pub struct WorkflowDecisionForm {
#[serde(default)]
pub comment: String,
#[serde(default)]
pub task_id: Option<i64>,
}
fn step_already_decided(page_id: i64, headers: &HeaderMap) -> Result<Response, AdminError> {
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", page_id.to_string())],
MsgLevel::Error,
"That review step was already decided — check the page's current step before deciding again.",
headers,
)
}
async fn user_is_in_role(
pool: &rustango::sql::Pool,
user_id: i64,
role_id: i64,
) -> Result<bool, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let rows: Vec<rustango::tenancy::permissions::UserRole> =
rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
.where_(rustango::tenancy::permissions::UserRole::role_id.eq(role_id))
.fetch(pool)
.await?;
Ok(!rows.is_empty())
}
pub async fn page_workflow_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let page = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let pts: Vec<PageType> = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.fetch(tenant.pool())
.await?;
let Some(pt) = pts.into_iter().next() else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Page type row not found.",
&headers,
);
};
let Some(slug) = pt.workflow_name() else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"This page type isn't bound to a workflow — nothing to submit.",
&headers,
);
};
let Some(workflow) = crate::workflow::find_by_name(tenant.pool(), &slug).await? else {
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Workflow `{slug}` not found or inactive — ask an admin to enable it.",
&[("slug", slug.as_str())],
&headers,
);
};
let tasks = crate::workflow::tasks_for(
tenant.pool(),
workflow.id.get().copied().unwrap_or_default(),
)
.await?;
if tasks.is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Workflow has no review steps yet — ask an admin to add at least one step.",
&headers,
);
}
if let Some(active) = crate::workflow::active_state_for_page(tenant.pool(), id).await? {
if active.status == crate::workflow::WorkflowStatus::InProgress.as_str() {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Warning,
"This page is already under review.",
&headers,
);
}
}
crate::workflow::submit_for_review(tenant.pool(), id, &workflow, &tasks, viewer_id).await?;
crate::lock::release(tenant.pool(), id, viewer_id)
.await
.log_warn("editor lock not released on submit");
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_WORKFLOW_SUBMIT,
Some(viewer_id),
format!(
"Submitted for review — workflow “{}”, first step “{}”.",
workflow.name, tasks[0].name
),
Some(serde_json::json!({
"workflow_id": workflow.id.get().copied(),
"workflow_name": workflow.name,
"first_task": tasks[0].name,
})),
)
.await;
notify_workflow(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
"submit",
&workflow.name,
&page.title,
id,
Some(&tasks[0].name),
session_user.as_ref().map(|u| u.username.as_str()),
None,
WorkflowRecipients::Role(tasks[0].role_id),
)
.await;
redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Submitted for review — first step: “{name}”.",
&[("name", tasks[0].name.as_str())],
&headers,
)
}
enum WorkflowRecipients {
Role(i64),
User(i64),
}
#[allow(clippy::too_many_arguments)]
async fn notify_workflow(
mailer: Option<&dyn rustango::email::Mailer>,
from: &str,
pool: &rustango::sql::Pool,
tenant_slug: &str,
event: &str,
workflow_name: &str,
page_title: &str,
page_id: i64,
task_name: Option<&str>,
actor_username: Option<&str>,
comment: Option<&str>,
recipients: WorkflowRecipients,
) {
let Some(mailer) = mailer else {
return;
};
let kind = crate::notification_pref::pref_kind_for_workflow_event(event);
let candidate_user_ids: Vec<i64> = match recipients {
WorkflowRecipients::Role(role_id) => {
crate::workflow_mail::role_member_user_ids(pool, role_id)
.await
.unwrap_or_default()
}
WorkflowRecipients::User(user_id) => vec![user_id],
};
let allowed_ids = crate::notification_pref::filter_enabled(pool, &candidate_user_ids, kind)
.await
.unwrap_or(candidate_user_ids);
let mut pairs: Vec<(String, String)> = Vec::with_capacity(allowed_ids.len());
for uid in allowed_ids {
if let Ok(Some(pair)) = crate::workflow_mail::user_email(pool, uid, tenant_slug).await {
pairs.push(pair);
}
}
if pairs.is_empty() {
return;
}
let (subject, body) = crate::workflow_mail::render_notification(
event,
workflow_name,
page_title,
page_id,
task_name,
actor_username,
comment,
);
crate::workflow_mail::notify_many(mailer, from, &pairs, &subject, &body).await;
}
pub async fn page_workflow_approve(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<WorkflowDecisionForm>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"No active workflow on this page.",
&headers,
);
};
let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
let Some(current_task) = state
.current_task_id
.and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Workflow has no current task — refresh the page.",
&headers,
);
};
if !viewer.is_superuser
&& !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
{
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Only members of the task's role can approve “{name}”.",
&[("name", current_task.name.as_str())],
&headers,
);
}
if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
return step_already_decided(id, &headers);
}
let submitter_id = state.requested_by;
let page_title: String = Page::objects()
.where_(Page::id.eq(id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|p| p.title)
.unwrap_or_else(|| format!("page #{id}"));
let workflow_name: String = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(state.workflow_id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|w| w.name)
.unwrap_or_else(|| "Workflow".to_owned());
let outcome = crate::workflow::approve_current(
tenant.pool(),
&mut state,
&tasks,
viewer_id,
&form.comment,
)
.await?;
let msg = match outcome {
crate::workflow::ApproveOutcome::AlreadyDecided => {
return step_already_decided(id, &headers);
}
crate::workflow::ApproveOutcome::Advanced { next_task_id } => {
let next = tasks
.iter()
.find(|t| t.id.get().copied() == Some(next_task_id));
let next_name = next.map(|t| t.name.as_str()).unwrap_or("next step");
if let Some(nt) = next {
notify_workflow(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
"approve_advance",
&workflow_name,
&page_title,
id,
Some(&nt.name),
Some(&viewer.username),
Some(&form.comment),
WorkflowRecipients::Role(nt.role_id),
)
.await;
}
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_WORKFLOW_APPROVE,
Some(viewer_id),
format!(
"Approved “{}” — advanced to “{next_name}”.",
current_task.name
),
Some(serde_json::json!({
"outcome": "advanced",
"task_name": current_task.name,
"next_task_name": next_name,
"comment": form.comment,
})),
)
.await;
format!("Approved “{}” — moved to “{next_name}”.", current_task.name)
}
crate::workflow::ApproveOutcome::Finished => {
if let Some(pending) = crate::pending_change::for_page(tenant.pool(), id).await? {
match apply_page_edit(
tenant.pool(),
&tenant.org.slug,
&_state.cache_invalidator,
_state.mailer.as_deref(),
&_state.mailer_from,
false,
id,
&pending.form_map(),
None,
)
.await
{
Ok(Ok(_)) => crate::pending_change::discard(tenant.pool(), id).await?,
Ok(Err(_)) | Err(_) => {
tracing::warn!(page_id = id, "held change could not be applied on approval");
}
}
}
if let Some(mut page) = Page::objects()
.where_(Page::id.eq(id))
.first(tenant.pool())
.await?
{
page.status = crate::page::PageStatus::Published.as_str().to_owned();
let now = chrono::Utc::now();
if page.published_at.is_none() {
page.published_at = Some(now);
}
page.last_published_at = Some(now);
page.save_pool(tenant.pool()).await?;
crate::page::went_live_effects(&tenant.org.slug, &page).await;
crate::task_queue::purge_urls(
_state.cache_invalidator.clone(),
tenant.org.slug.clone(),
vec![page.url_path.clone()],
)
.await;
crate::page_subscription::notify_publish(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
id,
&page.title,
&page.url_path,
Some(&viewer.username),
)
.await;
}
notify_workflow(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
"approve_finish",
&workflow_name,
&page_title,
id,
Some(¤t_task.name),
Some(&viewer.username),
Some(&form.comment),
WorkflowRecipients::User(submitter_id),
)
.await;
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_WORKFLOW_APPROVE,
Some(viewer_id),
format!(
"Approved “{}” — workflow complete; page auto-published.",
current_task.name
),
Some(serde_json::json!({
"outcome": "finished",
"task_name": current_task.name,
"comment": form.comment,
})),
)
.await;
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_PUBLISH,
Some(viewer_id),
"Published via workflow approval.",
Some(serde_json::json!({ "via": "workflow" })),
)
.await;
format!(
"Approved “{}” — workflow complete, page published.",
current_task.name
)
}
};
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
&msg,
&headers,
)
}
pub async fn page_workflow_reject(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<WorkflowDecisionForm>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"No active workflow on this page.",
&headers,
);
};
let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
let Some(current_task) = state
.current_task_id
.and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Workflow has no current task — refresh the page.",
&headers,
);
};
if !viewer.is_superuser
&& !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
{
return redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Only members of the task's role can reject “{name}”.",
&[("name", current_task.name.as_str())],
&headers,
);
}
if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
return step_already_decided(id, &headers);
}
if form.comment.trim().is_empty() {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Error,
"Say what should change — the author sees it in the review history.",
&headers,
);
}
let submitter_id = state.requested_by;
let workflow_id = state.workflow_id;
if !crate::workflow::reject_current(tenant.pool(), &mut state, viewer_id, &form.comment).await? {
return step_already_decided(id, &headers);
}
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_WORKFLOW_REJECT,
Some(viewer_id),
format!("Rejected “{}” — changes requested.", current_task.name),
Some(serde_json::json!({
"task_name": current_task.name,
"comment": form.comment,
})),
)
.await;
let workflow_name: String = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(workflow_id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|w| w.name)
.unwrap_or_else(|| "Workflow".to_owned());
let page_title: String = Page::objects()
.where_(Page::id.eq(id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|p| p.title)
.unwrap_or_else(|| format!("page #{id}"));
notify_workflow(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
"reject",
&workflow_name,
&page_title,
id,
Some(¤t_task.name),
Some(&viewer.username),
Some(&form.comment),
WorkflowRecipients::User(submitter_id),
)
.await;
redirect_named_with_params_and_message_args(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Rejected “{name}” — page returned to author for changes.",
&[("name", current_task.name.as_str())],
&headers,
)
}
pub async fn page_workflow_cancel(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
return redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Warning,
"This page isn't currently under review.",
&headers,
);
};
let submitter_id = state.requested_by;
let workflow_id = state.workflow_id;
crate::workflow::cancel(tenant.pool(), &mut state, viewer_id).await?;
crate::page_log::record_or_warn(
tenant.pool(),
id,
crate::page_log::ACTION_WORKFLOW_CANCEL,
Some(viewer_id),
"Workflow cancelled.",
Some(serde_json::json!({ "workflow_id": workflow_id })),
)
.await;
let workflow_name: String = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.eq(workflow_id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|w| w.name)
.unwrap_or_else(|| "Workflow".to_owned());
let page_title: String = Page::objects()
.where_(Page::id.eq(id))
.fetch(tenant.pool())
.await
.ok()
.and_then(|v| v.into_iter().next())
.map(|p| p.title)
.unwrap_or_else(|| format!("page #{id}"));
let actor_username = session_user.as_ref().map(|u| u.username.as_str());
notify_workflow(
_state.mailer.as_deref(),
&_state.mailer_from,
tenant.pool(),
&tenant.org.slug,
"cancel",
&workflow_name,
&page_title,
id,
None,
actor_username,
None,
WorkflowRecipients::User(submitter_id),
)
.await;
redirect_named_with_params_and_message(
"rcms-admin:pages:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Workflow cancelled.",
&headers,
)
}
pub async fn page_log_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let entries = crate::page_log::for_page(tenant.pool(), id, None).await?;
let user_ids: std::collections::BTreeSet<i64> =
entries.iter().filter_map(|e| e.actor_id).collect();
let users: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
std::collections::HashMap::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(
rustango::tenancy::auth::User::id.is_in(user_ids.into_iter().collect::<Vec<_>>()),
)
.fetch(tenant.pool())
.await?
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect()
};
let mut out = String::with_capacity(4096);
out.push_str("timestamp,action,actor_id,actor_username,message,data_json\n");
for e in entries {
let ts = e
.created_at
.get()
.map(|t| t.to_rfc3339())
.unwrap_or_default();
let actor_id = e.actor_id.map(|i| i.to_string()).unwrap_or_default();
let actor_username = e
.actor_id
.and_then(|uid| users.get(&uid).cloned())
.unwrap_or_default();
out.push_str(&csv_escape(&ts));
out.push(',');
out.push_str(&csv_escape(&e.action));
out.push(',');
out.push_str(&csv_escape(&actor_id));
out.push(',');
out.push_str(&csv_escape(&actor_username));
out.push(',');
out.push_str(&csv_escape(&e.message));
out.push(',');
out.push_str(&csv_escape(&e.data_json));
out.push('\n');
}
let filename = format!("page-{id}-audit-log.csv");
Ok((
[
(
axum::http::header::CONTENT_TYPE,
"text/csv; charset=utf-8".to_owned(),
),
(
axum::http::header::CONTENT_DISPOSITION,
format!("attachment; filename=\"{filename}\""),
),
],
out,
)
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct HistoryQuery {
#[serde(default)]
pub page_id: Option<i64>,
#[serde(default)]
pub user_id: Option<i64>,
#[serde(default)]
pub page: Option<u32>,
#[serde(default)]
pub per_page: Option<usize>,
}
pub async fn history_page(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<HistoryQuery>,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
) -> Result<Response, AdminError> {
let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
let mut revisions_query =
crate::revision::Revision::objects().order_by(&[("created_at", true)]); if let Some(pid) = q.page_id {
revisions_query = revisions_query.where_(crate::revision::Revision::page_id.eq(pid));
}
if let Some(uid) = q.user_id {
revisions_query =
revisions_query.where_(crate::revision::Revision::created_by.eq(Some(uid)));
}
let all: Vec<crate::revision::Revision> = revisions_query.fetch(tenant.pool()).await?;
let total = all.len();
let paginator = rustango::pagination::Paginator::new(total, page_size);
let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
let current_page = page_obj.number as u32;
let has_next = page_obj.has_next();
let has_prev = page_obj.has_previous();
let revisions: Vec<crate::revision::Revision> = if total == 0 {
Vec::new()
} else {
all[page_obj.start_index().saturating_sub(1)..page_obj.end_index()].to_vec()
};
let page_ids: std::collections::BTreeSet<i64> = revisions.iter().map(|r| r.page_id).collect();
let user_ids: std::collections::BTreeSet<i64> =
revisions.iter().filter_map(|r| r.created_by).collect();
let pages: Vec<Page> = if page_ids.is_empty() {
Vec::new()
} else {
Page::objects()
.where_(Page::id.is_in(page_ids.iter().copied()))
.fetch(tenant.pool())
.await?
};
let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
Vec::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids.iter().copied()))
.fetch(tenant.pool())
.await?
};
let pages_by_id: std::collections::HashMap<i64, &Page> = pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let users_by_id: std::collections::HashMap<i64, &rustango::tenancy::auth::User> = users
.iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u)))
.collect();
let mut latest_seq_by_page: std::collections::HashMap<i64, i32> =
std::collections::HashMap::new();
for r in &all {
let cur = latest_seq_by_page.entry(r.page_id).or_insert(r.sequence);
if r.sequence > *cur {
*cur = r.sequence;
}
}
let mut by_page: std::collections::HashMap<i64, Vec<&crate::revision::Revision>> =
std::collections::HashMap::new();
for r in &all {
by_page.entry(r.page_id).or_default().push(r);
}
let mut prev_by_id: std::collections::HashMap<i64, (i64, i32)> =
std::collections::HashMap::new();
for (_pid, mut list) in by_page {
list.sort_by_key(|r| r.sequence);
for window in list.windows(2) {
let earlier = window[0];
let later = window[1];
if let (Some(later_id), Some(earlier_id)) =
(later.id.get().copied(), earlier.id.get().copied())
{
prev_by_id.insert(later_id, (earlier_id, earlier.sequence));
}
}
}
let rows: Vec<serde_json::Value> = revisions
.iter()
.map(|r| {
let page = pages_by_id.get(&r.page_id);
let user = r.created_by.and_then(|uid| users_by_id.get(&uid));
let created_at = r.created_at.get().copied();
let (prev_id, prev_sequence) =
r.id.get()
.copied()
.and_then(|id| prev_by_id.get(&id).copied())
.map(|(a, b)| (Some(a), Some(b)))
.unwrap_or((None, None));
let is_latest = latest_seq_by_page
.get(&r.page_id)
.is_some_and(|s| *s == r.sequence);
serde_json::json!({
"id": r.id.get().copied(),
"page_id": r.page_id,
"sequence": r.sequence,
"created_at": created_at,
"page_title": page.map(|p| p.title.clone()),
"page_url_path": page.map(|p| p.url_path.clone()),
"page_status": page.map(|p| p.status.as_str()),
"username": user.map(|u| u.username.clone()),
"system_user": r.created_by.is_none(),
"is_latest": is_latest,
"prev_id": prev_id,
"prev_sequence": prev_sequence,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("filter_page_id", &q.page_id);
ctx.insert("filter_user_id", &q.user_id);
ctx.insert("query_string", &raw_query.unwrap_or_default());
ctx.insert("current_page", ¤t_page);
ctx.insert("has_next", &has_next);
ctx.insert("has_prev", &has_prev);
ctx.insert("total", &total);
ctx.insert("page_size", &page_size);
ctx.insert(
"pagination",
&crate::admin::pagination::context(current_page as i64, page_size, total),
);
render_with_csrf(&state, &headers, "rcms_admin/history.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct HistoryDiffQuery {
pub a: i64,
pub b: i64,
#[serde(default)]
pub all: Option<String>,
}
pub async fn history_diff(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(page_id): Path<i64>,
Query(q): Query<HistoryDiffQuery>,
) -> Result<Response, AdminError> {
let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
.where_(crate::revision::Revision::page_id.eq(page_id))
.where_(crate::revision::Revision::id.is_in([q.a, q.b]))
.fetch(tenant.pool())
.await?;
let a_row = revisions
.iter()
.find(|r| r.id.get().copied() == Some(q.a))
.cloned()
.ok_or(AdminError::NotFound(q.a))?;
let b_row = revisions
.iter()
.find(|r| r.id.get().copied() == Some(q.b))
.cloned()
.ok_or(AdminError::NotFound(q.b))?;
let page = Page::objects()
.where_(Page::id.eq(page_id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(page_id))?;
let user_ids: Vec<i64> = [a_row.created_by, b_row.created_by]
.into_iter()
.flatten()
.collect();
let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
Vec::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids))
.fetch(tenant.pool())
.await?
};
let username_for = |uid: Option<i64>| -> Option<String> {
uid.and_then(|id| {
users
.iter()
.find(|u| u.id.get().copied() == Some(id))
.map(|u| u.username.clone())
})
};
let diffs = crate::revision::diff_snapshots(&a_row.snapshot, &b_row.snapshot);
let changed_count = diffs.iter().filter(|d| d.is_change()).count();
let only_changes = q.all.is_none();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("page", &page);
ctx.insert(
"rev_a",
&serde_json::json!({
"id": a_row.id.get().copied(),
"sequence": a_row.sequence,
"created_at": a_row.created_at.get().copied(),
"username": username_for(a_row.created_by),
}),
);
ctx.insert(
"rev_b",
&serde_json::json!({
"id": b_row.id.get().copied(),
"sequence": b_row.sequence,
"created_at": b_row.created_at.get().copied(),
"username": username_for(b_row.created_by),
}),
);
ctx.insert("diffs", &diffs);
ctx.insert("changed_count", &changed_count);
ctx.insert("only_changes", &only_changes);
render_with_csrf(&state, &headers, "rcms_admin/history_diff.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct AnalyticsQuery {
#[serde(default)]
pub days: Option<i64>,
}
pub async fn analytics_dashboard(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<AnalyticsQuery>,
) -> Result<Response, AdminError> {
let days = q.days.unwrap_or(30).clamp(1, 365);
let to = chrono::Utc::now();
let from = to - chrono::Duration::days(days);
let metrics = crate::analytics::query::compute(tenant.pool(), from, to).await?;
let host = headers
.get(header::HOST)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
let active_now = crate::analytics::presence_count(host);
let series_max = metrics
.series
.iter()
.map(|p| p.pageviews)
.max()
.unwrap_or(0)
.max(1);
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "analytics", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("metrics", &metrics);
ctx.insert("active_now", &active_now);
ctx.insert("series_max", &series_max);
ctx.insert("days", &days);
render_with_csrf(&state, &headers, "rcms_admin/analytics.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct AgingQuery {
#[serde(default)]
pub min_days: Option<i64>,
#[serde(default)]
pub status: Option<String>,
#[serde(default)]
pub page: Option<u32>,
#[serde(default)]
pub per_page: Option<usize>,
}
pub async fn aging_pages_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<AgingQuery>,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
) -> Result<Response, AdminError> {
let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
let min_days = q.min_days.unwrap_or(90).max(0);
let status_filter = q
.status
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty() && *s != "all")
.map(str::to_owned)
.unwrap_or_else(|| "published".to_owned());
let now = chrono::Utc::now();
let mut q_pages = Page::objects().order_by(&[("updated_at", false)]); if status_filter != "all" {
q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
}
let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
let stale: Vec<&Page> = all
.iter()
.filter(|p| match p.updated_at.get().copied() {
Some(ts) => {
let delta = now.signed_duration_since(ts).num_days();
delta >= min_days
}
None => false,
})
.collect();
let total = stale.len();
let paginator = rustango::pagination::Paginator::new(total, page_size);
let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
let current_page = page_obj.number as u32;
let has_next = page_obj.has_next();
let has_prev = page_obj.has_previous();
let slice: Vec<&&Page> = if total == 0 {
Vec::new()
} else {
stale[page_obj.start_index().saturating_sub(1)..page_obj.end_index()]
.iter()
.collect()
};
let page_ids: Vec<i64> = slice.iter().filter_map(|p| p.id.get().copied()).collect();
let revisions: Vec<crate::revision::Revision> = if page_ids.is_empty() {
Vec::new()
} else {
crate::revision::Revision::objects()
.where_(crate::revision::Revision::page_id.is_in(page_ids.iter().copied()))
.order_by(&[("sequence", true)]) .fetch(tenant.pool())
.await
.unwrap_or_default()
};
let mut last_editor_by_page: std::collections::HashMap<i64, Option<i64>> =
std::collections::HashMap::new();
for r in &revisions {
last_editor_by_page.entry(r.page_id).or_insert(r.created_by);
}
let user_ids: Vec<i64> = last_editor_by_page
.values()
.filter_map(|opt| *opt)
.collect();
let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
Vec::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids))
.fetch(tenant.pool())
.await
.unwrap_or_default()
};
let username_by_id: std::collections::HashMap<i64, String> = users
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect();
let rows: Vec<serde_json::Value> = slice
.iter()
.map(|p| {
let pid = p.id.get().copied().unwrap_or_default();
let updated = p.updated_at.get().copied();
let days_stale = updated.map(|ts| now.signed_duration_since(ts).num_days());
let editor = last_editor_by_page
.get(&pid)
.and_then(|v| *v)
.and_then(|uid| username_by_id.get(&uid).cloned());
serde_json::json!({
"id": pid,
"title": p.title,
"url_path": p.url_path,
"status": p.status,
"updated_at": updated,
"days_stale": days_stale,
"last_editor": editor,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "reports", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("min_days", &min_days);
ctx.insert("status_filter", &status_filter);
ctx.insert("query_string", &raw_query.unwrap_or_default());
ctx.insert("current_page", ¤t_page);
ctx.insert("has_next", &has_next);
ctx.insert("has_prev", &has_prev);
ctx.insert("total", &total);
ctx.insert("page_size", &page_size);
ctx.insert(
"pagination",
&crate::admin::pagination::context(current_page as i64, page_size, total),
);
render_with_csrf(&state, &headers, "rcms_admin/aging_pages.html", &mut ctx)
}
pub async fn aging_pages_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Query(q): Query<AgingQuery>,
) -> Result<Response, AdminError> {
let min_days = q.min_days.unwrap_or(90).max(0);
let status_filter = q
.status
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty() && *s != "all")
.map(str::to_owned)
.unwrap_or_else(|| "published".to_owned());
let now = chrono::Utc::now();
let mut q_pages = Page::objects().order_by(&[("updated_at", false)]);
if status_filter != "all" {
q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
}
let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
let stale: Vec<&Page> = all
.iter()
.filter(|p| match p.updated_at.get().copied() {
Some(ts) => now.signed_duration_since(ts).num_days() >= min_days,
None => false,
})
.collect();
let mut out = String::with_capacity(256 + stale.len() * 96);
out.push_str("page_id,title,url_path,status,updated_at,days_stale\n");
for p in stale {
let pid = p.id.get().copied().unwrap_or_default();
let updated = p.updated_at.get().copied();
let days = updated
.map(|ts| now.signed_duration_since(ts).num_days())
.unwrap_or_default();
let when = updated.map(|t| t.to_rfc3339()).unwrap_or_default();
out.push_str(&format!(
"{},{},{},{},{},{}\n",
pid,
csv_escape(&p.title),
csv_escape(&p.url_path),
csv_escape(&p.status),
csv_escape(&when),
days
));
}
Ok(csv_response("aging-pages", &out))
}
fn csv_response(name: &str, body: &str) -> Response {
let filename = format!("{name}-{}.csv", chrono::Utc::now().format("%Y%m%d"));
let mut response = (
[(header::CONTENT_TYPE, "text/csv; charset=utf-8")],
body.to_owned(),
)
.into_response();
if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
response
.headers_mut()
.insert(header::CONTENT_DISPOSITION, v);
}
response
}
pub async fn site_settings_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = crate::site_setting::list_all(tenant.pool())
.await
.unwrap_or_default();
let by_scope: std::collections::HashMap<&str, &crate::site_setting::SiteSetting> =
rows.iter().map(|r| (r.scope.as_str(), r)).collect();
let mut view: Vec<serde_json::Value> = Vec::new();
for schema in crate::site_setting::registered_schemas() {
let row = by_scope.get(schema.scope).copied();
view.push(serde_json::json!({
"scope": schema.scope,
"label": schema.label,
"typed": true,
"configured": row.is_some(),
"preview": row
.map(|r| serde_json::to_string(&r.value_json).unwrap_or_default())
.unwrap_or_default(),
"updated_at": row.and_then(|r| r.updated_at.get().copied()),
}));
}
for s in &rows {
if crate::site_setting::schema_for(&s.scope).is_some() {
continue;
}
view.push(serde_json::json!({
"scope": s.scope,
"label": s.scope,
"typed": false,
"configured": true,
"preview": serde_json::to_string(&s.value_json).unwrap_or_default(),
"updated_at": s.updated_at.get().copied(),
}));
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &view);
render_with_csrf(
&state,
&headers,
"rcms_admin/site_settings_list.html",
&mut ctx,
)
}
pub async fn site_setting_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(scope): Path<String>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let row = crate::site_setting::get(tenant.pool(), &scope)
.await
.unwrap_or(None);
let stored = row
.as_ref()
.map(|s| s.value_json.clone())
.unwrap_or_else(|| serde_json::json!({}));
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("scope", &scope);
ctx.insert("is_new", &row.is_none());
if let Some(schema) = crate::site_setting::schema_for(&scope) {
let widgets = crate::site_setting::prefill_widgets((schema.fields)(), &stored);
ctx.insert("typed", &true);
ctx.insert("schema_label", schema.label);
let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let editing = q
.locale
.as_deref()
.and_then(|c| locales.iter().find(|l| l.code == c && !l.is_default).cloned());
if let (Some(loc), false) = (&editing, row.is_none()) {
let tr = crate::site_setting::translations(&stored, &loc.code);
let rows: Vec<serde_json::Value> = widgets
.iter()
.filter(|w| site_setting_translatable(w))
.map(|w| {
serde_json::json!({
"name": w.name,
"label": w.label,
"canonical": w.value,
"multiline": !matches!(w.kind, crate::widget::WidgetKind::Text),
"value": tr.get(&w.name).and_then(|v| v.as_str()).unwrap_or(""),
})
})
.collect();
ctx.insert("translation_mode", &true);
ctx.insert("editing_locale", loc);
ctx.insert("tr_rows", &rows);
}
ctx.insert("locales", &locales);
ctx.insert("widgets", &widgets);
} else {
ctx.insert("typed", &false);
let body = serde_json::to_string_pretty(&stored).unwrap_or_else(|_| "{}".to_owned());
ctx.insert("value_pretty", &body);
}
render_with_csrf(
&state,
&headers,
"rcms_admin/site_setting_form.html",
&mut ctx,
)
}
pub async fn site_setting_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(scope): Path<String>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let parsed: serde_json::Value = if let Some(schema) = crate::site_setting::schema_for(&scope) {
let fields = (schema.fields)();
let missing = crate::site_setting::missing_required(&fields, &form);
if !missing.is_empty() {
return Err(AdminError::Validation(format!(
"These required fields are empty: {}.",
missing.join(", ")
)));
}
let mut value = crate::site_setting::value_json_from_form(&fields, &form);
if let Ok(Some(old)) = crate::site_setting::get(tenant.pool(), &scope).await {
crate::site_setting::keep_translations(&old.value_json, &mut value);
}
value
} else {
let raw = form.get("value_json").map_or("", |s| s.trim());
if raw.is_empty() {
serde_json::json!({})
} else {
serde_json::from_str(raw)
.map_err(|e| AdminError::Validation(format!("value_json isn't valid JSON: {e}")))?
}
};
crate::site_setting::upsert(tenant.pool(), &scope, parsed).await?;
redirect_named_with_message_args(
"rcms-admin:site-settings:list",
MsgLevel::Success,
"Saved site setting “{scope}”.",
&[("scope", scope.as_str())],
&headers,
)
}
fn site_setting_translatable(w: &crate::widget::Widget) -> bool {
use crate::widget::WidgetKind as K;
matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
}
pub async fn site_setting_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(scope): Path<String>,
Query(q): Query<EditQuery>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
let schema = crate::site_setting::schema_for(&scope)
.ok_or_else(|| AdminError::Validation(format!("`{scope}` has no typed fields to translate")))?;
let row = crate::site_setting::get(tenant.pool(), &scope)
.await?
.ok_or_else(|| AdminError::Validation(format!("save `{scope}` before translating it")))?;
let fields: serde_json::Map<String, serde_json::Value> = (schema.fields)()
.iter()
.filter(|w| site_setting_translatable(w))
.filter_map(|w| {
form.get(&format!("tr__{}", w.name))
.map(|v| (w.name.clone(), serde_json::Value::String(v.trim().to_owned())))
})
.collect();
let mut value = row.value_json;
crate::site_setting::set_translations(&mut value, &locale.code, fields);
crate::site_setting::upsert(tenant.pool(), &scope, value).await?;
Ok(rustango::messages::redirect_with_message(
messages_secret(),
&headers,
MsgLevel::Success,
&super::i18n::tr(&headers, "Translations saved.", &[]),
&format!("/cms-admin/site-settings/{scope}/edit?locale={}", locale.code),
))
}
pub async fn site_setting_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(scope): Path<String>,
) -> Result<Response, AdminError> {
if let Some(row) = crate::site_setting::get(tenant.pool(), &scope)
.await
.unwrap_or(None)
{
row.delete_pool(tenant.pool()).await?;
}
redirect_named_with_message_args(
"rcms-admin:site-settings:list",
MsgLevel::Success,
"Deleted site setting “{scope}”.",
&[("scope", scope.as_str())],
&headers,
)
}
pub async fn search_promotions_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let top = crate::search_promotion::top_queries(tenant.pool(), 100)
.await
.unwrap_or_default();
let mut rows: Vec<serde_json::Value> = Vec::with_capacity(top.len());
for q in top {
let qid = q.id.get().copied().unwrap_or_default();
let promos = crate::search_promotion::promotions_for_query(tenant.pool(), qid)
.await
.unwrap_or_default();
rows.push(serde_json::json!({
"id": qid,
"raw": q.raw,
"normalized": q.normalized,
"hits": q.hits,
"last_seen_at": q.last_seen_at.get().copied(),
"promotion_count": promos.len(),
}));
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/search_promotions_report.html",
&mut ctx,
)
}
pub async fn search_promotion_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(query_id): Path<i64>,
) -> Result<Response, AdminError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let queries: Vec<crate::search_promotion::SearchQuery> =
crate::search_promotion::SearchQuery::objects()
.where_(crate::search_promotion::SearchQuery::id.eq(query_id))
.fetch(tenant.pool())
.await?;
let Some(query) = queries.into_iter().next() else {
return Err(AdminError::NotFound(query_id));
};
let promotions = crate::search_promotion::promotions_for_query(tenant.pool(), query_id)
.await
.unwrap_or_default();
let pages: Vec<Page> = Page::objects()
.where_(Page::status.eq("published".to_owned()))
.order_by(&[("title", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("query", &query);
ctx.insert("promotions", &promotions);
ctx.insert("pages", &pages);
render_with_csrf(
&state,
&headers,
"rcms_admin/search_promotion_edit.html",
&mut ctx,
)
}
#[derive(Debug, Deserialize)]
pub struct SearchPromotionForm {
#[serde(default)]
pub page_ids: String,
#[serde(default)]
pub descriptions: String,
}
pub async fn search_promotion_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(query_id): Path<i64>,
Form(form): Form<SearchPromotionForm>,
) -> Result<Response, AdminError> {
use rustango::core::Column as _;
use rustango::sql::Auto;
use rustango::sql::FetcherPool as _;
let existing: Vec<crate::search_promotion::SearchPromotion> =
crate::search_promotion::SearchPromotion::objects()
.where_(crate::search_promotion::SearchPromotion::query_id.eq(query_id))
.fetch(tenant.pool())
.await?;
for row in existing {
row.delete_pool(tenant.pool()).await.log_warn("old search promotion not deleted");
}
let ids: Vec<i64> = form
.page_ids
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse::<i64>().ok())
.collect();
let descriptions: Vec<String> = form
.descriptions
.split('\n')
.map(|s| s.trim().to_owned())
.collect();
for (idx, page_id) in ids.iter().enumerate() {
let mut row = crate::search_promotion::SearchPromotion {
id: Auto::Unset,
query_id,
page_id: *page_id,
sort_order: idx as i32,
description: descriptions.get(idx).cloned().unwrap_or_default(),
created_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await.log_warn("search promotion not saved");
}
redirect_named_with_message_plural(
"rcms-admin:reports:search",
MsgLevel::Success,
"Saved {count} pinned result(s).",
ids.len() as i64,
&[("count", &ids.len().to_string())],
&headers,
)
}
pub(crate) fn derive_scheduled_status(
current: &str,
go_live_at: Option<chrono::DateTime<chrono::Utc>>,
) -> String {
let archived = crate::page::PageStatus::Archived.as_str();
if current == archived {
return current.to_owned();
}
let now = chrono::Utc::now();
let future = go_live_at.is_some_and(|t| t > now);
let scheduled = crate::page::PageStatus::Scheduled.as_str();
let draft = crate::page::PageStatus::Draft.as_str();
match (current, future, go_live_at) {
(_, true, _) => scheduled.to_owned(),
(s, false, None) if s == scheduled => draft.to_owned(),
_ => current.to_owned(),
}
}
#[cfg(test)]
mod scheduled_status_tests {
use super::derive_scheduled_status;
use chrono::{Duration, Utc};
#[test]
fn future_go_live_promotes_draft_to_scheduled() {
let go = Utc::now() + Duration::hours(1);
assert_eq!(derive_scheduled_status("draft", Some(go)), "scheduled");
}
#[test]
fn future_go_live_also_promotes_published() {
let go = Utc::now() + Duration::hours(2);
assert_eq!(derive_scheduled_status("published", Some(go)), "scheduled");
}
#[test]
fn cleared_go_live_demotes_scheduled_to_draft() {
assert_eq!(derive_scheduled_status("scheduled", None), "draft");
}
#[test]
fn past_go_live_on_scheduled_left_alone_for_sweep() {
let past = Utc::now() - Duration::hours(1);
assert_eq!(
derive_scheduled_status("scheduled", Some(past)),
"scheduled",
);
}
#[test]
fn archived_preserved_regardless_of_go_live() {
let go = Utc::now() + Duration::hours(1);
assert_eq!(derive_scheduled_status("archived", Some(go)), "archived");
assert_eq!(derive_scheduled_status("archived", None), "archived");
}
#[test]
fn draft_with_no_go_live_unchanged() {
assert_eq!(derive_scheduled_status("draft", None), "draft");
}
#[test]
fn published_with_no_go_live_unchanged() {
assert_eq!(derive_scheduled_status("published", None), "published");
}
}
async fn scheduled_pages_rows(
pool: &rustango::sql::Pool,
) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
use rustango::sql::FetcherPool as _;
let pages: Vec<Page> = Page::objects().fetch(pool).await?;
let now = chrono::Utc::now();
let mut rows: Vec<serde_json::Value> = Vec::new();
for p in &pages {
let pid = p.id.get().copied().unwrap_or_default();
if let Some(go) = p.go_live_at {
if go > now
&& p.status != crate::page::PageStatus::Archived.as_str()
&& p.status != crate::page::PageStatus::Expired.as_str()
{
let countdown = (go - now).num_seconds();
rows.push(serde_json::json!({
"kind": "publish",
"when": go,
"countdown_secs": countdown,
"page_id": pid,
"title": p.title,
"url_path": p.url_path,
"status": p.status,
}));
}
}
if let Some(exp) = p.expire_at {
if exp > now
&& (p.status == crate::page::PageStatus::Published.as_str()
|| p.status == crate::page::PageStatus::Scheduled.as_str())
{
let countdown = (exp - now).num_seconds();
rows.push(serde_json::json!({
"kind": "expire",
"when": exp,
"countdown_secs": countdown,
"page_id": pid,
"title": p.title,
"url_path": p.url_path,
"status": p.status,
}));
}
}
}
rows.sort_by_key(|r| {
r.get("countdown_secs")
.and_then(|v| v.as_i64())
.unwrap_or(i64::MAX)
});
Ok(rows)
}
pub async fn scheduled_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = scheduled_pages_rows(tenant.pool())
.await
.unwrap_or_default();
let mut ctx = Context::new();
add_chrome(
&mut ctx,
&tenant,
"reports-scheduled",
session_user.as_ref(),
)
.await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/scheduled_report.html",
&mut ctx,
)
}
pub async fn scheduled_report_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = scheduled_pages_rows(tenant.pool())
.await
.unwrap_or_default();
let mut out = String::with_capacity(256 + rows.len() * 160);
out.push_str("kind,page_id,title,url_path,status,when,countdown_secs\n");
for r in &rows {
out.push_str(&format!(
"{},{},{},{},{},{},{}\n",
csv_escape(r.get("kind").and_then(|v| v.as_str()).unwrap_or_default()),
r.get("page_id")
.and_then(|v| v.as_i64())
.unwrap_or_default(),
csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
csv_escape(
r.get("url_path")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
csv_escape(&r.get("when").map(ToString::to_string).unwrap_or_default()),
r.get("countdown_secs")
.and_then(|v| v.as_i64())
.unwrap_or_default(),
));
}
Ok(csv_response("scheduled-pages", &out))
}
async fn locked_pages_rows(
pool: &rustango::sql::Pool,
) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
use rustango::sql::FetcherPool as _;
let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
.order_by(&[("acquired_at", true)]) .fetch(pool)
.await?;
let now = chrono::Utc::now();
let live: Vec<&crate::lock::PageLock> = locks.iter().filter(|l| !l.is_stale(now)).collect();
if live.is_empty() {
return Ok(Vec::new());
}
let page_ids: Vec<i64> = live.iter().map(|l| l.page_id).collect();
let user_ids: Vec<i64> = live.iter().map(|l| l.user_id).collect();
let pages: Vec<Page> = Page::objects()
.where_(Page::id.is_in(page_ids))
.fetch(pool)
.await
.unwrap_or_default();
let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids))
.fetch(pool)
.await
.unwrap_or_default();
let page_by_id: std::collections::HashMap<i64, &Page> = pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let user_by_id: std::collections::HashMap<i64, String> = users
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect();
Ok(live
.into_iter()
.map(|l| {
let title = page_by_id
.get(&l.page_id)
.map(|p| p.title.clone())
.unwrap_or_else(|| format!("page #{}", l.page_id));
let url_path = page_by_id
.get(&l.page_id)
.map(|p| p.url_path.clone())
.unwrap_or_default();
let username = user_by_id
.get(&l.user_id)
.cloned()
.unwrap_or_else(|| format!("user#{}", l.user_id));
let ttl_remaining = (l.expires_at - now).num_seconds();
serde_json::json!({
"page_id": l.page_id,
"title": title,
"url_path": url_path,
"user_id": l.user_id,
"username": username,
"acquired_at": l.acquired_at.get().copied(),
"expires_at": l.expires_at,
"ttl_remaining_secs": ttl_remaining,
})
})
.collect())
}
pub async fn locked_pages_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "reports-locked", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
render_with_csrf(&state, &headers, "rcms_admin/locked_pages.html", &mut ctx)
}
pub async fn locked_pages_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
let mut out = String::with_capacity(256 + rows.len() * 128);
out.push_str("page_id,title,url_path,username,acquired_at,expires_at\n");
for r in &rows {
out.push_str(&format!(
"{},{},{},{},{},{}\n",
r.get("page_id")
.and_then(|v| v.as_i64())
.unwrap_or_default(),
csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
csv_escape(
r.get("url_path")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("username")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("acquired_at")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("expires_at")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
));
}
Ok(csv_response("locked-pages", &out))
}
async fn workflows_report_rows(
pool: &rustango::sql::Pool,
) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
use rustango::sql::FetcherPool as _;
let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
.order_by(&[("requested_at", true)]) .fetch(pool)
.await?;
if states.is_empty() {
return Ok(Vec::new());
}
let workflow_ids: Vec<i64> = states.iter().map(|s| s.workflow_id).collect();
let page_ids: Vec<i64> = states.iter().map(|s| s.page_id).collect();
let user_ids: Vec<i64> = states.iter().map(|s| s.requested_by).collect();
let workflows: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
.where_(crate::workflow::Workflow::id.is_in(workflow_ids))
.fetch(pool)
.await
.unwrap_or_default();
let pages: Vec<Page> = Page::objects()
.where_(Page::id.is_in(page_ids))
.fetch(pool)
.await
.unwrap_or_default();
let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids))
.fetch(pool)
.await
.unwrap_or_default();
let task_ids: Vec<i64> = states.iter().filter_map(|s| s.current_task_id).collect();
let tasks: Vec<crate::workflow::WorkflowTask> = if task_ids.is_empty() {
Vec::new()
} else {
crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::id.is_in(task_ids))
.fetch(pool)
.await
.unwrap_or_default()
};
let workflow_by_id: std::collections::HashMap<i64, String> = workflows
.into_iter()
.filter_map(|w| w.id.get().copied().map(|id| (id, w.name)))
.collect();
let page_by_id: std::collections::HashMap<i64, &Page> = pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let user_by_id: std::collections::HashMap<i64, String> = users
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect();
let task_by_id: std::collections::HashMap<i64, String> = tasks
.into_iter()
.filter_map(|t| t.id.get().copied().map(|id| (id, t.name)))
.collect();
Ok(states
.iter()
.map(|s| {
serde_json::json!({
"id": s.id.get().copied(),
"workflow_name": workflow_by_id.get(&s.workflow_id).cloned().unwrap_or_else(|| format!("workflow #{}", s.workflow_id)),
"page_id": s.page_id,
"page_title": page_by_id.get(&s.page_id).map(|p| p.title.clone()).unwrap_or_else(|| format!("page #{}", s.page_id)),
"page_url_path": page_by_id.get(&s.page_id).map(|p| p.url_path.clone()).unwrap_or_default(),
"status": s.status,
"current_task_name": s.current_task_id.and_then(|tid| task_by_id.get(&tid).cloned()),
"requested_by_username": user_by_id.get(&s.requested_by).cloned(),
"requested_at": s.requested_at.get().copied(),
"finished_at": s.finished_at,
})
})
.collect())
}
pub async fn workflows_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = workflows_report_rows(tenant.pool())
.await
.unwrap_or_default();
let mut ctx = Context::new();
add_chrome(
&mut ctx,
&tenant,
"reports-workflows",
session_user.as_ref(),
)
.await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/workflow_report.html",
&mut ctx,
)
}
pub async fn revisions_report(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
use rustango::sql::FetcherPool as _;
let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
.fetch(tenant.pool())
.await
.unwrap_or_default();
let mut count_by_page: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
for r in &revisions {
*count_by_page.entry(r.page_id).or_default() += 1;
}
let mut rows: Vec<serde_json::Value> = pages
.into_iter()
.filter_map(|p| {
let pid = p.id.get().copied()?;
let count = count_by_page.get(&pid).copied().unwrap_or(0);
if count == 0 {
return None;
}
Some(serde_json::json!({
"page_id": pid,
"title": p.title,
"url_path": p.url_path,
"status": p.status,
"revision_count": count,
}))
})
.collect();
rows.sort_by(|a, b| {
let ac = a
.get("revision_count")
.and_then(|v| v.as_u64())
.unwrap_or(0);
let bc = b
.get("revision_count")
.and_then(|v| v.as_u64())
.unwrap_or(0);
bc.cmp(&ac)
});
let total_revisions = revisions.len();
let mut ctx = Context::new();
add_chrome(
&mut ctx,
&tenant,
"reports-revisions",
session_user.as_ref(),
)
.await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("total_revisions", &total_revisions);
ctx.insert("default_keep_latest", &crate::revision::DEFAULT_KEEP_LATEST);
render_with_csrf(
&state,
&headers,
"rcms_admin/revisions_report.html",
&mut ctx,
)
}
#[derive(Debug, Deserialize)]
pub struct RevisionsPruneForm {
#[serde(default)]
pub keep_latest: Option<usize>,
#[serde(default)]
pub include_published: Option<String>,
}
pub async fn revisions_report_prune(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<RevisionsPruneForm>,
) -> Result<Response, AdminError> {
let keep_latest = form
.keep_latest
.unwrap_or(crate::revision::DEFAULT_KEEP_LATEST)
.max(1);
let keep_published = form.include_published.as_deref() != Some("1");
let (pages_scanned, rows_deleted) =
crate::revision::prune_all_pages(tenant.pool(), keep_latest, keep_published)
.await
.unwrap_or((0, 0));
let revisions = super::i18n::tr_plural(
&headers,
"{count} revision(s)",
rows_deleted as i64,
&[("count", &rows_deleted.to_string())],
);
let pages_ph = super::i18n::tr_plural(
&headers,
"{count} page(s)",
pages_scanned as i64,
&[("count", &pages_scanned.to_string())],
);
let kl = keep_latest.to_string();
let kp = keep_published.to_string();
redirect_named_with_message_args(
"rcms-admin:reports:revisions",
MsgLevel::Success,
"Pruned {revisions} across {pages} (keep_latest={keep_latest}, keep_published={keep_published}).",
&[
("revisions", revisions.as_str()),
("pages", pages_ph.as_str()),
("keep_latest", kl.as_str()),
("keep_published", kp.as_str()),
],
&headers,
)
}
pub async fn workflows_report_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let rows = workflows_report_rows(tenant.pool())
.await
.unwrap_or_default();
let mut out = String::with_capacity(256 + rows.len() * 192);
out.push_str("workflow,page_id,page_title,page_url,status,current_task,requested_by,requested_at,finished_at\n");
for r in &rows {
out.push_str(&format!(
"{},{},{},{},{},{},{},{},{}\n",
csv_escape(
r.get("workflow_name")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
r.get("page_id")
.and_then(|v| v.as_i64())
.unwrap_or_default(),
csv_escape(
r.get("page_title")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("page_url_path")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
csv_escape(
r.get("current_task_name")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("requested_by_username")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("requested_at")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
csv_escape(
r.get("finished_at")
.and_then(|v| v.as_str())
.unwrap_or_default()
),
));
}
Ok(csv_response("workflow-report", &out))
}
#[derive(Debug, Deserialize)]
pub struct AdminSearchQuery {
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub autocomplete: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct PageChooserQuery {
#[serde(default)]
pub q: Option<String>,
}
#[derive(Debug, Default, Deserialize)]
pub struct ChooserSearchQuery {
#[serde(default)]
pub q: Option<String>,
}
pub async fn chooser_search_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(slug): Path<String>,
Query(q): Query<ChooserSearchQuery>,
) -> Result<Response, AdminError> {
let Some(cvs) = super::chooser::find(&slug) else {
return Ok((axum::http::StatusCode::NOT_FOUND, "unknown chooser").into_response());
};
let items = (cvs.search_rows)(tenant.pool().clone(), q.q.unwrap_or_default()).await;
let body = serde_json::json!({ "items": items });
Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
#[derive(Debug, Default, Deserialize)]
pub struct MediaPickerQuery {
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub collection: Option<i64>,
#[serde(default)]
pub kind: Option<String>,
#[serde(default)]
pub ids: Option<String>,
#[serde(default)]
pub limit: Option<usize>,
#[serde(default)]
pub offset: Option<usize>,
}
pub async fn media_picker_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
Query(q): Query<MediaPickerQuery>,
) -> Result<Response, AdminError> {
let body = media_picker_payload(tenant.pool(), &q).await?;
Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
pub(crate) async fn media_picker_payload(
pool: &rustango::sql::Pool,
q: &MediaPickerQuery,
) -> Result<serde_json::Value, AdminError> {
let mut rows: Vec<Media> = Media::objects()
.order_by(&[("uploaded_at", true)])
.fetch(pool)
.await?;
let id_set: Option<std::collections::HashSet<i64>> = q.ids.as_deref().map(|s| {
s.split(',')
.filter_map(|t| t.trim().parse::<i64>().ok())
.collect()
});
if let Some(ids) = &id_set {
rows.retain(|m| m.id.get().copied().is_some_and(|id| ids.contains(&id)));
}
let kind = q
.kind
.as_deref()
.unwrap_or(if id_set.is_some() { "any" } else { "image" });
if kind != "any" {
rows.retain(|m| m.kind == kind);
}
let mut collection_counts: std::collections::HashMap<i64, i64> =
std::collections::HashMap::new();
let mut uncategorized_count: i64 = 0;
for m in &rows {
match m.collection_id {
Some(cid) => *collection_counts.entry(cid).or_default() += 1,
None => uncategorized_count += 1,
}
}
match q.collection {
Some(0) => rows.retain(|m| m.collection_id.is_none()),
Some(cid) => rows.retain(|m| m.collection_id == Some(cid)),
None => {}
}
if let Some(needle) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
let needle = needle.to_lowercase();
rows.retain(|m| {
m.title.to_lowercase().contains(&needle)
|| m.filename.to_lowercase().contains(&needle)
|| m.alt_text.to_lowercase().contains(&needle)
|| m.description.to_lowercase().contains(&needle)
});
}
let total = rows.len();
let limit = q.limit.unwrap_or(60).min(200);
let offset = q.offset.unwrap_or(0).min(total);
let has_more = offset + limit < total;
let page: Vec<serde_json::Value> = rows[offset..(offset + limit).min(total)]
.iter()
.map(|m| {
let id = m.id.get().copied().unwrap_or_default();
let is_image = m.kind == "image";
let thumb_url = is_image
.then(|| {
crate::rendition::rendition_url_for(
id,
"fill-320x320|format-webp|quality-70",
Some(m.content_hash.as_str()),
)
})
.flatten();
let preview_url = is_image
.then(|| {
crate::rendition::rendition_url_for(
id,
"max-640x480|format-webp|quality-80",
Some(m.content_hash.as_str()),
)
})
.flatten();
serde_json::json!({
"id": id,
"title": if m.title.is_empty() { m.filename.clone() } else { m.title.clone() },
"filename": m.filename,
"kind": m.kind,
"mime": m.mime,
"size": m.size,
"width": m.width,
"height": m.height,
"collection_id": m.collection_id,
"alt_text": m.alt_text,
"uploaded_at": m.uploaded_at,
"thumb_url": thumb_url,
"preview_url": preview_url,
})
})
.collect();
let cols: Vec<crate::media::MediaCollection> =
crate::media::MediaCollection::objects().fetch(pool).await?;
let mut children: std::collections::HashMap<Option<i64>, Vec<&crate::media::MediaCollection>> =
std::collections::HashMap::new();
for c in &cols {
children.entry(c.parent_id).or_default().push(c);
}
for v in children.values_mut() {
v.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.name.cmp(&b.name)));
}
let mut ordered: Vec<serde_json::Value> = Vec::with_capacity(cols.len());
let mut visited: std::collections::HashSet<i64> = std::collections::HashSet::new();
let mut stack: Vec<(i64, usize)> = children
.get(&None)
.map(|roots| {
roots
.iter()
.rev()
.filter_map(|c| c.id.get().copied())
.map(|id| (id, 0))
.collect()
})
.unwrap_or_default();
let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = cols
.iter()
.filter_map(|c| c.id.get().copied().map(|id| (id, c)))
.collect();
while let Some((id, depth)) = stack.pop() {
if !visited.insert(id) {
continue;
}
if let Some(c) = by_id.get(&id) {
ordered.push(serde_json::json!({
"id": id,
"name": c.name,
"depth": depth,
"count": collection_counts.get(&id).copied().unwrap_or(0),
}));
if let Some(kids) = children.get(&Some(id)) {
for k in kids.iter().rev() {
if let Some(kid) = k.id.get().copied() {
stack.push((kid, depth + 1));
}
}
}
}
}
Ok(serde_json::json!({
"items": page,
"collections": ordered,
"uncategorized_count": uncategorized_count,
"total": total,
"has_more": has_more,
}))
}
pub async fn page_chooser_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
Query(q): Query<PageChooserQuery>,
) -> Result<Response, AdminError> {
let needle =
q.q.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_lowercase);
let mut pages: Vec<Page> = Page::objects()
.order_by(&[("updated_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
if let Some(n) = needle.as_ref() {
pages.retain(|p| {
p.title.to_lowercase().contains(n)
|| p.slug.to_lowercase().contains(n)
|| p.url_path.to_lowercase().contains(n)
});
}
let items: Vec<serde_json::Value> = pages
.iter()
.take(50)
.map(|p| {
serde_json::json!({
"id": p.id.get().copied(),
"title": p.title,
"slug": p.slug,
"url_path": p.url_path,
"depth": p.depth,
"parent_id": p.parent_id,
"status": p.status,
})
})
.collect();
let body = serde_json::json!({ "items": items });
Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct SnippetChooserQuery {
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub type_name: Option<String>,
#[serde(default)]
pub ids: Option<String>,
}
pub async fn snippet_chooser_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
Query(q): Query<SnippetChooserQuery>,
) -> Result<Response, AdminError> {
let needle =
q.q.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_lowercase);
let type_filter = q
.type_name
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let mut snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.order_by(&[("updated_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
if let Some(ids) = q.ids.as_deref() {
let id_set: std::collections::HashSet<i64> = ids
.split(',')
.filter_map(|t| t.trim().parse::<i64>().ok())
.collect();
snippets.retain(|s| s.id.get().copied().is_some_and(|id| id_set.contains(&id)));
}
if let Some(tn) = type_filter.as_ref() {
snippets.retain(|s| &s.type_name == tn);
}
if let Some(n) = needle.as_ref() {
snippets
.retain(|s| s.title.to_lowercase().contains(n) || s.slug.to_lowercase().contains(n));
}
let items: Vec<serde_json::Value> = snippets
.iter()
.take(50)
.map(|s| {
serde_json::json!({
"id": s.id.get().copied(),
"title": s.title,
"slug": s.slug,
"type_name": s.type_name,
})
})
.collect();
let body = serde_json::json!({ "items": items });
Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct DocumentChooserQuery {
#[serde(default)]
pub q: Option<String>,
}
pub async fn document_chooser_json(
State(_state): State<super::AdminState>,
tenant: Tenant,
Query(q): Query<DocumentChooserQuery>,
) -> Result<Response, AdminError> {
let needle =
q.q.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_lowercase);
let mut rows: Vec<Media> = Media::objects()
.where_(Media::kind.eq("document".to_owned()))
.order_by(&[("uploaded_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
if let Some(n) = needle.as_ref() {
rows.retain(|m| {
m.title.to_lowercase().contains(n) || m.filename.to_lowercase().contains(n)
});
}
let items: Vec<serde_json::Value> = rows
.iter()
.take(50)
.map(|m| {
serde_json::json!({
"id": m.id.get().copied(),
"title": m.title,
"filename": m.filename,
"kind": m.kind,
"mime": m.mime,
})
})
.collect();
let body = serde_json::json!({ "items": items });
Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response())
}
pub async fn admin_search(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<AdminSearchQuery>,
) -> Result<Response, AdminError> {
let needle =
q.q.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_lowercase);
let autocomplete = q.autocomplete.as_deref() == Some("1");
if !autocomplete {
if let Some(raw) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
if let Err(e) = crate::search_promotion::log_query(tenant.pool(), raw).await {
tracing::debug!(
target: "rustango_cms::search",
error = %e,
"search query log failed (best-effort)",
);
}
}
}
let mut pages_out: Vec<serde_json::Value> = Vec::new();
let mut snippets_out: Vec<serde_json::Value> = Vec::new();
let mut media_out: Vec<serde_json::Value> = Vec::new();
if let Some(needle) = needle.as_ref() {
let all_pages: Vec<Page> = Page::objects()
.order_by(&[("updated_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
let page_types: Vec<PageType> = PageType::objects()
.fetch(tenant.pool())
.await
.unwrap_or_default();
let page_type_by_id: std::collections::HashMap<i64, String> = page_types
.into_iter()
.filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
.collect();
let mut title_hits: Vec<serde_json::Value> = Vec::new();
let mut body_hits: Vec<serde_json::Value> = Vec::new();
for p in all_pages {
if title_hits.len() + body_hits.len() >= 20 {
break;
}
let title = p.title.to_lowercase();
let slug = p.slug.to_lowercase();
let url_path = p.url_path.to_lowercase();
let primary_hit =
title.contains(needle) || slug.contains(needle) || url_path.contains(needle);
let mut body_match = false;
if !primary_hit {
if p.seo_title.to_lowercase().contains(needle)
|| p.seo_description.to_lowercase().contains(needle)
|| p.og_title.to_lowercase().contains(needle)
|| p.og_description.to_lowercase().contains(needle)
{
body_match = true;
}
if !body_match {
if let Some(type_name) = page_type_by_id.get(&p.page_type_id) {
if let Some(handler) = crate::page_type::find_handler(type_name) {
let page_id = p.id.get().copied().unwrap_or_default();
if let Ok(ext) = handler.load_extension(tenant.pool(), page_id).await {
body_match = json_contains_needle(&ext, needle);
}
}
}
}
}
if primary_hit || body_match {
let row = serde_json::json!({
"id": p.id.get().copied(),
"title": p.title,
"slug": p.slug,
"url_path": p.url_path,
"status": p.status,
});
if primary_hit {
title_hits.push(row);
} else {
body_hits.push(row);
}
}
}
pages_out.extend(title_hits);
pages_out.extend(body_hits);
if pages_out.len() > 20 {
pages_out.truncate(20);
}
let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.order_by(&[("updated_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
for s in all_snippets {
if snippets_out.len() >= 20 {
break;
}
let title = s.title.to_lowercase();
let slug = s.slug.to_lowercase();
if title.contains(needle) || slug.contains(needle) {
snippets_out.push(serde_json::json!({
"id": s.id.get().copied(),
"title": s.title,
"slug": s.slug,
"type_name": s.type_name,
}));
}
}
let all_media: Vec<crate::media::Media> = crate::media::Media::objects()
.order_by(&[("created_at", true)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
for m in all_media {
if media_out.len() >= 20 {
break;
}
let title = m.title.to_lowercase();
let filename = m.filename.to_lowercase();
let alt = m.alt_text.to_lowercase();
if title.contains(needle) || filename.contains(needle) || alt.contains(needle) {
media_out.push(serde_json::json!({
"id": m.id.get().copied(),
"title": m.title,
"filename": m.filename,
"alt_text": m.alt_text,
"kind": m.kind,
}));
}
}
}
let plugin_areas: Vec<serde_json::Value> = if let Some(query) = q.q.as_deref() {
let trimmed = query.trim();
if trimmed.is_empty() {
Vec::new()
} else {
crate::hooks::run_admin_search_areas(trimmed)
.into_iter()
.map(|(label, hits)| {
serde_json::json!({
"label": label,
"hits": hits,
})
})
.collect()
}
} else {
Vec::new()
};
if autocomplete {
let payload = serde_json::json!({
"q": q.q,
"pages": pages_out.iter().take(5).collect::<Vec<_>>(),
"snippets": snippets_out.iter().take(5).collect::<Vec<_>>(),
"media": media_out.iter().take(5).collect::<Vec<_>>(),
"plugin_areas": plugin_areas,
});
return Ok((
[(header::CONTENT_TYPE, "application/json")],
serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
)
.into_response());
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "search", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("query", &q.q.unwrap_or_default());
ctx.insert("pages", &pages_out);
ctx.insert("snippets", &snippets_out);
ctx.insert("media", &media_out);
let plugin_hit_count: usize = plugin_areas
.iter()
.filter_map(|a| a.get("hits").and_then(|h| h.as_array()).map(Vec::len))
.sum();
ctx.insert("plugin_search_areas", &plugin_areas);
ctx.insert(
"total_hits",
&(pages_out.len() + snippets_out.len() + media_out.len() + plugin_hit_count),
);
render_with_csrf(&state, &headers, "rcms_admin/admin_search.html", &mut ctx)
}
pub async fn navigation_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let menus: Vec<crate::navigation::Menu> = crate::navigation::Menu::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let all_items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
.fetch(tenant.pool())
.await?;
let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for it in &all_items {
*counts.entry(it.menu_id).or_insert(0) += 1;
}
let rows: Vec<serde_json::Value> = menus
.iter()
.map(|m| {
let id = m.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": id,
"slug": m.slug,
"name": m.name,
"item_count": counts.get(&id).copied().unwrap_or(0),
"created_at": m.created_at.get().copied(),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("menus", &rows);
render_with_csrf(
&state,
&headers,
"rcms_admin/navigation_list.html",
&mut ctx,
)
}
#[derive(Debug, Deserialize)]
pub struct MenuForm {
pub slug: String,
pub name: String,
}
pub async fn navigation_create_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<MenuForm>,
) -> Result<Response, AdminError> {
let slug = form.slug.trim().to_lowercase();
let name = form.name.trim().to_owned();
if slug.is_empty() || name.is_empty() {
return redirect_named_with_message(
"rcms-admin:navigation:list",
MsgLevel::Warning,
"Menu slug + name are both required.",
&headers,
);
}
let mut row = crate::navigation::Menu {
id: rustango::sql::Auto::Unset,
slug: slug.clone(),
name,
created_at: rustango::sql::Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:navigation:list",
MsgLevel::Success,
"Menu “{slug}” created.",
&[("slug", slug.as_str())],
&headers,
)
}
pub async fn navigation_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let menu = crate::navigation::Menu::objects()
.where_(crate::navigation::Menu::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.fetch(tenant.pool())
.await?;
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
delete_menu_items_tx(tx, items).await?;
menu.delete_tx(tx).await?;
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
redirect_named_with_message(
"rcms-admin:navigation:list",
MsgLevel::Success,
"Menu deleted.",
&headers,
)
}
pub async fn navigation_clone_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let source = crate::navigation::Menu::objects()
.where_(crate::navigation::Menu::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let base = source.slug.trim_matches('-').to_owned();
let desired = format!("{base}-copy");
let existing_slugs: std::collections::HashSet<String> = crate::navigation::Menu::objects()
.fetch(tenant.pool())
.await?
.into_iter()
.map(|m| m.slug)
.collect();
let slug = if !existing_slugs.contains(&desired) {
desired
} else {
let mut chosen = None;
for n in 2..=100 {
let candidate = format!("{desired}-{n}");
if !existing_slugs.contains(&candidate) {
chosen = Some(candidate);
break;
}
}
chosen.ok_or_else(|| {
AdminError::Validation(
"Could not allocate a unique slug for the cloned menu.".to_owned(),
)
})?
};
let mut clone_menu = crate::navigation::Menu {
id: rustango::sql::Auto::Unset,
slug,
name: format!("{} (copy)", source.name),
created_at: rustango::sql::Auto::Unset,
};
let items = crate::navigation::order_pre_order(
crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.order_by(&[("sort_order", false), ("id", false)])
.fetch(tenant.pool())
.await?,
);
let count = items.len().to_string();
let new_menu_id = rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
clone_menu.save_tx(tx).await?;
let new_menu_id = clone_menu.id.get().copied().unwrap_or_default();
let mut id_map: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for item in &items {
let old_id = item.id.get().copied().unwrap_or_default();
let new_parent = item.parent_id.and_then(|p| id_map.get(&p).copied());
let mut clone_item = crate::navigation::MenuItem {
id: rustango::sql::Auto::Unset,
menu_id: new_menu_id,
parent_id: new_parent,
sort_order: item.sort_order,
label: item.label.clone(),
page_id: item.page_id,
external_url: item.external_url.clone(),
open_in_new_tab: item.open_in_new_tab,
};
clone_item.save_tx(tx).await?;
id_map.insert(old_id, clone_item.id.get().copied().unwrap_or_default());
}
Ok::<_, rustango::sql::ExecError>(new_menu_id)
})
.await?;
redirect_named_with_params_and_message_args(
"rcms-admin:navigation:edit",
&[("id", new_menu_id.to_string())],
MsgLevel::Success,
"Cloned “{name}” with {count} items.",
&[("name", source.name.as_str()), ("count", count.as_str())],
&headers,
)
}
pub async fn navigation_seed_from_pages_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let menu = crate::navigation::Menu::objects()
.where_(crate::navigation::Menu::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.fetch(tenant.pool())
.await?;
let mut pages: Vec<crate::page::Page> = crate::page::Page::objects()
.where_(crate::page::Page::show_in_menus.eq(true))
.where_(crate::page::Page::status.eq("published".to_owned()))
.order_by(&[("path", false), ("id", false)])
.fetch(tenant.pool())
.await?;
let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
pages.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
let mut page_to_item: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
let mut sibling_counter: std::collections::HashMap<Option<i64>, i32> =
std::collections::HashMap::new();
let inserted = pages.len();
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
delete_menu_items_tx(tx, existing).await?;
for page in &pages {
let page_id = page.id.get().copied().unwrap_or_default();
let parent_menu_item_id: Option<i64> = page
.parent_id
.and_then(|pid| page_to_item.get(&pid).copied());
let bucket = parent_menu_item_id;
let sort_order = *sibling_counter
.entry(bucket)
.and_modify(|n| *n += 1)
.or_insert(0);
let mut item = crate::navigation::MenuItem {
id: rustango::sql::Auto::Unset,
menu_id: id,
parent_id: parent_menu_item_id,
sort_order,
label: page.title.clone(),
page_id: Some(page_id),
external_url: None,
open_in_new_tab: false,
};
item.save_tx(tx).await?;
let new_item_id = item.id.get().copied().unwrap_or_default();
page_to_item.insert(page_id, new_item_id);
}
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
redirect_named_with_params_and_message_plural(
"rcms-admin:navigation:edit",
&[("id", id.to_string())],
MsgLevel::Success,
"Seeded “{name}” with {count} item(s) from pages marked Show in menus.",
inserted as i64,
&[
("name", menu.name.as_str()),
("count", &inserted.to_string()),
],
&headers,
)
}
async fn delete_menu_items_tx(
tx: &mut rustango::sql::PoolTx<'_>,
items: Vec<crate::navigation::MenuItem>,
) -> Result<(), rustango::sql::ExecError> {
use crate::menu_item_translation::MenuItemTranslation;
if items.is_empty() {
return Ok(());
}
let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
if !ids.is_empty() {
let orphans: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
.where_(MenuItemTranslation::item_id.is_in(ids))
.fetch_tx(tx)
.await?;
for row in orphans {
row.delete_tx(tx).await?;
}
}
for it in crate::navigation::order_deepest_first(items) {
it.delete_tx(tx).await?;
}
Ok(())
}
#[derive(Debug, Deserialize)]
pub struct SaveTreeItem {
#[serde(default)]
pub id: Option<i64>,
pub local_id: i32,
#[serde(default)]
pub parent_local_id: Option<i32>,
pub label: String,
#[serde(default)]
pub page_id: Option<i64>,
#[serde(default)]
pub external_url: Option<String>,
#[serde(default)]
pub open_in_new_tab: bool,
}
#[derive(Debug, Deserialize)]
pub struct SaveTreePayload {
pub items: Vec<SaveTreeItem>,
}
pub async fn navigation_save_tree_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
axum::Json(payload): axum::Json<SaveTreePayload>,
) -> Result<Response, AdminError> {
for (i, item) in payload.items.iter().enumerate() {
if item.local_id as usize != i {
return Err(AdminError::Validation(format!(
"items[{i}].local_id must equal its array index"
)));
}
if let Some(p) = item.parent_local_id {
if (p as usize) >= i {
return Err(AdminError::Validation(format!(
"items[{i}].parent_local_id {p} must reference an earlier item"
)));
}
}
}
for (i, item) in payload.items.iter().enumerate() {
let external = item
.external_url
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty());
match (item.page_id, external) {
(Some(_), Some(_)) => {
return Err(AdminError::Validation(format!(
"items[{i}] sets both a page and an external URL — pick one"
)))
}
(None, None) => {
return Err(AdminError::Validation(format!(
"items[{i}] has no link target — set a page or an external URL"
)))
}
_ => {}
}
if item.label.chars().count() > 200 {
return Err(AdminError::Validation(format!(
"items[{i}].label is too long (max 200 characters)"
)));
}
if external.is_some_and(|u| u.chars().count() > 500) {
return Err(AdminError::Validation(format!(
"items[{i}].external_url is too long (max 500 characters)"
)));
}
}
let mut seen: std::collections::HashSet<i64> = std::collections::HashSet::new();
for (i, item) in payload.items.iter().enumerate() {
if let Some(iid) = item.id {
if !seen.insert(iid) {
return Err(AdminError::Validation(format!(
"items[{i}].id {iid} appears more than once"
)));
}
}
}
if crate::navigation::Menu::objects()
.where_(crate::navigation::Menu::id.eq(id))
.first(tenant.pool())
.await?
.is_none()
{
return Err(AdminError::NotFound(id));
}
let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.fetch(tenant.pool())
.await?;
let mut existing_by_id: std::collections::HashMap<i64, crate::navigation::MenuItem> = existing
.into_iter()
.filter_map(|it| it.id.get().copied().map(|iid| (iid, it)))
.collect();
let plan: Vec<Option<crate::navigation::MenuItem>> = payload
.items
.iter()
.map(|it| it.id.and_then(|iid| existing_by_id.remove(&iid)))
.collect();
let items_saved = payload.items.len();
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
let mut resolved: Vec<i64> = Vec::with_capacity(payload.items.len());
for ((i, item), claimed) in payload.items.iter().enumerate().zip(plan) {
let parent_id = item.parent_local_id.map(|p| resolved[p as usize]);
let external_url = item
.external_url
.as_ref()
.filter(|s| !s.trim().is_empty())
.cloned();
let sort_order = (i as i32) * 10;
let new_id = match claimed {
Some(mut row) => {
let iid = row.id.get().copied().unwrap_or_default();
row.parent_id = parent_id;
row.sort_order = sort_order;
row.label = item.label.clone();
row.page_id = item.page_id;
row.external_url = external_url;
row.open_in_new_tab = item.open_in_new_tab;
row.save_tx(tx).await?;
iid
}
None => {
let mut row = crate::navigation::MenuItem {
id: rustango::sql::Auto::Unset,
menu_id: id,
parent_id,
sort_order,
label: item.label.clone(),
page_id: item.page_id,
external_url,
open_in_new_tab: item.open_in_new_tab,
};
row.save_tx(tx).await?;
row.id.get().copied().unwrap_or_default()
}
};
resolved.push(new_id);
}
delete_menu_items_tx(tx, existing_by_id.into_values().collect()).await?;
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
Ok(axum::Json(serde_json::json!({
"ok": true,
"items_saved": items_saved,
}))
.into_response())
}
pub async fn navigation_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
) -> Result<Response, AdminError> {
let menu = crate::navigation::Menu::objects()
.where_(crate::navigation::Menu::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let items = crate::navigation::order_pre_order(
crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.order_by(&[("sort_order", false), ("id", false)])
.fetch(tenant.pool())
.await?,
);
let suggested: Vec<Page> = Page::objects()
.where_(Page::show_in_menus.eq(true))
.order_by(&[("title", false)])
.fetch(tenant.pool())
.await?;
let all_pages: Vec<Page> = Page::objects()
.order_by(&[("title", false)])
.fetch(tenant.pool())
.await?;
let by_page_id: std::collections::HashMap<i64, &Page> = all_pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let locales: Vec<Locale> = Locale::objects()
.where_(Locale::active.eq(true))
.order_by(&[("is_default", true), ("code", false)])
.fetch(tenant.pool())
.await?;
let editing_locale: Option<Locale> = match q.locale.as_deref().filter(|c| !c.is_empty()) {
Some(code) => locales.iter().find(|l| l.code == code).cloned(),
None => None,
};
let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
let item_translations = match editing_locale.as_ref().filter(|l| !l.is_default) {
Some(loc) => {
let lid = loc.id.get().copied().unwrap_or_default();
let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
crate::menu_item_translation::fetch_for_items(tenant.pool(), &ids, lid).await?
}
None => std::collections::HashMap::new(),
};
let item_rows: Vec<serde_json::Value> = items
.iter()
.map(|it| {
let resolved_label = if it.label.trim().is_empty() {
it.page_id
.and_then(|pid| by_page_id.get(&pid).map(|p| p.title.clone()))
.unwrap_or_default()
} else {
it.label.clone()
};
let resolved_url = match (it.page_id, it.external_url.clone()) {
(Some(pid), _) => by_page_id
.get(&pid)
.map(|p| p.url_path.clone())
.unwrap_or_else(|| "—".to_owned()),
(None, Some(url)) => url,
_ => "—".to_owned(),
};
let tr = it
.id
.get()
.and_then(|iid| item_translations.get(iid));
serde_json::json!({
"id": it.id.get().copied(),
"label": it.label,
"resolved_label": resolved_label,
"page_id": it.page_id,
"external_url": it.external_url,
"parent_id": it.parent_id,
"sort_order": it.sort_order,
"open_in_new_tab": it.open_in_new_tab,
"resolved_url": resolved_url,
"tr_label": tr.and_then(|m| m.get("label")).cloned().unwrap_or_default(),
"tr_external_url": tr
.and_then(|m| m.get("external_url"))
.cloned()
.unwrap_or_default(),
})
})
.collect();
let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
let linkable = |p: &&Page| error_tid.map_or(true, |tid| p.page_type_id != tid);
let picker_pages: Vec<serde_json::Value> = all_pages
.iter()
.filter(linkable)
.map(|p| {
serde_json::json!({
"id": p.id.get().copied(),
"title": p.title,
"url_path": p.url_path,
})
})
.collect();
let recent_pages_raw: Vec<Page> = Page::objects()
.order_by(&[("updated_at", true)])
.fetch(tenant.pool())
.await?;
let picker_recent: Vec<serde_json::Value> = recent_pages_raw
.iter()
.filter(linkable)
.take(20)
.map(|p| {
serde_json::json!({
"id": p.id.get().copied(),
"title": p.title,
"url_path": p.url_path,
"updated_at": p.updated_at,
})
})
.collect();
let mut picker_library: Vec<serde_json::Value> = Vec::new();
for handler in crate::library::registered_handlers() {
let entries = handler
.menu_picker_entries(tenant.pool())
.await
.map_err(|e| {
AdminError::Validation(format!(
"library `{}::menu_picker_entries` failed: {e}",
handler.type_name()
))
})?;
for entry in entries {
picker_library.push(serde_json::json!({
"label": entry.label,
"url": entry.url,
"kind_hint": entry.kind_hint,
"library_type": handler.verbose_name(),
}));
}
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("menu_id", &menu.id.get().copied());
ctx.insert("menu_slug", &menu.slug);
ctx.insert("menu_name", &menu.name);
ctx.insert("items", &item_rows);
ctx.insert("picker_pages", &picker_pages);
ctx.insert("picker_recent", &picker_recent);
ctx.insert("picker_library", &picker_library);
ctx.insert("has_library_picker", &!picker_library.is_empty());
ctx.insert("has_curated_picker", &!suggested.is_empty());
ctx.insert("locales", &locales);
ctx.insert("editing_locale", &editing_locale);
ctx.insert("translation_mode", &translation_mode);
render_with_csrf(
&state,
&headers,
"rcms_admin/navigation_edit.html",
&mut ctx,
)
}
pub async fn navigation_translate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
Path(id): Path<i64>,
Query(q): Query<EditQuery>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
use crate::menu_item_translation::MenuItemTranslation;
let code = q
.locale
.as_deref()
.filter(|c| !c.is_empty())
.ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
let locale = Locale::objects()
.where_(Locale::code.eq(code.to_owned()))
.where_(Locale::active.eq(true))
.first(tenant.pool())
.await?
.ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
if locale.is_default {
return Ok((
axum::http::StatusCode::BAD_REQUEST,
"cannot translate INTO the default locale; canonical labels live on cms_menu_item",
)
.into_response());
}
let locale_id = locale
.id
.get()
.copied()
.ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
let own_items: std::collections::HashSet<i64> = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::menu_id.eq(id))
.fetch(tenant.pool())
.await?
.iter()
.filter_map(|it| it.id.get().copied())
.collect();
let mut updates: Vec<(i64, String, String)> = Vec::new();
for (k, v) in &form {
let Some(rest) = k.strip_prefix("tr__") else {
continue;
};
let Some((raw_id, raw_field)) = rest.split_once("__") else {
continue;
};
let Ok(item_id) = raw_id.parse::<i64>() else {
continue;
};
if !own_items.contains(&item_id) {
continue;
}
if let Ok(field) = crate::menu_item_translation::validate_field_path(raw_field) {
updates.push((item_id, field, v.trim().to_owned()));
}
}
rustango::atomic!(tenant.pool(), |tx| {
let mut guard = tx.lock().await?;
let tx = &mut *guard;
for (item_id, field, value) in updates {
let existing: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
.where_(MenuItemTranslation::item_id.eq(item_id))
.where_(MenuItemTranslation::locale_id.eq(locale_id))
.where_(MenuItemTranslation::field_path.eq(field.clone()))
.fetch_tx(tx)
.await?;
if value.is_empty() {
for row in existing {
row.delete_tx(tx).await?;
}
} else if let Some(mut row) = existing.into_iter().next() {
row.value = value;
row.save_tx(tx).await?;
} else {
let mut row = MenuItemTranslation {
id: rustango::sql::Auto::Unset,
item_id,
locale_id,
field_path: field,
value,
updated_at: rustango::sql::Auto::Unset,
};
row.save_tx(tx).await?;
}
}
Ok::<_, rustango::sql::ExecError>(())
})
.await?;
Ok(Redirect::to(&format!(
"/cms-admin/navigation/{id}/edit?locale={code}"
))
.into_response())
}
#[derive(Debug, Deserialize)]
pub struct MenuItemForm {
pub label: String,
#[serde(default, deserialize_with = "super::deserialize_optional_i64")]
pub page_id: Option<i64>,
#[serde(default)]
pub external_url: Option<String>,
#[serde(default, deserialize_with = "super::deserialize_optional_i64")]
pub parent_id: Option<i64>,
#[serde(default)]
pub sort_order: Option<i32>,
#[serde(default)]
pub open_in_new_tab: Option<String>,
}
async fn validate_menu_parent(
tenant: &Tenant,
menu_id: i64,
parent_id: Option<i64>,
) -> Result<(), AdminError> {
let Some(pid) = parent_id else {
return Ok(());
};
let parent = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::id.eq(pid))
.first(tenant.pool())
.await?;
match parent {
Some(p) if p.menu_id == menu_id => Ok(()),
Some(_) => Err(AdminError::Validation(
"That parent item belongs to a different menu.".to_owned(),
)),
None => Err(AdminError::Validation(
"That parent item no longer exists.".to_owned(),
)),
}
}
impl MenuItemForm {
fn parsed_external_url(&self) -> Option<String> {
self.external_url
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned)
}
}
pub async fn navigation_item_create(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(menu_id): Path<i64>,
Form(form): Form<MenuItemForm>,
) -> Result<Response, AdminError> {
let external = form.parsed_external_url();
if form.page_id.is_some() == external.is_some() {
return redirect_named_with_params_and_message(
"rcms-admin:navigation:edit",
&[("id", menu_id.to_string())],
MsgLevel::Warning,
"Pick exactly one of: a page link, or a custom URL.",
&headers,
);
}
validate_menu_parent(&tenant, menu_id, form.parent_id).await?;
let mut row = crate::navigation::MenuItem {
id: rustango::sql::Auto::Unset,
menu_id,
parent_id: form.parent_id,
sort_order: form.sort_order.unwrap_or(100),
label: form.label.trim().to_owned(),
page_id: form.page_id,
external_url: external,
open_in_new_tab: form.open_in_new_tab.is_some(),
};
row.insert_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:navigation:edit",
&[("id", menu_id.to_string())],
MsgLevel::Success,
"Item added.",
&headers,
)
}
pub async fn navigation_item_delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path((menu_id, id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
let row = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::id.eq(id))
.where_(crate::navigation::MenuItem::menu_id.eq(menu_id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let children: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
.where_(crate::navigation::MenuItem::parent_id.eq(Some(id)))
.fetch(tenant.pool())
.await?;
for mut c in children {
c.parent_id = row.parent_id;
c.save_pool(tenant.pool()).await?;
}
row.delete_pool(tenant.pool()).await?;
redirect_named_with_params_and_message(
"rcms-admin:navigation:edit",
&[("id", menu_id.to_string())],
MsgLevel::Success,
"Item deleted.",
&headers,
)
}
pub async fn page_types_dashboard(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
let page_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
let mut latest: std::collections::HashMap<i64, chrono::DateTime<chrono::Utc>> =
std::collections::HashMap::new();
for p in &pages {
*counts.entry(p.page_type_id).or_insert(0) += 1;
if let Some(when) = p.published_at.or_else(|| p.created_at.get().copied()) {
latest
.entry(p.page_type_id)
.and_modify(|cur| {
if when > *cur {
*cur = when;
}
})
.or_insert(when);
}
}
let type_id_by_name: std::collections::HashMap<&str, i64> = page_types
.iter()
.filter_map(|t| t.id.get().copied().map(|id| (t.type_name.as_str(), id)))
.collect();
let mut handler_names = std::collections::BTreeSet::new();
let mut rows: Vec<serde_json::Value> = Vec::new();
for handler in crate::page_type::registered_handlers() {
let name = handler.type_name().to_owned();
handler_names.insert(name.clone());
let row_id = type_id_by_name.get(name.as_str()).copied();
let count = row_id.and_then(|id| counts.get(&id).copied()).unwrap_or(0);
let last = row_id.and_then(|id| latest.get(&id).copied());
rows.push(serde_json::json!({
"type_name": name,
"verbose_name": handler.verbose_name(),
"app_label": handler.app_label(),
"icon": handler.icon(),
"description": handler.description(),
"default_template": handler.default_template(),
"feed_kind": handler.feed_kind(),
"allowed_parents": handler.allowed_parent_types(),
"allowed_children": handler.allowed_child_types(),
"is_creatable": handler.is_creatable(),
"count": count,
"latest": last,
"registered": true,
"row_id": row_id,
}));
}
for t in &page_types {
if !handler_names.contains(&t.type_name) {
let id = t.id.get().copied().unwrap_or_default();
let count = counts.get(&id).copied().unwrap_or(0);
let ui_type = t.app_label == "cms_ui";
rows.push(serde_json::json!({
"type_name": t.type_name,
"verbose_name": t.verbose_name,
"app_label": t.app_label,
"icon": if ui_type { serde_json::Value::String("dashboard_customize".to_owned()) } else { serde_json::Value::Null },
"description": serde_json::Value::Null,
"default_template": t.default_template,
"feed_kind": serde_json::Value::Null,
"allowed_parents": t.allowed_parent_types.clone(),
"allowed_children": t.allowed_child_types.clone(),
"is_creatable": ui_type && t.is_creatable,
"count": count,
"latest": latest.get(&id).copied(),
"registered": false,
"row_id": id,
"ui_type": ui_type,
"deletable": ui_type && count == 0,
}));
}
}
rows.sort_by(|a, b| {
let ac = a.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
let bc = b.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
bc.cmp(&ac).then_with(|| {
a.get("verbose_name")
.and_then(|v| v.as_str())
.unwrap_or("")
.cmp(b.get("verbose_name").and_then(|v| v.as_str()).unwrap_or(""))
})
});
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("total_pages", &pages.len());
ctx.insert("total_types", &rows.len());
let can_build = session_user.as_ref().is_some_and(|u| u.is_superuser)
|| crate::permissions::user_codenames(
tenant.pool(),
session_user
.as_ref()
.and_then(|u| u.id.get().copied())
.unwrap_or_default(),
)
.await
.unwrap_or_default()
.contains("cms_page_type.build");
ctx.insert("can_build_types", &can_build);
ctx.insert("new_type_url", "/cms-admin/page-types/new");
render_with_csrf(&state, &headers, "rcms_admin/page_types.html", &mut ctx)
}
fn require_superuser_for_user_admin(
user: Option<&rustango::tenancy::auth::User>,
) -> Option<Response> {
use axum::response::{IntoResponse, Redirect};
user_admin_denial_target(user.map(|u| u.is_superuser))
.map(|path| Redirect::to(path).into_response())
}
fn user_admin_denial_target(is_superuser: Option<bool>) -> Option<&'static str> {
match is_superuser {
Some(true) => None,
Some(false) => Some("/cms-admin/no-access"),
None => Some("/login"),
}
}
pub async fn users_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.order_by(&[("username", false)])
.fetch(tenant.pool())
.await?;
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.fetch(tenant.pool())
.await?;
let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
rustango::tenancy::permissions::UserRole::objects()
.fetch(tenant.pool())
.await?;
let roles_by_id: std::collections::HashMap<i64, &rustango::tenancy::permissions::Role> = roles
.iter()
.filter_map(|r| r.id.get().copied().map(|id| (id, r)))
.collect();
let mut roles_by_user: std::collections::HashMap<i64, Vec<String>> =
std::collections::HashMap::new();
for ur in &user_roles {
if let Some(role) = roles_by_id.get(&ur.role_id) {
roles_by_user
.entry(ur.user_id)
.or_default()
.push(role.name.clone());
}
}
let rows: Vec<serde_json::Value> = users
.iter()
.map(|u| {
let id = u.id.get().copied();
serde_json::json!({
"id": id,
"username": u.username,
"email": user_email(u),
"is_superuser": u.is_superuser,
"active": u.active,
"created_at": u.created_at,
"password_changed_at": u.password_changed_at,
"roles": id.and_then(|i| roles_by_user.get(&i).cloned()).unwrap_or_default(),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("users", &rows);
ctx.insert("total_users", &users.len());
ctx.insert("active_users", &users.iter().filter(|u| u.active).count());
render_with_csrf(&state, &headers, "rcms_admin/users_list.html", &mut ctx)
}
#[derive(Debug, Deserialize)]
pub struct SecurityLogQuery {
#[serde(default)]
pub event: String,
#[serde(default)]
pub username: String,
#[serde(default)]
pub page: Option<i64>,
#[serde(default)]
pub per_page: Option<usize>,
}
fn security_event_tone(event: &str) -> &'static str {
use crate::security_log as log;
match event {
log::EVENT_LOGIN => "published",
log::EVENT_LOGIN_FAILED => "scheduled",
log::EVENT_LOCKOUT => "expired",
log::EVENT_PERMISSIONS_CHANGED => "archived",
_ => "draft",
}
}
pub async fn security_log_page(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<SecurityLogQuery>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let per_page = crate::admin::pagination::clamp_per_page(q.per_page);
let filter = crate::security_log::Filter {
event: q.event.trim().to_owned(),
username: q.username.trim().to_owned(),
};
let total = crate::security_log::count(tenant.pool(), &filter).await?;
let pagination = crate::admin::pagination::context(
q.page.unwrap_or(1),
per_page,
usize::try_from(total).unwrap_or(0),
);
let page = pagination["page"].as_i64().unwrap_or(1);
let events = crate::security_log::list(
tenant.pool(),
&filter,
per_page as i64,
crate::admin::pagination::offset(page, per_page),
)
.await?;
let rows: Vec<serde_json::Value> = events
.iter()
.map(|e| {
serde_json::json!({
"event": e.event,
"tone": security_event_tone(&e.event),
"source": e.source,
"user_id": e.user_id,
"username": e.username,
"reason": e.reason,
"actor": e.actor,
"detail": e.detail,
"ip_address": e.ip_address,
"user_agent": e.user_agent,
"created_at": e.created_at.get().copied(),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "security-log", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("rows", &rows);
ctx.insert("total", &total);
ctx.insert("events", crate::security_log::EVENTS);
ctx.insert("filter_event", &filter.event);
ctx.insert("filter_username", &filter.username);
ctx.insert("pagination", &pagination);
render_with_csrf(&state, &headers, "rcms_admin/security_log.html", &mut ctx)
}
pub async fn roles_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let perms: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.fetch(tenant.pool())
.await?;
let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
rustango::tenancy::permissions::UserRole::objects()
.fetch(tenant.pool())
.await?;
let mut perm_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for p in &perms {
*perm_counts.entry(p.role_id).or_insert(0) += 1;
}
let mut member_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
for ur in &user_roles {
*member_counts.entry(ur.role_id).or_insert(0) += 1;
}
let rows: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
let id = r.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": id,
"name": r.name,
"description": r.description,
"perm_count": perm_counts.get(&id).copied().unwrap_or(0),
"member_count": member_counts.get(&id).copied().unwrap_or(0),
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("roles", &rows);
render_with_csrf(&state, &headers, "rcms_admin/roles_list.html", &mut ctx)
}
pub async fn permissions_overview(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let perms: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.fetch(tenant.pool())
.await?;
let granted: std::collections::HashSet<(i64, String)> = perms
.iter()
.map(|p| (p.role_id, p.codename.clone()))
.collect();
let role_headers: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
serde_json::json!({
"id": r.id.get().copied().unwrap_or_default(),
"name": r.name,
})
})
.collect();
let sections: Vec<serde_json::Value> = super::resources::grouped()
.into_iter()
.map(|(section, resources)| {
let rows: Vec<serde_json::Value> = resources
.iter()
.map(|res| {
let cells: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
let rid = r.id.get().copied().unwrap_or_default();
let actions = super::resources::granted_actions(res, rid, &granted);
serde_json::json!({
"actions": actions,
"any": !actions.is_empty(),
})
})
.collect();
serde_json::json!({
"label": res.label,
"key": res.key,
"cells": cells,
})
})
.collect();
serde_json::json!({
"label": section.label(),
"rows": rows,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "permissions", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("roles", &role_headers);
ctx.insert("sections", §ions);
ctx.insert("role_count", &role_headers.len());
render_with_csrf(
&state,
&headers,
"rcms_admin/permissions_overview.html",
&mut ctx,
)
}
pub async fn roles_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert(
"role",
&serde_json::json!({ "id": serde_json::Value::Null, "name": "", "description": "", "permissions": [] }),
);
ctx.insert("matrix", &build_permission_matrix(&[]));
ctx.insert("legacy_codenames", &Vec::<String>::new());
render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
}
pub async fn roles_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let role = rustango::tenancy::permissions::Role::objects()
.where_(rustango::tenancy::permissions::Role::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let perms: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
.order_by(&[("codename", false)])
.fetch(tenant.pool())
.await?;
let codenames: Vec<String> = perms.iter().map(|p| p.codename.clone()).collect();
let (_matched, legacy) = split_matrix_codenames(&codenames);
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert(
"role",
&serde_json::json!({
"id": role.id.get().copied(),
"name": role.name,
"description": role.description,
"permissions": codenames,
}),
);
ctx.insert("matrix", &build_permission_matrix(&codenames));
ctx.insert("legacy_codenames", &legacy);
render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
}
fn build_permission_matrix(granted: &[String]) -> serde_json::Value {
use super::resources::{codename, grouped};
use crate::permissions::Action;
let granted_set: std::collections::HashSet<&str> = granted.iter().map(String::as_str).collect();
let mut sections = Vec::new();
for (section, rows) in grouped() {
let rows_json: Vec<serde_json::Value> = rows
.iter()
.map(|r| {
let applicable: Vec<&str> = r.actions.iter().map(|a| a.as_str()).collect();
let granted_actions: Vec<&str> = [
Action::Access,
Action::AccessAdmin,
Action::View,
Action::Add,
Action::Edit,
Action::Publish,
Action::Delete,
]
.iter()
.copied()
.filter(|action| {
r.actions.contains(action)
&& granted_set.contains(codename(r, *action).as_str())
})
.map(|a| a.as_str())
.collect();
serde_json::json!({
"key": r.key,
"label": r.label,
"applicable": applicable,
"granted": granted_actions,
})
})
.collect();
sections.push(serde_json::json!({
"section_label": section.label(),
"rows": rows_json,
}));
}
serde_json::Value::Array(sections)
}
fn split_matrix_codenames(granted: &[String]) -> (Vec<String>, Vec<String>) {
use super::resources::{all_resources, codename};
use crate::permissions::Action;
let known: std::collections::HashSet<String> = all_resources()
.iter()
.flat_map(|r| {
r.actions
.iter()
.copied()
.filter(|a| {
matches!(
a,
Action::View
| Action::Add
| Action::Edit
| Action::Publish
| Action::Delete
| Action::Access
| Action::AccessAdmin
)
})
.map(|a| codename(r, a))
.collect::<Vec<_>>()
})
.collect();
let (matched, legacy): (Vec<String>, Vec<String>) =
granted.iter().cloned().partition(|c| known.contains(c));
(matched, legacy)
}
fn parse_matrix_form(form: &std::collections::HashMap<String, String>) -> Vec<String> {
use super::resources::{all_resources, codename};
use crate::permissions::Action;
let resources = all_resources();
let resource_by_key: std::collections::HashMap<&str, &super::resources::AdminResource> =
resources.iter().map(|r| (r.key.as_str(), r)).collect();
let mut out = Vec::new();
for (raw_key, value) in form {
let Some(rest) = raw_key.strip_prefix("perm[") else {
continue;
};
let Some((key, rest)) = rest.split_once("][") else {
continue;
};
let Some(action_str) = rest.strip_suffix(']') else {
continue;
};
if value.is_empty() || value == "0" || value.eq_ignore_ascii_case("off") {
continue;
}
let Some(resource) = resource_by_key.get(key) else {
continue;
};
let action = match action_str {
"view" => Action::View,
"add" => Action::Add,
"edit" => Action::Edit,
"publish" => Action::Publish,
"delete" => Action::Delete,
"access" => Action::Access,
"access_admin" => Action::AccessAdmin,
_ => continue,
};
if !resource.actions.contains(&action) {
continue;
}
out.push(codename(resource, action));
}
out.sort();
out.dedup();
out
}
async fn sync_role_codenames(
pool: &rustango::sql::Pool,
role_id: i64,
new_codenames: &[String],
) -> Result<(), AdminError> {
let existing: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
.fetch(pool)
.await?;
let want: std::collections::BTreeSet<&str> = new_codenames.iter().map(String::as_str).collect();
let have: std::collections::BTreeSet<&str> =
existing.iter().map(|p| p.codename.as_str()).collect();
for p in &existing {
if !want.contains(p.codename.as_str()) {
p.clone().delete_pool(pool).await?;
}
}
for codename in new_codenames {
if !have.contains(codename.as_str()) {
let mut row = rustango::tenancy::permissions::RolePermission {
id: rustango::sql::Auto::Unset,
role_id,
codename: codename.clone(),
};
row.insert_pool(pool).await?;
}
}
Ok(())
}
pub async fn roles_create_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
if name.is_empty() {
return Err(AdminError::Validation("Role name is required.".to_owned()));
}
let description = form
.get("description")
.map(|s| s.trim())
.unwrap_or("")
.to_owned();
let mut row = rustango::tenancy::permissions::Role {
id: rustango::sql::Auto::Unset,
name: name.clone(),
description,
data: serde_json::Value::Object(serde_json::Map::new()),
};
row.insert_pool(tenant.pool()).await?;
let role_id = row.id.get().copied().unwrap_or_default();
let codenames = parse_matrix_form(&form);
sync_role_codenames(tenant.pool(), role_id, &codenames).await?;
let detail = crate::security_log::describe_role_change(&name, &[], &codenames)
.unwrap_or_else(|| format!("role “{name}”: no permissions"));
record_access_change(&tenant, session_user.as_ref(), &request, None, format!("created {detail}"))
.await;
redirect_named_with_message_args(
"rcms-admin:roles",
MsgLevel::Success,
"Role “{name}” created.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn roles_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut role = rustango::tenancy::permissions::Role::objects()
.where_(rustango::tenancy::permissions::Role::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
if name.is_empty() {
return Err(AdminError::Validation("Role name is required.".to_owned()));
}
let description = form
.get("description")
.map(|s| s.trim())
.unwrap_or("")
.to_owned();
role.name = name.clone();
role.description = description;
role.save_pool(tenant.pool()).await?;
let existing: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
.fetch(tenant.pool())
.await?;
let existing_codenames: Vec<String> = existing.into_iter().map(|p| p.codename).collect();
let (_old_matrix, legacy) = split_matrix_codenames(&existing_codenames);
let mut codenames = parse_matrix_form(&form);
codenames.extend(legacy);
codenames.sort();
codenames.dedup();
sync_role_codenames(tenant.pool(), id, &codenames).await?;
if let Some(detail) =
crate::security_log::describe_role_change(&name, &existing_codenames, &codenames)
{
record_access_change(&tenant, session_user.as_ref(), &request, None, detail).await;
}
redirect_named_with_message_args(
"rcms-admin:roles",
MsgLevel::Success,
"Role “{name}” saved.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn roles_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let role = rustango::tenancy::permissions::Role::objects()
.where_(rustango::tenancy::permissions::Role::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let name = role.name.clone();
for p in rustango::tenancy::permissions::RolePermission::objects()
.where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
.fetch(tenant.pool())
.await?
{
p.delete_pool(tenant.pool()).await?;
}
for ur in rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::role_id.eq(id))
.fetch(tenant.pool())
.await?
{
ur.delete_pool(tenant.pool()).await?;
}
role.delete_pool(tenant.pool()).await?;
record_access_change(
&tenant,
session_user.as_ref(),
&request,
None,
format!("deleted role “{name}”"),
)
.await;
redirect_named_with_message_args(
"rcms-admin:roles",
MsgLevel::Success,
"Role “{name}” deleted.",
&[("name", name.as_str())],
&headers,
)
}
pub async fn users_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert(
"user",
&serde_json::json!({
"id": serde_json::Value::Null,
"username": "",
"is_superuser": false,
"active": true,
}),
);
let role_choices: Vec<serde_json::Value> = rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?
.iter()
.map(|r| {
serde_json::json!({
"id": r.id.get().copied().unwrap_or_default(),
"name": r.name,
"description": r.description,
"assigned": false,
})
})
.collect();
ctx.insert("role_choices", &role_choices);
render_with_csrf(&state, &headers, "rcms_admin/user_form.html", &mut ctx)
}
pub async fn users_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
render_user_edit_page(&state, &tenant, &headers, session_user.as_ref(), id, None).await
}
async fn render_user_edit_page(
state: &super::AdminState,
tenant: &Tenant,
headers: &HeaderMap,
session_user: Option<&rustango::tenancy::auth::User>,
id: i64,
mcp_one_time: Option<serde_json::Value>,
) -> Result<Response, AdminError> {
let user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let roles: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let memberships: Vec<rustango::tenancy::permissions::UserRole> =
rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::user_id.eq(id))
.fetch(tenant.pool())
.await?;
let assigned: std::collections::BTreeSet<i64> = memberships.iter().map(|m| m.role_id).collect();
let role_choices: Vec<serde_json::Value> = roles
.iter()
.map(|r| {
let rid = r.id.get().copied().unwrap_or_default();
serde_json::json!({
"id": rid,
"name": r.name,
"description": r.description,
"assigned": assigned.contains(&rid),
})
})
.collect();
let user_timezone = user
.data
.get("timezone")
.and_then(serde_json::Value::as_str)
.unwrap_or("")
.to_owned();
let user_email = user_email(&user);
let mut ctx = Context::new();
add_chrome(&mut ctx, tenant, "users", session_user).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert(
"user",
&serde_json::json!({
"id": user.id.get().copied(),
"username": user.username,
"email": user_email,
"is_superuser": user.is_superuser,
"active": user.active,
"timezone": user_timezone,
"password_changed_at": user.password_changed_at,
"created_at": user.created_at,
}),
);
ctx.insert("role_choices", &role_choices);
let (keys, skills) = mcp_keys_ctx(tenant.pool(), id).await;
ctx.insert("mcp_keys", &keys);
ctx.insert("mcp_skills", &skills);
if let Some(one_time) = &mcp_one_time {
ctx.insert("mcp_one_time", one_time);
}
render_with_csrf(state, headers, "rcms_admin/user_form.html", &mut ctx)
}
fn parse_mcp_key_form(pairs: &[(String, String)]) -> (String, Vec<String>) {
let label = pairs
.iter()
.find(|(k, _)| k == "label")
.map(|(_, v)| v.trim())
.filter(|v| !v.is_empty())
.unwrap_or("MCP key")
.to_owned();
let skills: Vec<String> = pairs
.iter()
.filter(|(k, v)| k == "skill" && !v.trim().is_empty())
.map(|(_, v)| v.trim().to_owned())
.collect();
(label, skills)
}
async fn audit_mcp_key(
pool: &rustango::sql::Pool,
actor_id: i64,
what: &str,
detail: serde_json::Value,
) {
let entry = rustango::audit::PendingEntry {
entity_table: "rustango_agents",
entity_pk: detail
.get("key_id")
.and_then(serde_json::Value::as_i64)
.map(|i| i.to_string())
.unwrap_or_default(),
operation: rustango::audit::AuditOp::Action,
source: rustango::audit::AuditSource::User {
id: actor_id.to_string(),
},
changes: serde_json::json!({ "event": what, "detail": detail }),
};
if let Err(e) = rustango::audit::emit_one_pool(pool, &entry).await {
tracing::warn!(error = %e, "mcp key audit emit failed");
}
}
async fn mint_mcp_key(
pool: &rustango::sql::Pool,
actor_id: i64,
owner_id: i64,
label: &str,
skills: &[String],
) -> Result<serde_json::Value, String> {
match rustango::tenancy::create_user_key_pool(pool, owner_id, label, skills).await {
Ok(issued) => {
let key_id = issued.agent.id.get().copied().unwrap_or_default();
audit_mcp_key(
pool,
actor_id,
"created",
serde_json::json!({ "key_id": key_id, "owner_id": owner_id, "label": label, "scope": skills }),
)
.await;
Ok(serde_json::json!({ "token": issued.token, "label": label }))
}
Err(e) => Err(e.to_string()),
}
}
pub async fn account_mcp_key_create(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(pairs): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let (label, skills) = parse_mcp_key_form(&pairs);
match mint_mcp_key(tenant.pool(), uid, uid, &label, &skills).await {
Ok(one_time) => {
render_account_page(
&state,
&tenant,
&headers,
session_user.as_ref(),
Some(one_time),
)
.await
}
Err(msg) => redirect_named_with_message_args(
"rcms-admin:account",
MsgLevel::Error,
"Couldn't create the key: {error}",
&[("error", msg.as_str())],
&headers,
),
}
}
pub async fn account_mcp_key_revoke(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(key_id): Path<i64>,
) -> Result<Response, AdminError> {
let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
match rustango::tenancy::revoke_user_key_pool(tenant.pool(), uid, key_id).await {
Ok(()) => {
audit_mcp_key(
tenant.pool(),
uid,
"revoked",
serde_json::json!({ "key_id": key_id, "owner_id": uid }),
)
.await;
redirect_named_with_message_args(
"rcms-admin:account",
MsgLevel::Success,
"MCP key revoked.",
&[],
&headers,
)
}
Err(e) => {
let msg = e.to_string();
redirect_named_with_message_args(
"rcms-admin:account",
MsgLevel::Error,
"Couldn't revoke the key: {error}",
&[("error", msg.as_str())],
&headers,
)
}
}
}
pub async fn users_mcp_key_create(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(user_id): Path<i64>,
Form(pairs): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
let (label, skills) = parse_mcp_key_form(&pairs);
match mint_mcp_key(tenant.pool(), actor_id, user_id, &label, &skills).await {
Ok(one_time) => {
render_user_edit_page(
&state,
&tenant,
&headers,
session_user.as_ref(),
user_id,
Some(one_time),
)
.await
}
Err(msg) => redirect_named_with_params_and_message_args(
"rcms-admin:users:edit",
&[("id", user_id.to_string())],
MsgLevel::Error,
"Couldn't create the key: {error}",
&[("error", msg.as_str())],
&headers,
),
}
}
pub async fn users_mcp_key_revoke(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path((user_id, key_id)): Path<(i64, i64)>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
return Ok(unauthorized_no_session());
};
match rustango::tenancy::revoke_user_key_pool(tenant.pool(), user_id, key_id).await {
Ok(()) => {
audit_mcp_key(
tenant.pool(),
actor_id,
"revoked",
serde_json::json!({ "key_id": key_id, "owner_id": user_id }),
)
.await;
redirect_named_with_params_and_message_args(
"rcms-admin:users:edit",
&[("id", user_id.to_string())],
MsgLevel::Success,
"MCP key revoked.",
&[],
&headers,
)
}
Err(e) => {
let msg = e.to_string();
redirect_named_with_params_and_message_args(
"rcms-admin:users:edit",
&[("id", user_id.to_string())],
MsgLevel::Error,
"Couldn't revoke the key: {error}",
&[("error", msg.as_str())],
&headers,
)
}
}
}
#[derive(Deserialize)]
pub struct UserForm {
pub username: String,
#[serde(default)]
pub email: Option<String>,
#[serde(default)]
pub password: Option<String>,
#[serde(default)]
pub is_superuser: Option<String>,
#[serde(default)]
pub active: Option<String>,
}
fn validate_optional_email(raw: Option<&str>) -> Result<String, String> {
let e = raw.map(str::trim).unwrap_or("");
if e.is_empty() {
return Ok(String::new());
}
let ok = e.split('@').count() == 2
&& e.split('@').all(|p| !p.is_empty())
&& !e.contains(char::is_whitespace);
if ok {
Ok(e.to_owned())
} else {
Err(format!("“{e}” is not a valid email address."))
}
}
pub async fn users_create_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(pairs): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
use rustango::sql::Auto;
let single = |k: &str| pairs.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
let form = UserForm {
username: single("username").unwrap_or_default(),
email: single("email"),
password: single("password"),
is_superuser: single("is_superuser"),
active: single("active"),
};
let role_ids: Vec<i64> = pairs
.iter()
.filter(|(k, _)| k == "role_id")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
let username = form.username.trim().to_owned();
let password = form
.password
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
if username.is_empty() || password.is_none() {
return Err(AdminError::Validation(
"Username and initial password are both required.".to_owned(),
));
}
let hash = crate::passwords::hash(password.as_deref().unwrap_or_default()).await
.map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
let email = validate_optional_email(form.email.as_deref()).map_err(AdminError::Validation)?;
let email_col = (!email.is_empty()).then(|| email.clone());
let mut data = serde_json::Map::new();
if !email.is_empty() {
data.insert("email".to_owned(), serde_json::Value::String(email));
}
let mut row = rustango::tenancy::auth::User {
id: Auto::Unset,
username: username.clone(),
password_hash: hash,
email: email_col,
is_superuser: form.is_superuser.is_some(),
active: form.active.is_some(),
created_at: chrono::Utc::now(),
data: serde_json::Value::Object(data),
password_changed_at: Some(chrono::Utc::now()),
sessions_revoked_at: None,
};
row.insert_pool(tenant.pool()).await?;
if let Some(new_id) = row.id.get().copied() {
sync_user_roles(tenant.pool(), new_id, &role_ids).await?;
}
let access = user_access(tenant.pool(), &row).await?;
record_access_change(
&tenant,
session_user.as_ref(),
&request,
Some(&row),
crate::security_log::describe_new_user(&access),
)
.await;
redirect_named_with_message_args(
"rcms-admin:users",
MsgLevel::Success,
"User “{username}” created.",
&[("username", username.as_str())],
&headers,
)
}
pub async fn users_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let single = |key: &str| -> Option<String> {
form.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
};
let username_raw = single("username").unwrap_or_default();
let username = username_raw.trim().to_owned();
if username.is_empty() {
return Err(AdminError::Validation(
"Username cannot be empty.".to_owned(),
));
}
let password = single("password");
let is_superuser = form.iter().any(|(k, _)| k == "is_superuser");
let active = form.iter().any(|(k, _)| k == "active");
let timezone_raw = single("timezone").unwrap_or_default();
let timezone = timezone_raw.trim().to_owned();
let email =
validate_optional_email(single("email").as_deref()).map_err(AdminError::Validation)?;
let role_ids: Vec<i64> = form
.iter()
.filter(|(k, _)| k == "role_id")
.filter_map(|(_, v)| v.parse::<i64>().ok())
.collect();
let mut user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let before = user_access(tenant.pool(), &user).await?;
user.username = username.clone();
user.is_superuser = is_superuser;
user.active = active;
{
let map = user.data.as_object_mut().ok_or_else(|| {
AdminError::Validation(
"User.data is not a JSON object — refusing to overwrite.".to_owned(),
)
})?;
if timezone.is_empty() {
map.remove("timezone");
} else {
map.insert(
"timezone".to_owned(),
serde_json::Value::String(timezone.clone()),
);
}
if email.is_empty() {
map.remove("email");
} else {
map.insert("email".to_owned(), serde_json::Value::String(email.clone()));
}
}
user.email = (!email.is_empty()).then(|| email.clone());
let rotated = password.as_deref().map(str::trim).filter(|s| !s.is_empty());
if let Some(new_pw) = rotated {
let hash = crate::passwords::hash(new_pw).await
.map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
user.password_hash = hash;
user.password_changed_at = Some(chrono::Utc::now());
}
user.save_pool(tenant.pool()).await?;
sync_user_roles(tenant.pool(), id, &role_ids).await?;
let after = user_access(tenant.pool(), &user).await?;
if let Some(detail) = crate::security_log::describe_user_change(&before, &after) {
record_access_change(&tenant, session_user.as_ref(), &request, Some(&user), detail).await;
}
if rotated.is_some() {
redirect_named_with_message_args(
"rcms-admin:users",
MsgLevel::Success,
"User “{username}” saved (password rotated).",
&[("username", username.as_str())],
&headers,
)
} else {
redirect_named_with_message_args(
"rcms-admin:users",
MsgLevel::Success,
"User “{username}” saved.",
&[("username", username.as_str())],
&headers,
)
}
}
async fn sync_user_roles(
pool: &rustango::sql::Pool,
user_id: i64,
new_role_ids: &[i64],
) -> Result<(), AdminError> {
let existing: Vec<rustango::tenancy::permissions::UserRole> =
rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
.fetch(pool)
.await?;
let want: std::collections::BTreeSet<i64> = new_role_ids.iter().copied().collect();
let have: std::collections::BTreeSet<i64> = existing.iter().map(|m| m.role_id).collect();
for m in &existing {
if !want.contains(&m.role_id) {
m.clone().delete_pool(pool).await?;
}
}
for role_id in new_role_ids {
if !have.contains(role_id) {
let mut row = rustango::tenancy::permissions::UserRole {
id: rustango::sql::Auto::Unset,
user_id,
role_id: *role_id,
};
row.insert_pool(pool).await?;
}
}
Ok(())
}
async fn user_access(
pool: &rustango::sql::Pool,
user: &rustango::tenancy::auth::User,
) -> Result<crate::security_log::Access, AdminError> {
use rustango::tenancy::permissions::{Role, UserRole};
let role_ids: Vec<i64> = match user.id.get().copied() {
Some(uid) => UserRole::objects()
.where_(UserRole::user_id.eq(uid))
.fetch(pool)
.await?
.into_iter()
.map(|m| m.role_id)
.collect(),
None => Vec::new(),
};
let roles = if role_ids.is_empty() {
Vec::new()
} else {
Role::objects()
.where_(Role::id.is_in(role_ids))
.fetch(pool)
.await?
.into_iter()
.map(|r| r.name)
.collect()
};
Ok(crate::security_log::Access {
superuser: user.is_superuser,
active: user.active,
roles,
})
}
async fn record_access_change(
tenant: &Tenant,
actor: Option<&rustango::tenancy::auth::User>,
request: &crate::security_log::LoginRequest,
target: Option<&rustango::tenancy::auth::User>,
detail: String,
) {
let mut entry = SecurityEntry::new(
crate::security_log::EVENT_PERMISSIONS_CHANGED,
"admin",
&request.meta,
)
.change(actor.map_or("", |u| u.username.as_str()), detail);
if let Some(user) = target {
entry = entry.user(user.id.get().copied(), &user.username);
}
crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
}
pub async fn users_deactivate_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let was_active = user.active;
user.active = false;
user.save_pool(tenant.pool()).await?;
if was_active {
record_access_change(
&tenant,
session_user.as_ref(),
&request,
Some(&user),
"active: on → off".to_owned(),
)
.await;
}
redirect_named_with_message_args(
"rcms-admin:users",
MsgLevel::Success,
"User “{username}” deactivated.",
&[("username", user.username.as_str())],
&headers,
)
}
pub async fn users_bulk_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(pairs): Form<Vec<(String, String)>>,
) -> Result<Response, AdminError> {
if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
return Ok(redirect);
}
let mut ids: Vec<i64> = Vec::new();
let mut action = String::new();
for (k, v) in &pairs {
match k.as_str() {
"user_id" => {
if let Ok(id) = v.parse::<i64>() {
ids.push(id);
}
}
"action" => action = v.clone(),
_ => {}
}
}
let target_active = match action.as_str() {
"enable" => true,
"disable" => false,
_ => {
return redirect_named_with_message(
"rcms-admin:users",
MsgLevel::Error,
"Unknown bulk action.",
&headers,
);
}
};
if ids.is_empty() {
return redirect_named_with_message(
"rcms-admin:users",
MsgLevel::Info,
"No users selected.",
&headers,
);
}
let me = session_user.as_ref().and_then(|u| u.id.get().copied());
let mut changed = 0usize;
let mut skipped_self = false;
for id in ids {
if !target_active && Some(id) == me {
skipped_self = true;
continue;
}
if let Some(mut user) = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(id))
.first(tenant.pool())
.await?
{
if user.active != target_active {
user.active = target_active;
user.save_pool(tenant.pool()).await?;
changed += 1;
let detail = if target_active { "active: off → on" } else { "active: on → off" };
record_access_change(
&tenant,
session_user.as_ref(),
&request,
Some(&user),
detail.to_owned(),
)
.await;
}
}
}
let verb = if target_active { "Enabled" } else { "Disabled" };
let mut msg = format!("{verb} {changed} user(s).");
if skipped_self {
msg.push_str(" (Skipped your own account.)");
}
redirect_named_with_message("rcms-admin:users", MsgLevel::Success, &msg, &headers)
}
pub async fn settings_page(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let locales: Vec<Locale> = Locale::objects()
.order_by(&[("sort_order", false), ("code", false)])
.fetch(tenant.pool())
.await?;
let media_count: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await?;
let theme_rows: Vec<serde_json::Value> = themes
.iter()
.map(|t| {
serde_json::json!({
"id": t.id.get().copied(),
"name": t.name,
"slug": t.slug,
"is_admin_default": t.is_admin_default,
"is_default": t.is_default,
"color_bg": t.color_bg,
"color_surface": t.color_surface,
"color_text_primary": t.color_text_primary,
"color_link": t.color_link,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "settings", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("locales", &locales);
ctx.insert("media_count", &media_count.len());
ctx.insert("org_slug", &tenant.org.slug);
ctx.insert("org_display_name", &tenant.org.display_name);
ctx.insert("themes", &theme_rows);
if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
let logo_key = row
.value_json
.get("logo_storage_key")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_owned();
let favicon_key = row
.value_json
.get("favicon_storage_key")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_owned();
ctx.insert("branding_logo_filename", &logo_key);
ctx.insert("branding_favicon_filename", &favicon_key);
ctx.insert(
"branding_site_name",
row.value_json.get("site_name").and_then(|v| v.as_str()).unwrap_or(""),
);
}
render_with_csrf(&state, &headers, "rcms_admin/settings.html", &mut ctx)
}
pub async fn settings_branding_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
let mut logo_filename: Option<String> = None;
let mut favicon_filename: Option<String> = None;
let mut site_name: Option<String> = None;
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
let field_name = field.name().unwrap_or("").to_owned();
let original = field.file_name().map(|s| s.to_owned());
let bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read field {field_name}: {e}")))?;
if field_name == "site_name" {
site_name = Some(String::from_utf8_lossy(&bytes).trim().chars().take(120).collect());
continue;
}
if bytes.is_empty() {
continue;
}
let (slot, default_ext) = match field_name.as_str() {
"logo" => (&mut logo_filename, "png"),
"favicon" => (&mut favicon_filename, "ico"),
_ => continue,
};
let safe_ext = original
.as_deref()
.and_then(|n| n.rsplit_once('.'))
.map(|(_, ext)| ext)
.filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
.map(str::to_ascii_lowercase)
.unwrap_or_else(|| default_ext.to_owned());
let storage_name = format!("{field_name}.{safe_ext}");
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &format!("branding/{storage_name}")),
&bytes,
)
.await
.map_err(|e| AdminError::Upload(format!("write {field_name}: {e}")))?;
*slot = Some(storage_name);
}
let existing = crate::site_setting::get(tenant.pool(), "branding")
.await
.unwrap_or_default()
.map(|r| r.value_json)
.unwrap_or_else(|| serde_json::json!({}));
let mut value = existing.as_object().cloned().unwrap_or_default();
if let Some(name) = logo_filename {
value.insert("logo_storage_key".to_owned(), serde_json::json!(name));
}
if let Some(name) = favicon_filename {
value.insert("favicon_storage_key".to_owned(), serde_json::json!(name));
}
match site_name {
Some(n) if n.is_empty() => {
value.remove("site_name");
}
Some(n) => {
value.insert("site_name".to_owned(), serde_json::json!(n));
}
None => {}
}
let _ =
crate::site_setting::upsert(tenant.pool(), "branding", serde_json::Value::Object(value))
.await?;
redirect_named_with_message(
"rcms-admin:settings",
MsgLevel::Success,
"Branding saved. Reload to see the new logo / favicon.",
&headers,
)
}
pub async fn settings_branding_serve_logo(headers: HeaderMap, tenant: Tenant) -> Response {
serve_branding_asset(&headers, &tenant, "logo_storage_key").await
}
pub async fn settings_branding_serve_favicon(headers: HeaderMap, tenant: Tenant) -> Response {
serve_branding_asset(&headers, &tenant, "favicon_storage_key").await
}
async fn serve_branding_asset(headers: &HeaderMap, tenant: &Tenant, slot: &str) -> Response {
let setting = match crate::site_setting::get(tenant.pool(), "branding").await {
Ok(Some(s)) => s,
_ => {
return (axum::http::StatusCode::NOT_FOUND, "no branding set").into_response();
}
};
let storage_name = match setting.value_json.get(slot).and_then(|v| v.as_str()) {
Some(s) if !s.is_empty() => s.to_owned(),
_ => {
return (axum::http::StatusCode::NOT_FOUND, "asset not set").into_response();
}
};
if storage_name.contains('/') || storage_name.contains("..") {
return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
}
let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(
&tenant.org.slug,
&format!("branding/{storage_name}"),
))
.await
{
Ok(b) => b,
Err(_) => {
return (axum::http::StatusCode::NOT_FOUND, "branding bytes missing").into_response();
}
};
let mime = mime_guess::from_path(&storage_name)
.first_or_octet_stream()
.essence_str()
.to_owned();
revalidated_asset(headers, mime, bytes)
}
fn revalidated_asset(headers: &HeaderMap, mime: String, bytes: Vec<u8>) -> Response {
use sha2::{Digest, Sha256};
let digest = Sha256::digest(&bytes);
let mut etag = String::with_capacity(34);
etag.push('"');
for b in digest.iter().take(16) {
use std::fmt::Write as _;
let _ = write!(etag, "{b:02x}");
}
etag.push('"');
let matches_etag = headers
.get(axum::http::header::IF_NONE_MATCH)
.and_then(|v| v.to_str().ok())
.is_some_and(|inm| inm.split(',').any(|t| t.trim() == etag));
if matches_etag {
return (
axum::http::StatusCode::NOT_MODIFIED,
[
(axum::http::header::ETAG, etag),
(axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
],
)
.into_response();
}
(
[
(axum::http::header::CONTENT_TYPE, mime),
(axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
(axum::http::header::ETAG, etag),
],
bytes,
)
.into_response()
}
#[derive(Debug, Deserialize)]
pub struct ThemeSwitchForm {
pub surface: String,
pub theme_id: i64,
}
pub async fn settings_theme_switch(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
Form(form): Form<ThemeSwitchForm>,
) -> Result<Response, AdminError> {
if form.surface != "admin" && form.surface != "public" {
return Err(AdminError::Validation(format!(
"Unknown surface `{}` — expected `admin` or `public`.",
form.surface
)));
}
let target = crate::theme::Theme::objects()
.where_(crate::theme::Theme::id.eq(form.theme_id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(form.theme_id))?;
let all_themes: Vec<crate::theme::Theme> =
crate::theme::Theme::objects().fetch(tenant.pool()).await?;
for mut t in all_themes {
let target_id = target.id.get().copied().unwrap_or_default();
let this_id = t.id.get().copied().unwrap_or_default();
if form.surface == "admin" {
t.is_admin_default = this_id == target_id;
} else {
t.is_default = this_id == target_id;
}
t.save_pool(tenant.pool()).await?;
}
if wants_json_response(&headers) && form.surface == "admin" {
let target_id = target.id.get().copied().unwrap_or_default();
let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
.where_(crate::theme::BrandColor::theme_id.eq(target_id))
.order_by(&[("sort_order", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
let css = crate::theme::emit_css(&target, &brand_colors);
return Ok(Json(serde_json::json!({
"ok": true,
"id": target_id,
"slug": target.slug,
"name": target.name,
"default_mode": target.default_mode,
"css": css,
"message": format!("Admin theme switched to “{}”.", target.name),
}))
.into_response());
}
let redirect_target = if form.surface == "admin" {
"rcms-admin:account"
} else {
"rcms-admin:settings"
};
let theme_flash = if form.surface == "admin" {
"Admin theme switched to “{name}”."
} else {
"Public theme switched to “{name}”."
};
redirect_named_with_message_args(
redirect_target,
MsgLevel::Success,
theme_flash,
&[("name", target.name.as_str())],
&headers,
)
}
fn wants_json_response(headers: &HeaderMap) -> bool {
let accept = headers
.get(header::ACCEPT)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
if accept.contains("application/json") {
return true;
}
headers
.get("x-requested-with")
.and_then(|v| v.to_str().ok())
.is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
}
#[derive(Debug, Deserialize)]
pub struct RedirectForm {
pub from_path: String,
pub to_path: String,
#[serde(default)]
pub is_permanent: Option<String>,
#[serde(default)]
pub note: Option<String>,
#[serde(default)]
pub overrides_live: Option<String>,
#[serde(default)]
pub from_page_id: Option<String>,
#[serde(default)]
pub to_page_id: Option<String>,
}
impl RedirectForm {
fn parsed_permanent(&self) -> bool {
self.is_permanent.is_some()
}
fn parsed_overrides_live(&self) -> bool {
self.overrides_live.is_some()
}
fn parsed_page_id(raw: &Option<String>) -> Option<i64> {
raw.as_deref()
.and_then(|s| s.trim().parse::<i64>().ok())
.filter(|id| *id > 0)
}
fn parsed_from_page_id(&self) -> Option<i64> {
Self::parsed_page_id(&self.from_page_id)
}
fn parsed_to_page_id(&self) -> Option<i64> {
Self::parsed_page_id(&self.to_page_id)
}
}
async fn redirect_form_paths(
pool: &rustango::sql::Pool,
form: &RedirectForm,
) -> Result<(String, String), AdminError> {
let mut from = form.from_path.trim().to_owned();
let mut to = form.to_path.trim().to_owned();
if let Some(pid) = form.parsed_from_page_id() {
if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
from = p.url_path;
}
}
if let Some(pid) = form.parsed_to_page_id() {
if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
to = p.url_path;
}
}
Ok((from, to))
}
async fn redirect_is_shadowed(tenant: &Tenant, from_path: &str, overrides_live: bool) -> bool {
if overrides_live || crate::redirect::is_wildcard(from_path) {
return false;
}
matches!(
crate::resolver::resolve_path(tenant, from_path).await,
Ok(Some(_))
)
}
fn redirect_pattern_error(from_path: &str, to_path: &str) -> Option<&'static str> {
if from_path.matches('*').count() > 1 {
Some("The from-path may contain at most one “*” wildcard (e.g. /old/* or */feed).")
} else if crate::redirect::redirect_loops(from_path, to_path) {
Some("That redirect points back at its own from-path, so visitors would loop.")
} else {
None
}
}
#[derive(Debug, Deserialize, Default)]
pub struct RedirectListQuery {
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub filter: Option<String>,
#[serde(default)]
pub sort: Option<String>,
#[serde(default)]
pub dir: Option<String>,
#[serde(default)]
pub page: Option<i64>,
}
const REDIRECTS_PER_PAGE: usize = 50;
pub async fn redirect_list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Query(q): Query<RedirectListQuery>,
) -> Result<Response, AdminError> {
let mut all: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
.fetch(tenant.pool())
.await?;
let now = chrono::Utc::now();
let needle = q.q.as_deref().unwrap_or("").trim().to_lowercase();
if !needle.is_empty() {
all.retain(|r| {
r.from_path.to_lowercase().contains(&needle)
|| r.to_path.to_lowercase().contains(&needle)
|| r.note.to_lowercase().contains(&needle)
});
}
let count_all = all.len();
let count_active = all.iter().filter(|r| r.is_active).count();
let count_disabled = all.iter().filter(|r| !r.is_active).count();
let count_stale = all
.iter()
.filter(|r| matches!(crate::redirect::staleness(r, now), "stale" | "unused"))
.count();
let filter = q.filter.as_deref().unwrap_or("all");
all.retain(|r| match filter {
"active" => r.is_active,
"disabled" => !r.is_active,
"stale" => matches!(crate::redirect::staleness(r, now), "stale" | "unused"),
_ => true,
});
let sort = q.sort.as_deref().unwrap_or("from");
let desc = q.dir.as_deref() == Some("desc");
all.sort_by(|a, b| {
let o = match sort {
"last_used" => a.last_hit_at.cmp(&b.last_hit_at),
"created" => a.created_at.get().cmp(&b.created_at.get()),
"hits" => a.hit_count.cmp(&b.hit_count),
"staleness" => {
let rank = |r: &crate::redirect::Redirect| match crate::redirect::staleness(r, now)
{
"disabled" => 0u8,
"unused" => 1,
"stale" => 2,
_ => 3,
};
rank(a).cmp(&rank(b))
}
_ => a.from_path.cmp(&b.from_path),
};
if desc {
o.reverse()
} else {
o
}
});
let total = all.len();
let total_pages = total.div_ceil(REDIRECTS_PER_PAGE).max(1);
let page = q.page.unwrap_or(1).clamp(1, total_pages as i64) as usize;
let start = (page - 1) * REDIRECTS_PER_PAGE;
let items: Vec<crate::redirect::Redirect> = all
.into_iter()
.skip(start)
.take(REDIRECTS_PER_PAGE)
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("items", &items);
ctx.insert("q", &needle);
ctx.insert("filter", filter);
ctx.insert("sort", sort);
ctx.insert("dir", if desc { "desc" } else { "asc" });
ctx.insert("current_page", &page);
ctx.insert("total_pages", &total_pages);
ctx.insert("total", &total);
ctx.insert("count_all", &count_all);
ctx.insert("count_active", &count_active);
ctx.insert("count_disabled", &count_disabled);
ctx.insert("count_stale", &count_stale);
render_with_csrf(&state, &headers, "rcms_admin/redirect_list.html", &mut ctx)
}
pub async fn redirect_new_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "new");
ctx.insert(
"redirect",
&serde_json::json!({
"from_path": "",
"to_path": "",
"is_permanent": true,
"note": "",
"hit_count": 0,
"overrides_live": false,
"from_page_id": null,
"to_page_id": null,
}),
);
render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
}
pub async fn redirect_new_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<RedirectForm>,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
if from.is_empty() || to.is_empty() {
return redirect_named_with_message(
"rcms-admin:redirects:list",
MsgLevel::Error,
"From-path and to-path are both required.",
&headers,
);
}
if let Some(msg) = redirect_pattern_error(&from, &to) {
return redirect_named_with_message(
"rcms-admin:redirects:list",
MsgLevel::Error,
msg,
&headers,
);
}
let overrides_live = form.parsed_overrides_live();
let is_permanent = form.parsed_permanent();
let from_page_id = form.parsed_from_page_id();
let to_page_id = form.parsed_to_page_id();
let mut row = crate::redirect::Redirect {
id: Auto::Unset,
from_path: from,
to_path: to,
is_permanent,
note: form.note.unwrap_or_default().trim().to_owned(),
hit_count: 0,
overrides_live,
from_page_id,
to_page_id,
is_active: true,
disabled_reason: String::new(),
last_hit_at: None,
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
row.insert_pool(tenant.pool()).await?;
redirect_save_response(&tenant, &row, overrides_live, true, &headers).await
}
async fn redirect_save_response(
tenant: &Tenant,
row: &crate::redirect::Redirect,
overrides_live: bool,
is_new: bool,
headers: &HeaderMap,
) -> Result<Response, AdminError> {
let args = &[
("from", row.from_path.as_str()),
("to", row.to_path.as_str()),
];
if overrides_live && crate::redirect::is_wildcard(&row.from_path) {
let key = if is_new {
"Added redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
} else {
"Saved redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
};
return redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Warning,
key,
args,
headers,
);
}
if redirect_is_shadowed(tenant, &row.from_path, overrides_live).await {
let key = if is_new {
"Added redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
} else {
"Saved redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
};
return redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Warning,
key,
args,
headers,
);
}
let key = if is_new {
"Added redirect {from} → {to}."
} else {
"Saved redirect {from} → {to}."
};
redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Success,
key,
args,
headers,
)
}
#[derive(Debug)]
struct SnippetImportRow {
slug: String,
title: String,
body_markdown: String,
folder_path: String,
data: serde_json::Map<String, serde_json::Value>,
}
fn parse_snippet_csv(text: &str) -> Vec<SnippetImportRow> {
let delimiter = if text.contains('\t') { '\t' } else { ',' };
let mut lines = text.lines();
let header = match lines.next() {
Some(h) => h,
None => return Vec::new(),
};
let cols: Vec<String> = header
.split(delimiter)
.map(|s| s.trim().to_ascii_lowercase())
.collect();
let slug_idx = cols.iter().position(|c| c == "slug" || c == "key");
let title_idx = cols.iter().position(|c| c == "title" || c == "name");
let (Some(slug_idx), Some(title_idx)) = (slug_idx, title_idx) else {
return Vec::new();
};
let body_idx = cols
.iter()
.position(|c| c == "body_markdown" || c == "body" || c == "content");
let folder_idx = cols
.iter()
.position(|c| c == "folder_path" || c == "folder" || c == "path");
let mut out = Vec::new();
for raw in lines {
let trimmed = raw.trim();
if trimmed.is_empty() {
continue;
}
let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
let slug = parts.get(slug_idx).copied().unwrap_or("");
let title = parts.get(title_idx).copied().unwrap_or("");
if slug.is_empty() || title.is_empty() {
continue;
}
let body_markdown = body_idx
.and_then(|i| parts.get(i))
.copied()
.unwrap_or("")
.to_owned();
let folder_path = folder_idx
.and_then(|i| parts.get(i))
.copied()
.unwrap_or("")
.to_owned();
let mut data = serde_json::Map::new();
for (i, col) in cols.iter().enumerate() {
if Some(i) == Some(slug_idx)
|| Some(i) == Some(title_idx)
|| Some(i) == body_idx
|| Some(i) == folder_idx
{
continue;
}
if col.is_empty() {
continue;
}
let v = parts.get(i).copied().unwrap_or("");
if !v.is_empty() {
data.insert(col.clone(), serde_json::Value::String(v.to_owned()));
}
}
out.push(SnippetImportRow {
slug: slug.to_owned(),
title: title.to_owned(),
body_markdown,
folder_path: crate::snippet::normalize_folder(&folder_path),
data,
});
}
out
}
pub async fn snippet_import_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(type_name): Path<String>,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("type_name", &type_name);
render_with_csrf(&state, &headers, "rcms_admin/snippet_import.html", &mut ctx)
}
pub async fn snippet_import_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(type_name): Path<String>,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let mut bytes: Vec<u8> = Vec::new();
let mut filename = String::new();
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
if field.name().unwrap_or("") == "file" {
if let Some(name) = field.file_name() {
filename = name.to_owned();
}
bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
.to_vec();
} else {
let _ = field.bytes().await;
}
}
if bytes.is_empty() {
return redirect_named_with_message(
"rcms-admin:library:list",
MsgLevel::Error,
"No file uploaded.",
&headers,
);
}
let text = String::from_utf8_lossy(&bytes);
let rows = parse_snippet_csv(&text);
let total = rows.len();
if total == 0 {
return redirect_named_with_message(
"rcms-admin:library:list",
MsgLevel::Error,
"Imported 0 snippets — CSV must have a header row with `slug` + `title` columns.",
&headers,
);
}
let mut inserted = 0usize;
let mut skipped = 0usize;
let _ = filename; for row in rows {
let mut snippet = crate::snippet::Snippet {
id: Auto::Unset,
type_name: type_name.clone(),
folder_path: row.folder_path,
slug: row.slug,
title: row.title,
body_markdown: row.body_markdown,
data: serde_json::Value::Object(row.data),
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
match snippet.insert_pool(tenant.pool()).await {
Ok(_) => inserted += 1,
Err(_) => skipped += 1,
}
}
let inserted_str = inserted.to_string();
let total_str = total.to_string();
let skipped_str = skipped.to_string();
redirect_named_with_message_args(
"rcms-admin:library:list",
MsgLevel::Success,
"Imported {inserted}/{total} snippets ({skipped} skipped — likely duplicate slugs).",
&[
("inserted", inserted_str.as_str()),
("total", total_str.as_str()),
("skipped", skipped_str.as_str()),
],
&headers,
)
}
pub async fn redirect_import_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
render_with_csrf(
&state,
&headers,
"rcms_admin/redirect_import.html",
&mut ctx,
)
}
#[derive(Debug)]
struct RedirectImportRow {
from_path: String,
to_path: String,
is_permanent: bool,
}
fn parse_redirect_csv(text: &str) -> Vec<RedirectImportRow> {
let delimiter = if text.contains('\t') { '\t' } else { ',' };
let mut out = Vec::new();
for (lineno, raw) in text.lines().enumerate() {
let trimmed = raw.trim();
if trimmed.is_empty() {
continue;
}
let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
if lineno == 0 {
let h0 = parts.first().copied().unwrap_or("").to_ascii_lowercase();
if h0 == "from_path" || h0 == "from" || h0 == "old" || h0 == "source" {
continue;
}
}
if parts.len() < 2 {
continue;
}
let from = parts[0];
let to = parts[1];
if from.is_empty() || to.is_empty() {
continue;
}
let is_permanent = parts
.get(2)
.map(|s| {
let v = s.to_ascii_lowercase();
!matches!(v.as_str(), "false" | "0" | "302" | "no")
})
.unwrap_or(true);
out.push(RedirectImportRow {
from_path: from.to_owned(),
to_path: to.to_owned(),
is_permanent,
});
}
out
}
fn redirects_csv(items: &[crate::redirect::Redirect]) -> String {
let mut out = String::from("from_path,to_path,is_permanent\n");
for r in items {
out.push_str(&csv_escape(&r.from_path));
out.push(',');
out.push_str(&csv_escape(&r.to_path));
out.push(',');
out.push_str(if r.is_permanent { "301" } else { "302" });
out.push('\n');
}
out
}
pub async fn redirect_export_csv(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let items: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
.order_by(&[("from_path", false)])
.fetch(tenant.pool())
.await?;
let body = redirects_csv(&items);
let filename = format!("redirects-{}.csv", chrono::Utc::now().format("%Y%m%d"));
let mut response = ([(header::CONTENT_TYPE, "text/csv; charset=utf-8")], body).into_response();
if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
response
.headers_mut()
.insert(header::CONTENT_DISPOSITION, v);
}
Ok(response)
}
#[cfg(test)]
mod user_email_column_tests {
use super::user_email;
fn user(email: Option<&str>, data: serde_json::Value) -> rustango::tenancy::auth::User {
rustango::tenancy::auth::User {
id: rustango::sql::Auto::Set(1),
username: "u".into(),
password_hash: String::new(),
email: email.map(ToOwned::to_owned),
is_superuser: false,
active: true,
created_at: chrono::Utc::now(),
data,
password_changed_at: None,
sessions_revoked_at: None,
}
}
#[test]
fn column_first_then_legacy_data_bag() {
assert_eq!(user_email(&user(Some("a@x.example"), serde_json::json!({}))), "a@x.example");
assert_eq!(user_email(&user(None, serde_json::json!({"email": "b@x.example"}))), "b@x.example");
assert_eq!(
user_email(&user(Some("a@x.example"), serde_json::json!({"email": "old@x.example"}))),
"a@x.example"
);
assert_eq!(user_email(&user(Some(" "), serde_json::json!({}))), "");
}
}
#[cfg(test)]
mod translation_canonical_html_tests {
use super::translation_canonical_html;
#[test]
fn rich_text_is_sanitized_html_other_kinds_empty() {
let html = translation_canonical_html("richtext", "<p>A jar</p><script>x()</script>");
assert_eq!(html, "<p>A jar</p>");
assert_eq!(translation_canonical_html("richtext", " "), "");
assert_eq!(translation_canonical_html("textarea", "<p>A jar</p>"), "");
assert_eq!(translation_canonical_html("text", "Moon jar"), "");
}
}
#[cfg(test)]
mod user_email_tests {
use super::validate_optional_email;
#[test]
fn accepts_valid_and_empty() {
assert_eq!(validate_optional_email(Some("a@b.com")).unwrap(), "a@b.com");
assert_eq!(
validate_optional_email(Some(" a@b.com ")).unwrap(),
"a@b.com"
); assert_eq!(validate_optional_email(None).unwrap(), ""); assert_eq!(validate_optional_email(Some(" ")).unwrap(), ""); }
#[test]
fn rejects_malformed() {
assert!(validate_optional_email(Some("nope")).is_err()); assert!(validate_optional_email(Some("a@b@c")).is_err()); assert!(validate_optional_email(Some("@b.com")).is_err()); assert!(validate_optional_email(Some("a@")).is_err()); assert!(validate_optional_email(Some("a b@c.com")).is_err()); }
}
#[cfg(test)]
mod copy_to_locale_tests {
use super::copy_translatable_fields;
#[test]
fn selects_nonempty_canonical_fields() {
let out = copy_translatable_fields("Home", "", " Welcome ");
assert_eq!(
out,
vec![
("title", "Home".to_owned()),
("seo_description", " Welcome ".to_owned()),
]
);
}
#[test]
fn all_empty_yields_nothing_to_seed() {
assert!(copy_translatable_fields("", " ", "").is_empty());
}
}
#[cfg(test)]
mod redirect_csv_tests {
use super::*;
use rustango::sql::Auto;
fn row(from: &str, to: &str, permanent: bool) -> crate::redirect::Redirect {
crate::redirect::Redirect {
id: Auto::Unset,
from_path: from.to_owned(),
to_path: to.to_owned(),
is_permanent: permanent,
note: String::new(),
hit_count: 0,
overrides_live: false,
from_page_id: None,
to_page_id: None,
is_active: true,
disabled_reason: String::new(),
last_hit_at: None,
created_at: Auto::Unset,
updated_at: Auto::Unset,
}
}
#[test]
fn redirects_csv_header_and_301_302_mapping() {
let csv = redirects_csv(&[row("/old", "/new", true), row("/tmp", "/dst", false)]);
let mut lines = csv.lines();
assert_eq!(lines.next(), Some("from_path,to_path,is_permanent"));
assert_eq!(lines.next(), Some("/old,/new,301"));
assert_eq!(lines.next(), Some("/tmp,/dst,302"));
assert_eq!(lines.next(), None);
}
#[test]
fn redirects_csv_empty_is_header_only() {
assert_eq!(redirects_csv(&[]), "from_path,to_path,is_permanent\n");
}
}
pub async fn redirect_import_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
use rustango::sql::Auto;
let mut bytes: Vec<u8> = Vec::new();
let mut filename = String::new();
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
if field.name().unwrap_or("") == "file" {
if let Some(name) = field.file_name() {
filename = name.to_owned();
}
bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
.to_vec();
} else {
let _ = field.bytes().await;
}
}
if bytes.is_empty() {
return redirect_named_with_message(
"rcms-admin:redirects:list",
MsgLevel::Error,
"No file uploaded.",
&headers,
);
}
let text = String::from_utf8_lossy(&bytes);
let rows = parse_redirect_csv(&text);
let total = rows.len();
let mut inserted = 0usize;
let mut skipped = 0usize;
for row in rows {
if redirect_pattern_error(&row.from_path, &row.to_path).is_some() {
skipped += 1;
continue;
}
let mut redirect = crate::redirect::Redirect {
id: Auto::Unset,
from_path: row.from_path,
to_path: row.to_path,
is_permanent: row.is_permanent,
note: format!("Imported from {filename}"),
hit_count: 0,
overrides_live: false,
from_page_id: None,
to_page_id: None,
is_active: true,
disabled_reason: String::new(),
last_hit_at: None,
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
match redirect.insert_pool(tenant.pool()).await {
Ok(_) => inserted += 1,
Err(_) => skipped += 1,
}
}
let inserted_str = inserted.to_string();
let total_str = total.to_string();
let skipped_str = skipped.to_string();
redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Success,
"Imported {inserted}/{total} redirects ({skipped} skipped — likely duplicates).",
&[
("inserted", inserted_str.as_str()),
("total", total_str.as_str()),
("skipped", skipped_str.as_str()),
],
&headers,
)
}
pub async fn redirect_edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("mode", "edit");
ctx.insert("redirect", &row);
render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
}
pub async fn redirect_edit_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
Form(form): Form<RedirectForm>,
) -> Result<Response, AdminError> {
let mut row = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
if from.is_empty() || to.is_empty() {
return redirect_named_with_message(
"rcms-admin:redirects:list",
MsgLevel::Error,
"From-path and to-path are both required.",
&headers,
);
}
if let Some(msg) = redirect_pattern_error(&from, &to) {
return redirect_named_with_message(
"rcms-admin:redirects:list",
MsgLevel::Error,
msg,
&headers,
);
}
row.from_path = from;
row.to_path = to;
row.is_permanent = form.parsed_permanent();
row.overrides_live = form.parsed_overrides_live();
row.from_page_id = form.parsed_from_page_id();
row.to_page_id = form.parsed_to_page_id();
row.note = form.note.unwrap_or_default().trim().to_owned();
row.save_pool(tenant.pool()).await?;
let overrides_live = row.overrides_live;
redirect_save_response(&tenant, &row, overrides_live, false, &headers).await
}
pub async fn redirect_enable_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let mut row = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
row.is_active = true;
row.disabled_reason = String::new();
row.save_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Success,
"Re-enabled redirect {from} → {to}.",
&[
("from", row.from_path.as_str()),
("to", row.to_path.as_str()),
],
&headers,
)
}
pub async fn redirect_delete_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Path(id): Path<i64>,
) -> Result<Response, AdminError> {
let row = crate::redirect::Redirect::objects()
.where_(crate::redirect::Redirect::id.eq(id))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(id))?;
let label = format!("{} → {}", row.from_path, row.to_path);
row.delete_pool(tenant.pool()).await?;
redirect_named_with_message_args(
"rcms-admin:redirects:list",
MsgLevel::Success,
"Deleted redirect {label}.",
&[("label", label.as_str())],
&headers,
)
}
pub(crate) fn creatable_types(all: &[PageType]) -> Vec<PageType> {
all.iter()
.filter(|t| {
find_handler(&t.type_name)
.map(|h| h.is_creatable())
.unwrap_or(t.is_creatable)
})
.cloned()
.collect()
}
pub(crate) fn allowed_root_types(all: &[PageType]) -> Vec<PageType> {
creatable_types(all)
.into_iter()
.filter(|t| t.allowed_parents().is_empty())
.collect()
}
pub(crate) fn allowed_children_for(parent: &Page, all: &[PageType]) -> Vec<PageType> {
let parent_row = all
.iter()
.find(|t| t.id.get().copied() == Some(parent.page_type_id));
let parent_type_name = parent_row.map(|t| t.type_name.clone()).unwrap_or_default();
let parent_allowed_children = parent_row.map(PageType::allowed_children).unwrap_or_default();
creatable_types(all)
.into_iter()
.filter(|cand| {
if !parent_allowed_children.is_empty()
&& !parent_allowed_children.iter().any(|t| t == &cand.type_name)
{
return false;
}
let allowed_parents = cand.allowed_parents();
allowed_parents.is_empty() || allowed_parents.iter().any(|p| *p == parent_type_name)
})
.collect()
}
fn empty_page_form_values() -> serde_json::Value {
serde_json::json!({
"title": "",
"slug": "",
"page_type_id": 0,
"status": "draft",
"seo_title": "",
"seo_description": "",
"robots_index": true,
"sitemap_priority": 0.5,
"show_in_menus": true,
"go_live_at": serde_json::Value::Null,
"expire_at": serde_json::Value::Null,
"og_title": "",
"og_description": "",
"og_image_media_id": serde_json::Value::Null,
"twitter_card": "summary_large_image",
})
}
pub async fn cms_logout_submit(
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
tenant: Result<Tenant, rustango::extractors::TenantRejection>,
request: crate::security_log::LoginRequest,
) -> Response {
if let (Some(user), Ok(tenant)) = (session_user, tenant) {
let entry = SecurityEntry::new(crate::security_log::EVENT_LOGOUT, "admin", &request.meta)
.user(user.id.get().copied(), &user.username);
crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
}
let mut resp = Redirect::to("/login").into_response();
let cookies = [
"rustango_admin_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
"rustango_tenant_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
"rustango_op_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
];
for c in cookies {
if let Ok(v) = HeaderValue::from_str(c) {
resp.headers_mut().append(header::SET_COOKIE, v);
}
}
resp
}
pub async fn no_access_page(
State(state): State<super::AdminState>,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
ctx.insert("admin_title", &"CMS Admin");
render_with_csrf(&state, &headers, "rcms_admin/no_access.html", &mut ctx)
}
pub async fn dismissible_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Path(key): Path<String>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let viewer_id = viewer.id.get().copied().unwrap_or_default();
crate::dismissible::dismiss(tenant.pool(), viewer_id, &key).await?;
Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
}
pub async fn dashboard(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let pool = tenant.pool();
let viewer_id = session_user.as_ref().and_then(|u| u.id.get().copied());
let all_pages: Vec<Page> = Page::objects().fetch(pool).await.unwrap_or_default();
let mut count_drafts = 0usize;
let mut count_published = 0usize;
let mut count_scheduled = 0usize;
let mut count_archived = 0usize;
for p in &all_pages {
match p.status.as_str() {
"draft" => count_drafts += 1,
"published" => count_published += 1,
"scheduled" => count_scheduled += 1,
"archived" => count_archived += 1,
_ => {}
}
}
let snippet_count: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.fetch(pool)
.await
.unwrap_or_default();
let media_rows: Vec<Media> = Media::objects().fetch(pool).await.unwrap_or_default();
let media_images = media_rows.iter().filter(|m| m.kind == "image").count();
let media_docs = media_rows.len() - media_images;
let revs: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
.order_by(&[("created_at", true)]) .limit(10)
.fetch(pool)
.await
.unwrap_or_default();
let user_ids: std::collections::BTreeSet<i64> = revs.iter().filter_map(|r| r.created_by).collect();
let usernames: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
std::collections::HashMap::new()
} else {
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.is_in(user_ids.into_iter()))
.fetch(pool)
.await
.unwrap_or_default()
.into_iter()
.filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
.collect()
};
let page_by_id: std::collections::HashMap<i64, &Page> = all_pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let recent_edits: Vec<serde_json::Value> = revs
.iter()
.filter_map(|r| {
let p = page_by_id.get(&r.page_id)?;
Some(serde_json::json!({
"page_id": r.page_id,
"title": p.title,
"url_path": p.url_path,
"sequence": r.sequence,
"created_at": r.created_at.get().copied(),
"created_by": r.created_by.and_then(|id| usernames.get(&id).cloned()),
}))
})
.collect();
let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
.fetch(pool)
.await
.unwrap_or_default();
let now = chrono::Utc::now();
let mine_locked: Vec<serde_json::Value> = locks
.iter()
.filter(|l| !l.is_stale(now))
.filter(|l| Some(l.user_id) == viewer_id)
.filter_map(|l| {
let p = page_by_id.get(&l.page_id)?;
Some(serde_json::json!({
"page_id": l.page_id,
"title": p.title,
"url_path": p.url_path,
"acquired_at": l.acquired_at.get().copied(),
}))
})
.collect();
let mut review_rows: Vec<serde_json::Value> = Vec::new();
if let Some(viewer) = session_user.as_ref() {
let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
.where_(crate::workflow::WorkflowState::status.eq(crate::workflow::WorkflowStatus::InProgress.as_str().to_owned()))
.fetch(pool)
.await
.unwrap_or_default();
if !states.is_empty() {
let my_roles: std::collections::BTreeSet<i64> = rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::user_id.eq(viewer_id.unwrap_or_default()))
.fetch(pool)
.await
.unwrap_or_default()
.into_iter()
.map(|m| m.role_id)
.collect();
let task_ids: Vec<i64> = states.iter().filter_map(|st| st.current_task_id).collect();
let tasks: std::collections::HashMap<i64, crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
.where_(crate::workflow::WorkflowTask::id.is_in(task_ids.into_iter()))
.fetch(pool)
.await
.unwrap_or_default()
.into_iter()
.filter_map(|t| t.id.get().copied().map(|id| (id, t)))
.collect();
for st in &states {
let Some(task) = st.current_task_id.and_then(|id| tasks.get(&id)) else { continue };
if !viewer.is_superuser && !my_roles.contains(&task.role_id) {
continue;
}
let Some(p) = page_by_id.get(&st.page_id) else { continue };
review_rows.push(serde_json::json!({
"page_id": st.page_id,
"title": p.title,
"url_path": p.url_path,
"step": task.name,
"requested_at": st.requested_at.get().copied(),
}));
}
}
}
let mut scheduled: Vec<&Page> = all_pages
.iter()
.filter(|p| {
p.status == "scheduled" && p.go_live_at.is_some() && p.go_live_at.unwrap() > now
})
.collect();
scheduled.sort_by_key(|p| p.go_live_at);
scheduled.truncate(5);
let scheduled_rows: Vec<serde_json::Value> = scheduled
.into_iter()
.map(|p| {
serde_json::json!({
"page_id": p.id.get().copied().unwrap_or_default(),
"title": p.title,
"url_path": p.url_path,
"go_live_at": p.go_live_at,
})
})
.collect();
let plugin_widgets: Vec<serde_json::Value> = crate::hooks::dashboard_widgets()
.into_iter()
.map(|w| {
serde_json::json!({
"key": w.key,
"label": w.label,
"icon": w.icon,
"html": w.html,
})
})
.collect();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "dashboard", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("review_rows", &review_rows);
ctx.insert("count_drafts", &count_drafts);
ctx.insert("count_published", &count_published);
ctx.insert("count_scheduled", &count_scheduled);
ctx.insert("count_archived", &count_archived);
ctx.insert("count_snippets", &snippet_count.len());
ctx.insert("count_images", &media_images);
ctx.insert("count_documents", &media_docs);
ctx.insert("recent_edits", &recent_edits);
ctx.insert("mine_locked", &mine_locked);
ctx.insert("scheduled_rows", &scheduled_rows);
ctx.insert("plugin_widgets", &plugin_widgets);
render_with_csrf(&state, &headers, "rcms_admin/dashboard.html", &mut ctx)
}
pub async fn styleguide(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "styleguide", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
let blocks: Vec<serde_json::Value> = crate::block::registered_blocks()
.map(|b| {
serde_json::json!({
"type_name": b.type_name(),
"verbose_name": b.verbose_name(),
"icon": b.icon(),
"group": b.group(),
"field_count": b.fields().len(),
})
})
.collect();
ctx.insert("blocks", &blocks);
let page_types: Vec<serde_json::Value> = crate::page_type::registered_handlers()
.map(|h| {
serde_json::json!({
"type_name": h.type_name(),
"verbose_name": h.verbose_name(),
"icon": h.icon(),
"description": h.description(),
})
})
.collect();
ctx.insert("page_types", &page_types);
let library_types: Vec<serde_json::Value> = crate::library::registered_handlers()
.map(|h| {
serde_json::json!({
"type_name": h.type_name(),
"verbose_name": h.verbose_name(),
})
})
.collect();
ctx.insert("library_types", &library_types);
render_with_csrf(&state, &headers, "rcms_admin/styleguide.html", &mut ctx)
}
pub async fn account_preferences(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
render_account_page(&state, &tenant, &headers, session_user.as_ref(), None).await
}
async fn mcp_keys_ctx(
pool: &rustango::sql::Pool,
owner_id: i64,
) -> (Vec<serde_json::Value>, Vec<serde_json::Value>) {
use rustango::tenancy::{AgentGrant, AgentSkill};
let keys = rustango::tenancy::list_user_keys_pool(pool, owner_id)
.await
.unwrap_or_default();
let skills: Vec<AgentSkill> = rustango::tenancy::list_skills_pool(pool)
.await
.unwrap_or_default();
let skill_name = |sid: i64| -> Option<String> {
skills
.iter()
.find(|s| s.id.get().copied() == Some(sid))
.map(|s| s.codename.clone())
};
let mut rows = Vec::with_capacity(keys.len());
for key in &keys {
let key_id = key.id.get().copied().unwrap_or_default();
let grants: Vec<AgentGrant> = AgentGrant::objects()
.where_(AgentGrant::agent_id.eq(key_id))
.fetch(pool)
.await
.unwrap_or_default();
let scope: Vec<String> = grants
.iter()
.filter_map(|g| skill_name(g.skill_id))
.collect();
rows.push(serde_json::json!({
"id": key_id,
"label": key.data.get("label").and_then(|v| v.as_str()).unwrap_or(&key.name),
"prefix": key.secret_prefix,
"active": key.active,
"created_at": key.created_at.get().map(|t| t.format("%Y-%m-%d %H:%M").to_string()),
"scope": scope,
}));
}
let skill_rows: Vec<serde_json::Value> = skills
.iter()
.map(|s| {
serde_json::json!({
"codename": s.codename,
"name": s.name,
"description": s.description,
})
})
.collect();
(rows, skill_rows)
}
async fn render_account_page(
state: &super::AdminState,
tenant: &Tenant,
headers: &HeaderMap,
session_user: Option<&rustango::tenancy::auth::User>,
mcp_one_time: Option<serde_json::Value>,
) -> Result<Response, AdminError> {
let (current_email, pending_email, mailer_wired) = {
let mailer = state.mailer.is_some();
let user_data = session_user
.map(|u| u.data.clone())
.unwrap_or_else(|| serde_json::json!({}));
let cur = session_user.map(user_email).unwrap_or_default();
let pending = user_data
.get("pending_email")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_owned();
(cur, pending, mailer)
};
let mut ctx = Context::new();
add_chrome(&mut ctx, tenant, "", session_user).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
.order_by(&[("name", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
let theme_rows: Vec<serde_json::Value> = themes
.iter()
.map(|t| {
serde_json::json!({
"id": t.id.get().copied(),
"name": t.name,
"slug": t.slug,
"is_admin_default": t.is_admin_default,
"color_bg": t.color_bg,
"color_surface": t.color_surface,
"color_text_primary": t.color_text_primary,
"color_link": t.color_link,
})
})
.collect();
ctx.insert("themes", &theme_rows);
let account_panels: Vec<serde_json::Value> = crate::hooks::account_settings_panels()
.into_iter()
.map(|p| {
serde_json::json!({
"key": p.key,
"label": p.label,
"icon": p.icon,
"html": p.html,
})
})
.collect();
ctx.insert("account_panels", &account_panels);
let pref_map = session_user
.and_then(|u| u.id.get().copied())
.map(|uid| crate::notification_pref::map_for_user(tenant.pool(), uid))
.map(|fut| async move { fut.await.unwrap_or_default() });
let pref_lookup: std::collections::HashMap<String, bool> = match pref_map {
Some(f) => f.await,
None => std::collections::HashMap::new(),
};
let notification_rows: Vec<serde_json::Value> = crate::notification_pref::ALL_KINDS
.iter()
.map(|(label, kind, hint)| {
let enabled = pref_lookup.get(*kind).copied().unwrap_or(true);
serde_json::json!({
"label": label,
"kind": kind,
"hint": hint,
"enabled": enabled,
})
})
.collect();
ctx.insert("notification_prefs", ¬ification_rows);
ctx.insert("account_email", ¤t_email);
ctx.insert("account_pending_email", &pending_email);
ctx.insert("account_mailer_wired", &mailer_wired);
if let Some(uid) = session_user.and_then(|u| u.id.get().copied()) {
let (keys, skills) = mcp_keys_ctx(tenant.pool(), uid).await;
ctx.insert("mcp_keys", &keys);
ctx.insert("mcp_skills", &skills);
}
if let Some(one_time) = &mcp_one_time {
ctx.insert("mcp_one_time", one_time);
}
render_with_csrf(
state,
headers,
"rcms_admin/account_preferences.html",
&mut ctx,
)
}
pub async fn account_notifications_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
for (_label, kind, _hint) in crate::notification_pref::ALL_KINDS {
let key = format!("kind_{kind}");
let enabled = form
.get(&key)
.map(|v| matches!(v.as_str(), "on" | "true" | "1" | "yes"))
.unwrap_or(false);
crate::notification_pref::set_enabled(tenant.pool(), uid, kind, enabled).await?;
}
redirect_named_with_params_and_message(
"rcms-admin:account",
&[],
MsgLevel::Success,
"Notification preferences saved.",
&headers,
)
}
pub async fn account_profile_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
mut multipart: axum::extract::Multipart,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
let mut new_display_name: Option<String> = None;
let mut new_avatar_path: Option<String> = None;
let avatar_dir = std::path::PathBuf::from("./var/avatars").join(&tenant.org.slug);
while let Some(field) = multipart
.next_field()
.await
.map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
{
let field_name = field.name().unwrap_or("").to_owned();
match field_name.as_str() {
"display_name" => {
new_display_name = Some(
field
.text()
.await
.map_err(|e| AdminError::Upload(format!("read display_name: {e}")))?
.trim()
.to_owned(),
);
}
"avatar" => {
let original = field.file_name().map(|s| s.to_owned());
let bytes = field
.bytes()
.await
.map_err(|e| AdminError::Upload(format!("read avatar: {e}")))?;
if bytes.is_empty() {
continue;
}
let ext = original
.as_deref()
.and_then(|n| n.rsplit_once('.'))
.map(|(_, ext)| ext)
.filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
.map(str::to_ascii_lowercase)
.unwrap_or_else(|| "png".to_owned());
std::fs::create_dir_all(&avatar_dir)
.map_err(|e| AdminError::Upload(format!("create avatar dir: {e}")))?;
let storage_name = format!("{uid}.{ext}");
let path = avatar_dir.join(&storage_name);
std::fs::write(&path, &bytes)
.map_err(|e| AdminError::Upload(format!("write avatar: {e}")))?;
new_avatar_path = Some(storage_name);
}
_ => {
let _ = field.bytes().await;
}
}
}
let mut user_rows: Vec<rustango::tenancy::auth::User> =
rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.fetch(tenant.pool())
.await?;
let Some(mut user) = user_rows.pop() else {
return Ok((axum::http::StatusCode::NOT_FOUND, "user not found").into_response());
};
let mut data = user.data.as_object().cloned().unwrap_or_default();
if let Some(name) = new_display_name {
if name.is_empty() {
data.remove("display_name");
} else {
data.insert("display_name".to_owned(), serde_json::json!(name));
}
}
if let Some(path) = new_avatar_path {
data.insert("avatar_path".to_owned(), serde_json::json!(path));
}
user.data = serde_json::Value::Object(data);
user.save_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Success,
"Profile saved.",
&headers,
)
}
async fn persist_user_admin_lang(
pool: &rustango::sql::Pool,
uid: i64,
lang: &str,
) -> Result<(), AdminError> {
let mut rows: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.fetch(pool)
.await?;
if let Some(mut user) = rows.pop() {
let mut data = user.data.as_object().cloned().unwrap_or_default();
data.insert("admin_lang".to_owned(), serde_json::json!(lang));
user.data = serde_json::Value::Object(data);
user.save_pool(pool).await?;
}
Ok(())
}
#[derive(Debug, Deserialize)]
pub struct AccountLanguageForm {
pub lang: String,
}
pub async fn account_language_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<AccountLanguageForm>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
let lang = if super::i18n::is_ui_locale(&form.lang) {
form.lang.clone()
} else {
"en".to_owned()
};
persist_user_admin_lang(tenant.pool(), uid, &lang).await?;
let mut resp = redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Success,
"Language updated.",
&headers,
)?;
let cookie = format!(
"{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
super::i18n::ADMIN_LANG_COOKIE
);
if let Ok(v) = HeaderValue::from_str(&cookie) {
resp.headers_mut().append(header::SET_COOKIE, v);
}
Ok(resp)
}
#[derive(Debug, Deserialize)]
pub struct AccountEmailForm {
pub new_email: String,
}
pub async fn account_email_submit(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<AccountEmailForm>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
let new_email = form.new_email.trim().to_owned();
if new_email.is_empty() || !new_email.contains('@') {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"Enter a valid email address.",
&headers,
);
}
let mut user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(uid))?;
let mut data = user.data.as_object().cloned().unwrap_or_default();
if state.mailer.is_none() {
data.insert("email".to_owned(), serde_json::json!(new_email));
user.email = Some(new_email.clone());
data.remove("pending_email");
user.data = serde_json::Value::Object(data);
user.save_pool(tenant.pool()).await?;
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Warning,
"Email updated. No confirmation email was sent — the host hasn't wired a mailer.",
&headers,
);
}
data.insert(
"pending_email".to_owned(),
serde_json::json!(new_email.clone()),
);
data.remove("pending_email_token");
data.remove("pending_email_expires_at");
user.data = serde_json::Value::Object(data);
user.save_pool(tenant.pool()).await?;
if let Some(mailer) = state.mailer.as_deref() {
let link = rustango::auth_flows::EmailVerification::issue(
&rustango::auth_flows::LinkScope::from(&tenant),
"/cms-admin/me/email/confirm",
uid,
&new_email,
state.signing_secret.as_slice(),
std::time::Duration::from_secs(3600),
);
let subject = "Confirm your CMS email change";
let body = format!(
"Click the link below to confirm your CMS email change to {new_email}.\n\nLink: {link}\n\nThe link expires in one hour. If you didn't request this change, ignore this email.\n",
);
let email = rustango::email::Email::new()
.from((*state.mailer_from).clone())
.to(new_email.clone())
.subject(subject.to_owned())
.body(body);
if let Err(e) = mailer.send(&email).await {
tracing::warn!(
target: "rustango_cms::admin::account",
user_id = uid, error = %e,
"email-change confirmation send failed (pending_email stashed; user can re-request)"
);
}
}
redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Success,
"Confirmation link sent to the new email. Click it within an hour to finalize the change.",
&headers,
)
}
pub async fn account_email_confirm(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
let path_and_query = uri
.path_and_query()
.map(|p| p.as_str())
.unwrap_or_default()
.to_owned();
let (token_uid, signed_email) = match rustango::auth_flows::EmailVerification::verify(
&rustango::auth_flows::LinkScope::from(&tenant),
&path_and_query,
state.signing_secret.as_slice(),
) {
Ok(pair) => pair,
Err(_) => {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"Confirmation link is invalid or has expired. Request a new one.",
&headers,
);
}
};
if token_uid != uid {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"Confirmation link belongs to a different account. Sign in as that account to confirm.",
&headers,
);
}
let mut user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(uid))?;
let mut data = user.data.as_object().cloned().unwrap_or_default();
let pending = data
.get("pending_email")
.and_then(|v| v.as_str())
.unwrap_or("");
if pending != signed_email {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"This link is for a different email change than the one currently pending. Request a fresh confirmation.",
&headers,
);
}
data.insert("email".to_owned(), serde_json::json!(signed_email));
user.email = Some(signed_email.clone());
data.remove("pending_email");
data.remove("pending_email_token");
data.remove("pending_email_expires_at");
user.data = serde_json::Value::Object(data);
user.save_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Success,
"Email confirmed. Notifications go to the new address from now on.",
&headers,
)
}
#[derive(Deserialize)]
pub struct AccountPasswordForm {
pub current_password: String,
pub new_password: String,
pub new_password_confirm: String,
}
pub async fn account_password_submit(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
Form(form): Form<AccountPasswordForm>,
) -> Result<Response, AdminError> {
let Some(viewer) = session_user.as_ref() else {
return Ok(unauthorized_no_session());
};
let Some(uid) = viewer.id.get().copied() else {
return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
};
if form.new_password.len() < 12 {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"New password must be at least 12 characters.",
&headers,
);
}
if form.new_password != form.new_password_confirm {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"New password and confirmation don't match.",
&headers,
);
}
let mut user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(uid))
.first(tenant.pool())
.await?
.ok_or(AdminError::NotFound(uid))?;
let verified =
crate::passwords::verify(&form.current_password, &user.password_hash).await.unwrap_or(false);
if !verified {
return redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Error,
"Current password is incorrect.",
&headers,
);
}
let hash = crate::passwords::hash(&form.new_password).await
.map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
user.password_hash = hash;
user.password_changed_at = Some(chrono::Utc::now());
user.save_pool(tenant.pool()).await?;
redirect_named_with_message(
"rcms-admin:account",
MsgLevel::Success,
"Password changed. Old sessions on other devices will be signed out on next request.",
&headers,
)
}
pub async fn account_avatar_serve(
headers: HeaderMap,
tenant: Tenant,
Path(user_id): Path<i64>,
) -> Response {
let user_rows: Vec<rustango::tenancy::auth::User> =
match rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(user_id))
.fetch(tenant.pool())
.await
{
Ok(v) => v,
Err(_) => {
return (
axum::http::StatusCode::INTERNAL_SERVER_ERROR,
"user lookup failed",
)
.into_response();
}
};
let Some(user) = user_rows.into_iter().next() else {
return (axum::http::StatusCode::NOT_FOUND, "user not found").into_response();
};
let storage_name = match user.data.get("avatar_path").and_then(|v| v.as_str()) {
Some(s) if !s.is_empty() => s.to_owned(),
_ => return (axum::http::StatusCode::NOT_FOUND, "no avatar").into_response(),
};
if storage_name.contains('/') || storage_name.contains("..") {
return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
}
let path = std::path::PathBuf::from("./var/avatars")
.join(&tenant.org.slug)
.join(&storage_name);
let bytes = match std::fs::read(&path) {
Ok(b) => b,
Err(_) => {
return (axum::http::StatusCode::NOT_FOUND, "avatar bytes missing").into_response()
}
};
let mime = mime_guess::from_path(&storage_name)
.first_or_octet_stream()
.essence_str()
.to_owned();
revalidated_asset(&headers, mime, bytes)
}
pub async fn cms_login_form(
State(state): State<super::AdminState>,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
tenant: Tenant,
Query(q): Query<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
ctx.insert("action", &"/login");
ctx.insert("admin_title", &"CMS Admin");
let next = q
.get("next")
.map(String::as_str)
.filter(|s| !s.is_empty())
.unwrap_or("/cms-admin/");
ctx.insert("next", next);
if let Some(err) = q.get("error") {
ctx.insert("error", err);
}
let sso_providers = rustango::admin::sso_provider::list_enabled(tenant.pool(), "/login").await;
ctx.insert("sso_enabled", &!sso_providers.is_empty());
ctx.insert("sso_providers", &sso_providers);
if let Some(err) = q.get("sso_error") {
ctx.insert("sso_error", err);
}
add_branding_urls(&mut ctx, &tenant).await;
render_with_csrf(&state, &headers, "login.html", &mut ctx)
}
pub async fn password_reset_request_form(
State(state): State<super::AdminState>,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
) -> Result<Response, AdminError> {
let mut ctx = Context::new();
render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_request.html",
&mut ctx,
)
}
fn password_reset_scope(tenant_slug: &str) -> rustango::auth_flows::LinkScope {
rustango::auth_flows::LinkScope::audience(&format!("rcms-reset:{tenant_slug}"))
}
fn password_reset_key(secret: &[u8], tenant_slug: &str, password_hash: &str) -> Vec<u8> {
let msg = format!("rcms-password-reset\0{tenant_slug}\0{password_hash}");
crate::signing::hmac_sha256_hex(secret, msg.as_bytes()).into_bytes()
}
fn password_reset_url(
secret: &[u8],
tenant_slug: &str,
user: &rustango::tenancy::auth::User,
) -> String {
let key = password_reset_key(secret, tenant_slug, &user.password_hash);
rustango::auth_flows::PasswordReset::issue(
&password_reset_scope(tenant_slug),
"/cms-admin/password-reset/confirm",
user.id.get().copied().unwrap_or(0),
&key,
std::time::Duration::from_secs(3600),
)
}
pub async fn issue_password_reset_link(
pool: &rustango::sql::Pool,
tenant_slug: &str,
username: &str,
) -> Result<Option<String>, rustango::sql::ExecError> {
let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::username.eq(username.to_owned()))
.where_(rustango::tenancy::auth::User::active.eq(true))
.fetch(pool)
.await?
.into_iter()
.next();
let secret = crate::signing::derived_key(super::PASSWORD_RESET_KEY_PURPOSE);
Ok(user.map(|u| password_reset_url(&secret, tenant_slug, &u)))
}
async fn password_reset_user(
tenant: &Tenant,
secret: &[u8],
signed_url: &str,
) -> Option<rustango::tenancy::auth::User> {
let claimed: i64 = signed_url
.split_once('?')?
.1
.split('&')
.find_map(|kv| kv.strip_prefix("user_id="))?
.parse()
.ok()?;
let user = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::id.eq(claimed))
.where_(rustango::tenancy::auth::User::active.eq(true))
.first(tenant.pool())
.await
.ok()??;
let key = password_reset_key(secret, &tenant.org.slug, &user.password_hash);
match rustango::auth_flows::PasswordReset::verify(
&password_reset_scope(&tenant.org.slug),
signed_url,
&key,
) {
Ok(uid) if uid == claimed => Some(user),
_ => None,
}
}
pub async fn password_reset_request_submit(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let username = form.get("username").cloned().unwrap_or_default();
if !username.trim().is_empty() {
let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
.where_(rustango::tenancy::auth::User::username.eq(username.clone()))
.where_(rustango::tenancy::auth::User::active.eq(true))
.fetch(tenant.pool())
.await
.unwrap_or_default()
.into_iter()
.next();
if let Some(u) = user {
let entry = SecurityEntry::new(
crate::security_log::EVENT_PASSWORD_RESET_REQUESTED,
"admin",
&request.meta,
)
.user(u.id.get().copied(), &u.username);
crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
let token_url =
password_reset_url(state.signing_secret.as_slice(), &tenant.org.slug, &u);
let to_email = Some(user_email(&u)).filter(|e| !e.is_empty());
match (to_email, state.mailer.is_some()) {
(Some(to), _) => {
send_reset_email(
state.mailer.as_deref(),
&state.mailer_from,
&to,
&u.username,
&token_url,
)
.await;
}
(None, false) => {
println!(
"============= password reset =============\n\
{} has no email on file. Reset link, valid for an hour \
(prefix the site's address):\n{token_url}\n\
==========================================",
u.username
);
tracing::warn!(
username = %u.username,
"password reset for an account with no email: link printed to stdout"
);
}
(None, true) => {
tracing::warn!(
username = %u.username,
"password reset requested but the account has no email on file; nothing \
sent. Add an email to the account, or issue a link with \
rustango_cms::admin::issue_password_reset_link"
);
}
}
}
}
let mut ctx = Context::new();
ctx.insert("console_mail", &state.mailer.is_none());
render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_sent.html",
&mut ctx,
)
}
pub async fn password_reset_confirm_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
) -> Result<Response, AdminError> {
let path_and_query = uri
.path_and_query()
.map(|p| p.as_str())
.unwrap_or_default()
.to_owned();
let mut ctx = Context::new();
match password_reset_user(&tenant, state.signing_secret.as_slice(), &path_and_query).await {
Some(_) => {
ctx.insert("signed_token", &path_and_query);
render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_confirm.html",
&mut ctx,
)
}
None => {
ctx.insert(
"error",
&"This reset link is invalid or has expired. Request a fresh one.",
);
render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_request.html",
&mut ctx,
)
}
}
}
pub async fn password_reset_confirm_submit(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: HeaderMap,
request: crate::security_log::LoginRequest,
rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
Form(form): Form<std::collections::HashMap<String, String>>,
) -> Result<Response, AdminError> {
let token = form.get("token").cloned().unwrap_or_default();
let password = form.get("password").cloned().unwrap_or_default();
let password_confirm = form.get("password_confirm").cloned().unwrap_or_default();
let mut ctx = Context::new();
let render_confirm_with_error = |state: &super::AdminState,
headers: &HeaderMap,
token: &str,
msg: &str|
-> Result<Response, AdminError> {
let mut c = Context::new();
c.insert("signed_token", &token);
c.insert("error", &msg);
render_with_csrf(
state,
headers,
"rcms_admin/password_reset_confirm.html",
&mut c,
)
};
if password.len() < 12 {
return render_confirm_with_error(
&state,
&headers,
&token,
"Password must be at least 12 characters.",
);
}
if password != password_confirm {
return render_confirm_with_error(
&state,
&headers,
&token,
"Password confirmation didn't match.",
);
}
let Some(mut user) = password_reset_user(&tenant, state.signing_secret.as_slice(), &token).await
else {
ctx.insert(
"error",
&"This reset link is invalid or has expired. Request a fresh one.",
);
return render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_request.html",
&mut ctx,
);
};
let new_hash = match crate::passwords::hash(&password).await {
Ok(h) => h,
Err(e) => {
tracing::warn!(error = %e, "password hash failed");
return render_confirm_with_error(
&state,
&headers,
&token,
"Could not save the new password. Try again.",
);
}
};
user.password_hash = new_hash;
if user.save_pool(tenant.pool()).await.is_err() {
return render_confirm_with_error(
&state,
&headers,
&token,
"Could not save the new password. Try again.",
);
}
crate::security_log::unlock(&tenant.org.slug, &user.username).await;
let entry = SecurityEntry::new(crate::security_log::EVENT_PASSWORD_RESET, "admin", &request.meta)
.user(user.id.get().copied(), &user.username);
crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
render_with_csrf(
&state,
&headers,
"rcms_admin/password_reset_done.html",
&mut ctx,
)
}
async fn send_reset_email(
mailer: Option<&dyn rustango::email::Mailer>,
mailer_from: &str,
to_email: &str,
username: &str,
reset_url: &str,
) {
let from = if mailer_from.trim().is_empty() {
"noreply@cms.local"
} else {
mailer_from
};
let email = rustango::email::Email::new()
.to(to_email)
.from(from)
.subject("Reset your CMS password")
.body(format!(
"Hi {username},\n\n\
We received a request to reset your CMS password.\n\
Click the link below within the next hour to set a new one:\n\n\
{reset_url}\n\n\
If you didn't request this, you can safely ignore this email.\n"
));
let result = match mailer {
Some(m) => m.send(&email).await,
None => {
let console = rustango::email::ConsoleMailer;
<rustango::email::ConsoleMailer as rustango::email::Mailer>::send(&console, &email)
.await
}
};
if let Err(e) = result {
tracing::warn!(error = %e, username = %username, "password-reset mail send failed");
}
tracing::info!(username = %username, "issued password-reset link");
}
#[cfg(test)]
mod tests {
use super::*;
fn reset_user(password_hash: &str) -> rustango::tenancy::auth::User {
rustango::tenancy::auth::User {
id: rustango::sql::Auto::Set(7),
username: "admin".to_owned(),
password_hash: password_hash.to_owned(),
email: None,
is_superuser: true,
active: true,
created_at: chrono::Utc::now(),
data: serde_json::json!({}),
password_changed_at: None,
sessions_revoked_at: None,
}
}
#[test]
fn a_reset_link_verifies_until_the_password_changes() {
let secret = b"test-secret";
let url = password_reset_url(secret, "blog", &reset_user("hash-1"));
assert!(url.starts_with("/cms-admin/password-reset/confirm?user_id=7&"), "{url}");
let key = password_reset_key(secret, "blog", "hash-1");
let blog = password_reset_scope("blog");
assert_eq!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &key).ok(), Some(7));
let after_change = password_reset_key(secret, "blog", "hash-2");
assert!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &after_change).is_err());
let other_tenant = password_reset_key(secret, "shop", "hash-1");
let shop = password_reset_scope("shop");
assert!(rustango::auth_flows::PasswordReset::verify(&shop, &url, &other_tenant).is_err());
}
#[test]
fn parse_matrix_form_translates_brackets_to_codenames() {
let mut form = std::collections::HashMap::new();
form.insert("name".to_owned(), "Editor".to_owned());
form.insert("perm[pages][view]".to_owned(), "1".to_owned());
form.insert("perm[pages][add]".to_owned(), "1".to_owned());
form.insert("perm[pages][edit]".to_owned(), "1".to_owned());
form.insert("perm[history][view]".to_owned(), "1".to_owned());
form.insert("perm[history][edit]".to_owned(), "1".to_owned());
form.insert("perm[redirects][delete]".to_owned(), "0".to_owned());
form.insert("perm[bogus][view]".to_owned(), "1".to_owned());
form.insert("perm[pages]".to_owned(), "1".to_owned());
let codenames = parse_matrix_form(&form);
assert!(codenames.contains(&"cms_page.view".to_owned()));
assert!(codenames.contains(&"cms_page.add".to_owned()));
assert!(codenames.contains(&"cms_page.edit".to_owned()));
assert!(codenames.contains(&"cms_history.view".to_owned()));
assert!(!codenames.contains(&"cms_history.edit".to_owned()));
assert!(!codenames.contains(&"cms_redirect.delete".to_owned()));
assert!(!codenames.iter().any(|c| c.contains("bogus")));
}
#[test]
fn split_matrix_codenames_isolates_legacy() {
let granted = vec![
"cms_page.view".to_owned(),
"cms_page.edit".to_owned(),
"rustango_roles.view".to_owned(),
"acme_custom.do_thing".to_owned(),
"free_form_string".to_owned(),
];
let (matched, legacy) = split_matrix_codenames(&granted);
assert!(matched.contains(&"cms_page.view".to_owned()));
assert!(matched.contains(&"cms_page.edit".to_owned()));
assert!(matched.contains(&"rustango_roles.view".to_owned()));
assert!(legacy.contains(&"acme_custom.do_thing".to_owned()));
assert!(legacy.contains(&"free_form_string".to_owned()));
}
#[test]
fn build_permission_matrix_marks_granted_cells() {
let granted = vec![
"cms_page.view".to_owned(),
"cms_page.add".to_owned(),
"cms_media.view".to_owned(),
];
let matrix = build_permission_matrix(&granted);
let arr = matrix.as_array().expect("matrix is an array of sections");
let pages_row = arr
.iter()
.flat_map(|s| s["rows"].as_array().unwrap().iter())
.find(|r| r["key"] == "pages")
.expect("pages row present");
let granted_actions: Vec<&str> = pages_row["granted"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap())
.collect();
assert!(granted_actions.contains(&"view"));
assert!(granted_actions.contains(&"add"));
assert!(!granted_actions.contains(&"edit"));
assert!(!granted_actions.contains(&"delete"));
}
#[test]
fn round_trip_form_to_codenames_to_matrix() {
let mut form = std::collections::HashMap::new();
form.insert("perm[pages][view]".to_owned(), "1".to_owned());
form.insert("perm[pages][publish]".to_owned(), "1".to_owned());
form.insert("perm[media][view]".to_owned(), "1".to_owned());
let codenames = parse_matrix_form(&form);
let matrix = build_permission_matrix(&codenames);
let pages = matrix
.as_array()
.unwrap()
.iter()
.flat_map(|s| s["rows"].as_array().unwrap().iter())
.find(|r| r["key"] == "pages")
.unwrap();
let granted: Vec<&str> = pages["granted"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap())
.collect();
assert_eq!(granted, vec!["view", "publish"]);
}
fn sample_spec() -> crate::page_type::InlinePanelSpec {
crate::page_type::InlinePanelSpec::new(
"team",
"Team",
vec![
crate::page_type::ExtensionField {
name: "name".to_owned(),
label: "Name".to_owned(),
kind: crate::page_type::ExtensionFieldKind::Text,
value: String::new(),
help: String::new(),
max_length: None,
},
crate::page_type::ExtensionField {
name: "role".to_owned(),
label: "Role".to_owned(),
kind: crate::page_type::ExtensionFieldKind::Text,
value: String::new(),
help: String::new(),
max_length: None,
},
],
)
}
#[test]
fn inline_extractor_groups_by_row_index() {
let spec = sample_spec();
let mut form = std::collections::HashMap::new();
form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
form.insert("inline__team__0__role".to_owned(), "Engineer".to_owned());
form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
form.insert("inline__team__1__role".to_owned(), "Designer".to_owned());
let rows = extract_inline_panel_rows(&form, &spec);
assert_eq!(rows.len(), 2);
assert_eq!(rows[0]["name"], "Ada");
assert_eq!(rows[1]["role"], "Designer");
}
#[test]
fn inline_extractor_drops_tombstoned_rows() {
let spec = sample_spec();
let mut form = std::collections::HashMap::new();
form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
form.insert("inline__team__1____deleted".to_owned(), "1".to_owned());
let rows = extract_inline_panel_rows(&form, &spec);
assert_eq!(rows.len(), 1);
assert_eq!(rows[0]["name"], "Ada");
}
#[test]
fn inline_extractor_ignores_unknown_field_names() {
let spec = sample_spec();
let mut form = std::collections::HashMap::new();
form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
form.insert("inline__team__0__bogus".to_owned(), "x".to_owned());
let rows = extract_inline_panel_rows(&form, &spec);
assert_eq!(rows.len(), 1);
assert!(!rows[0].contains_key("bogus"));
}
#[test]
fn inline_extractor_ignores_unrelated_form_keys() {
let spec = sample_spec();
let mut form = std::collections::HashMap::new();
form.insert("title".to_owned(), "irrelevant".to_owned());
form.insert("inline__other_panel__0__name".to_owned(), "x".to_owned());
let rows = extract_inline_panel_rows(&form, &spec);
assert!(rows.is_empty());
}
#[test]
fn page_form_canonical_keys_include_schedule_and_menu_fields() {
assert!(
PAGE_FORM_CANONICAL_KEYS.contains(&"go_live_at"),
"go_live_at must be in canonical keys — see #268"
);
assert!(
PAGE_FORM_CANONICAL_KEYS.contains(&"expire_at"),
"expire_at must be in canonical keys — see #268"
);
assert!(
PAGE_FORM_CANONICAL_KEYS.contains(&"show_in_menus"),
"show_in_menus must be in canonical keys — see #268"
);
}
}
#[cfg(all(test, feature = "sqlite"))]
mod media_picker_tests {
use super::{media_picker_payload, MediaPickerQuery};
use crate::media::{Media, MediaCollection};
use rustango::core::Model as _;
use rustango::sql::{Auto, FetcherPool as _, Pool};
async fn mem_pool() -> Pool {
let pool = Pool::connect("sqlite::memory:")
.await
.expect("in-memory sqlite");
for schema in [&Media::SCHEMA, &MediaCollection::SCHEMA] {
let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
pool.dialect(),
schema,
);
for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
.await
.expect("ddl");
}
}
pool
}
async fn mk_collection(pool: &Pool, name: &str, parent_id: Option<i64>, sort: i32) -> i64 {
MediaCollection {
id: Auto::Unset,
name: name.to_owned(),
parent_id,
sort_order: sort,
created_at: Auto::Unset,
}
.insert_pool(pool)
.await
.expect("collection insert");
MediaCollection::objects()
.fetch(pool)
.await
.expect("fetch")
.into_iter()
.find(|c| c.name == name)
.and_then(|c| c.id.get().copied())
.expect("collection id")
}
async fn mk_media(
pool: &Pool,
title: &str,
filename: &str,
kind: &str,
collection_id: Option<i64>,
alt: &str,
) {
Media {
id: Auto::Unset,
filename: filename.to_owned(),
content_hash: format!("{:0>64}", title.len()),
mime: if kind == "image" {
"image/png"
} else {
"application/pdf"
}
.to_owned(),
size: 123,
kind: kind.to_owned(),
width: (kind == "image").then_some(100),
height: (kind == "image").then_some(80),
storage_key: format!("k-{filename}"),
title: title.to_owned(),
alt_text: alt.to_owned(),
description: String::new(),
uploaded_by: None,
collection_id,
focal_point_x: None,
focal_point_y: None,
uploaded_at: Auto::Unset,
}
.insert_pool(pool)
.await
.expect("media insert");
}
#[tokio::test]
async fn default_kind_excludes_documents() {
let pool = mem_pool().await;
mk_media(&pool, "Photo", "p.png", "image", None, "").await;
mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
let body = media_picker_payload(&pool, &MediaPickerQuery::default())
.await
.expect("payload");
let items = body["items"].as_array().expect("items");
assert_eq!(items.len(), 1);
assert_eq!(items[0]["kind"], "image");
let q = MediaPickerQuery {
kind: Some("any".to_owned()),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 2);
}
#[tokio::test]
async fn collection_zero_means_uncategorized_only() {
let pool = mem_pool().await;
let cid = mk_collection(&pool, "Root", None, 0).await;
mk_media(&pool, "In", "in.png", "image", Some(cid), "").await;
mk_media(&pool, "Loose", "loose.png", "image", None, "").await;
let q = MediaPickerQuery {
collection: Some(0),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
let items = body["items"].as_array().expect("items");
assert_eq!(items.len(), 1);
assert_eq!(items[0]["title"], "Loose");
assert_eq!(body["uncategorized_count"], 1);
let q = MediaPickerQuery {
collection: Some(cid),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 1);
assert_eq!(body["items"][0]["title"], "In");
}
#[tokio::test]
async fn search_matches_alt_text() {
let pool = mem_pool().await;
mk_media(
&pool,
"IMG_0001",
"a.png",
"image",
None,
"sunset glow over harbour",
)
.await;
mk_media(&pool, "IMG_0002", "b.png", "image", None, "office desk").await;
let q = MediaPickerQuery {
q: Some("Sunset".to_owned()),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
let items = body["items"].as_array().expect("items");
assert_eq!(items.len(), 1);
assert_eq!(items[0]["title"], "IMG_0001");
}
#[tokio::test]
async fn pagination_math_and_has_more() {
let pool = mem_pool().await;
for i in 0..5 {
mk_media(
&pool,
&format!("M{i}"),
&format!("m{i}.png"),
"image",
None,
"",
)
.await;
}
let q = MediaPickerQuery {
limit: Some(2),
offset: Some(0),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 2);
assert_eq!(body["total"], 5);
assert_eq!(body["has_more"], true);
let q = MediaPickerQuery {
limit: Some(2),
offset: Some(4),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 1);
assert_eq!(body["has_more"], false);
let q = MediaPickerQuery {
limit: Some(2),
offset: Some(99),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 0);
}
#[tokio::test]
async fn collections_come_back_in_dfs_order_with_depth() {
let pool = mem_pool().await;
let root_a = mk_collection(&pool, "Alpha", None, 0).await;
let _sub = mk_collection(&pool, "Alpha Child", Some(root_a), 0).await;
let _root_b = mk_collection(&pool, "Beta", None, 1).await;
mk_media(&pool, "In A", "a.png", "image", Some(root_a), "").await;
let body = media_picker_payload(&pool, &MediaPickerQuery::default())
.await
.expect("payload");
let cols = body["collections"].as_array().expect("collections");
let names: Vec<&str> = cols.iter().map(|c| c["name"].as_str().unwrap()).collect();
assert_eq!(names, ["Alpha", "Alpha Child", "Beta"]);
assert_eq!(cols[0]["depth"], 0);
assert_eq!(cols[1]["depth"], 1);
assert_eq!(cols[2]["depth"], 0);
assert_eq!(cols[0]["count"], 1);
assert_eq!(cols[2]["count"], 0);
}
#[tokio::test]
async fn ids_lookup_resolves_any_kind() {
let pool = mem_pool().await;
mk_media(&pool, "Photo", "p.png", "image", None, "").await;
mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
let all = media_picker_payload(
&pool,
&MediaPickerQuery {
kind: Some("any".to_owned()),
..Default::default()
},
)
.await
.expect("payload");
let ids: Vec<i64> = all["items"]
.as_array()
.unwrap()
.iter()
.map(|i| i["id"].as_i64().unwrap())
.collect();
let q = MediaPickerQuery {
ids: Some(
ids.iter()
.map(|i| i.to_string())
.collect::<Vec<_>>()
.join(","),
),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
let items = body["items"].as_array().expect("items");
assert_eq!(
items.len(),
2,
"document resolves too when ids are explicit"
);
let q = MediaPickerQuery {
ids: Some(
ids.iter()
.map(|i| i.to_string())
.collect::<Vec<_>>()
.join(","),
),
kind: Some("image".to_owned()),
..Default::default()
};
let body = media_picker_payload(&pool, &q).await.expect("payload");
assert_eq!(body["items"].as_array().expect("items").len(), 1);
}
#[tokio::test]
async fn image_items_carry_rendition_thumb_urls() {
let pool = mem_pool().await;
mk_media(&pool, "Pic", "p.png", "image", None, "").await;
let body = media_picker_payload(&pool, &MediaPickerQuery::default())
.await
.expect("payload");
let item = &body["items"][0];
let thumb = item["thumb_url"].as_str().expect("thumb_url");
assert!(
thumb.starts_with("/__media__/fill-320x320"),
"spec-first URL: {thumb}"
);
assert!(thumb.contains("v="), "cache-buster present: {thumb}");
let preview = item["preview_url"].as_str().expect("preview_url");
assert!(preview.contains("max-640x480"), "{preview}");
}
}
#[cfg(all(test, feature = "sqlite"))]
mod forms_list_tests {
use super::forms_list_rows;
use crate::forms::submit::FormEntry;
use crate::snippet::Snippet;
use rustango::core::Model as _;
use rustango::sql::{Auto, FetcherPool as _, Pool};
async fn mem_pool() -> Pool {
let pool = Pool::connect("sqlite::memory:")
.await
.expect("in-memory sqlite");
for schema in [&Snippet::SCHEMA, &FormEntry::SCHEMA] {
let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
pool.dialect(),
schema,
);
for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
.await
.expect("ddl");
}
}
pool
}
async fn mk_form(pool: &Pool, slug: &str, title: &str, fields: usize) -> i64 {
let field_json: Vec<serde_json::Value> = (0..fields)
.map(|i| serde_json::json!({"id": format!("f{i}"), "key": format!("k{i}"), "type": "text", "label": "F"}))
.collect();
Snippet {
id: Auto::Unset,
type_name: "form".to_owned(),
folder_path: String::new(),
slug: slug.to_owned(),
title: title.to_owned(),
body_markdown: String::new(),
data: serde_json::json!({
"settings": {},
"pages": [{"id": "p1", "sections": [{"id": "s1", "rows": [{"id": "r1",
"columns": [{"id": "c1", "width": 12, "fields": field_json}]}]}]}]
}),
created_at: Auto::Unset,
updated_at: Auto::Unset,
}
.insert_pool(pool)
.await
.expect("form insert");
Snippet::objects()
.fetch(pool)
.await
.expect("fetch")
.into_iter()
.find(|s| s.slug == slug)
.and_then(|s| s.id.get().copied())
.expect("form id")
}
async fn mk_entry(pool: &Pool, form_id: i64) {
FormEntry {
id: Auto::Unset,
form_snippet_id: form_id,
form_version: 1,
source_page_id: 0,
source_url: "/contact".to_owned(),
data_json: serde_json::json!({"k0": "hi"}),
locale: "en".to_owned(),
ip: String::new(),
submitted_at: Auto::Unset,
}
.insert_pool(pool)
.await
.expect("entry insert");
}
#[tokio::test]
async fn rows_carry_field_and_submission_counts() {
let pool = mem_pool().await;
let a = mk_form(&pool, "contact", "Contact", 3).await;
let b = mk_form(&pool, "rsvp", "RSVP", 1).await;
mk_entry(&pool, a).await;
mk_entry(&pool, a).await;
let rows = forms_list_rows(&pool).await.expect("rows");
assert_eq!(rows.len(), 2);
let by_slug = |slug: &str| rows.iter().find(|r| r["slug"] == slug).expect("row");
let ra = by_slug("contact");
assert_eq!(ra["fields"], 3);
assert_eq!(ra["submissions"], 2);
assert!(
ra["last_submission"].as_str().unwrap().len() >= 16,
"has a timestamp"
);
assert_eq!(ra["build_url"], format!("/cms-admin/forms/{a}/build"));
assert_eq!(
ra["submissions_url"],
format!("/cms-admin/forms/{a}/submissions")
);
let rb = by_slug("rsvp");
assert_eq!(rb["fields"], 1);
assert_eq!(rb["submissions"], 0);
assert_eq!(rb["last_submission"], "");
assert_eq!(rb["delete_url"], format!("/cms-admin/library/{b}/delete"));
}
#[tokio::test]
async fn only_form_snippets_appear() {
let pool = mem_pool().await;
mk_form(&pool, "contact", "Contact", 1).await;
Snippet {
id: Auto::Unset,
type_name: "branding".to_owned(),
folder_path: String::new(),
slug: "site-branding".to_owned(),
title: "Branding".to_owned(),
body_markdown: String::new(),
data: serde_json::json!({}),
created_at: Auto::Unset,
updated_at: Auto::Unset,
}
.insert_pool(&pool)
.await
.expect("snippet insert");
let rows = forms_list_rows(&pool).await.expect("rows");
assert_eq!(rows.len(), 1);
assert_eq!(rows[0]["slug"], "contact");
}
#[test]
fn user_admin_is_superuser_only() {
assert_eq!(super::user_admin_denial_target(Some(true)), None);
assert_eq!(
super::user_admin_denial_target(Some(false)),
Some("/cms-admin/no-access")
);
assert_eq!(super::user_admin_denial_target(None), Some("/login"));
}
#[test]
fn mcp_key_admin_handlers_enforce_the_superuser_gate() {
let src = include_str!("handlers.rs");
for name in ["users_mcp_key_create", "users_mcp_key_revoke"] {
let start = src
.find(&format!("pub async fn {name}("))
.unwrap_or_else(|| panic!("handler {name} not found"));
let rest = &src[start + 1..];
let end = rest.find("\npub async fn ").unwrap_or(rest.len());
assert!(
rest[..end].contains("require_superuser_for_user_admin(session_user.as_ref())"),
"{name} is missing the superuser gate (#646)"
);
}
}
}
#[cfg(test)]
mod password_reset_key_tests {
use super::{password_reset_key, password_reset_scope};
use rustango::auth_flows::PasswordReset;
use std::time::Duration;
const SECRET: &[u8] = b"process-wide-signing-secret";
const BASE: &str = "/cms-admin/password-reset/confirm";
fn link(tenant: &str, hash: &str) -> String {
PasswordReset::issue(
&password_reset_scope(tenant),
BASE,
1,
&password_reset_key(SECRET, tenant, hash),
Duration::from_secs(3600),
)
}
#[test]
fn a_link_verifies_for_the_tenant_and_password_it_was_issued_for() {
let url = link("acme", "$argon2id$v=19$old");
let key = password_reset_key(SECRET, "acme", "$argon2id$v=19$old");
assert_eq!(PasswordReset::verify(&password_reset_scope("acme"), &url, &key).ok(), Some(1));
}
#[test]
fn a_link_issued_on_one_tenant_does_not_verify_on_another() {
let url = link("acme", "$argon2id$v=19$same");
let other = password_reset_key(SECRET, "globex", "$argon2id$v=19$same");
assert!(PasswordReset::verify(&password_reset_scope("globex"), &url, &other).is_err());
}
#[test]
fn a_link_stops_verifying_once_the_password_changes() {
let url = link("acme", "$argon2id$v=19$before");
let after = password_reset_key(SECRET, "acme", "$argon2id$v=19$after");
assert!(PasswordReset::verify(&password_reset_scope("acme"), &url, &after).is_err());
}
}
#[cfg(all(test, feature = "sqlite"))]
mod publish_gate_tests {
use super::{apply_page_edit, PageEditActor, PageEditRefusal};
use crate::page::{Page, PageStatus};
use crate::page_type_model::PageType;
use rustango::core::Column as _;
use rustango::sql::{Auto, Pool};
async fn mem_pool() -> Pool {
let pool = Pool::connect("sqlite::memory:").await.expect("in-memory sqlite");
for entry in inventory::iter::<rustango::core::ModelEntry> {
if !entry.schema.managed {
continue;
}
let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
pool.dialect(),
entry.schema,
);
for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
.await
.expect("ddl");
}
}
pool
}
async fn draft(pool: &Pool) -> Page {
let mut pt = PageType {
id: Auto::Unset,
app_label: "cms".to_owned(),
type_name: "TestPage".to_owned(),
verbose_name: "Test page".to_owned(),
default_template: "page.html".to_owned(),
view_mode: "auto".to_owned(),
is_creatable: true,
allowed_parent_types: serde_json::json!([]),
allowed_child_types: serde_json::json!([]),
workflow: String::new(),
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
pt.save_pool(pool).await.expect("page type");
let mut p = draft_template(pt.id.get().copied().expect("type id"));
p.save_pool(pool).await.expect("page");
p
}
fn draft_template(type_id: i64) -> Page {
Page {
id: Auto::Unset,
page_type_id: type_id,
title: "Draft".to_owned(),
slug: "draft".to_owned(),
path: "0001/".to_owned(),
url_path: "/draft".to_owned(),
preview_path: String::new(),
template_override: String::new(),
depth: 1,
parent_id: None,
locale_variant_of: None,
alias_of: None,
theme_id: None,
sort_order: 0,
status: PageStatus::Draft.as_str().to_owned(),
published_at: None,
last_published_at: None,
go_live_at: None,
expire_at: None,
seo_title: String::new(),
seo_description: String::new(),
robots_index: true,
sitemap_priority: 0.5,
show_in_menus: true,
og_title: String::new(),
og_description: String::new(),
og_image_media_id: None,
twitter_card: "summary".to_owned(),
notification_pre_published_sent: false,
created_at: Auto::Unset,
updated_at: Auto::Unset,
}
}
async fn save(
pool: &Pool,
page: &Page,
status: &str,
go_live_days: Option<i64>,
superuser: bool,
) -> Result<String, &'static str> {
let mut form = crate::page_form::prefill(pool, page).await;
form.insert("status".into(), status.to_owned());
match go_live_days {
Some(d) => form.insert(
"go_live_at".into(),
(chrono::Utc::now() + chrono::Duration::days(d))
.format("%Y-%m-%dT%H:%M")
.to_string(),
),
None => form.remove("go_live_at"),
};
let actor = PageEditActor { id: 999, username: "editor".to_owned(), is_superuser: superuser };
let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
std::sync::Arc::new(crate::cache_invalidate::Noop);
let id = page.id.get().copied().expect("id");
match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, Some(&actor))
.await
.expect("save")
{
Ok(o) => Ok(o.page.status),
Err(PageEditRefusal::PublishDenied) => Err("publish denied"),
Err(PageEditRefusal::ReviewRequired { .. }) => Err("review required"),
Err(_) => Err("other refusal"),
}
}
async fn stored_status(pool: &Pool, page: &Page) -> String {
Page::objects()
.where_(Page::id.eq(page.id.get().copied().expect("id")))
.first(pool)
.await
.expect("query")
.expect("page")
.status
}
async fn stored_theme(pool: &Pool, page: &Page) -> Option<i64> {
Page::objects()
.where_(Page::id.eq(page.id.get().copied().expect("id")))
.first(pool)
.await
.expect("query")
.expect("page")
.theme_id
}
#[tokio::test]
async fn an_editor_save_keeps_the_page_theme() {
let pool = mem_pool().await;
let mut page = draft(&pool).await;
let mut theme = crate::theme::tests::fixture_theme();
theme.save_pool(&pool).await.expect("theme");
let theme_id = theme.id.get().copied().expect("theme id");
page.theme_id = Some(theme_id);
page.save_pool(&pool).await.expect("set theme");
let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
std::sync::Arc::new(crate::cache_invalidate::Noop);
let id = page.id.get().copied().expect("id");
let mut form = crate::page_form::prefill(&pool, &page).await;
form.remove("theme_id");
assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
assert_eq!(stored_theme(&pool, &page).await, Some(theme_id), "a form without the field keeps it");
form.insert("theme_id".into(), String::new());
assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
assert_eq!(stored_theme(&pool, &page).await, None, "posted empty clears it");
}
async fn publish_headline_schema(pool: &Pool, type_id: i64) {
let document = serde_json::json!({
"nodes": [{ "kind": "field", "key": "headline", "label": "Headline", "widget": "text" }]
});
rustango::sql::raw_execute_pool(
pool,
"INSERT INTO cms_page_type_schema (page_type_id, status, version, document) \
VALUES (?, 'published', 1, ?)",
vec![
rustango::core::SqlValue::I64(type_id),
rustango::core::SqlValue::Json(document),
],
)
.await
.expect("schema");
}
#[tokio::test]
async fn the_new_page_form_shows_the_type_fields() {
let pool = mem_pool().await;
let type_id = draft(&pool).await.page_type_id;
publish_headline_schema(&pool, type_id).await;
let mut tera = tera::Tera::default();
crate::admin::register_templates(&mut tera).expect("templates");
let mut ctx = tera::Context::new();
super::insert_type_fields(&mut ctx, &tera, &pool, None, Vec::new(), 0, type_id, None).await;
let body = ctx
.get("builder_body_html")
.and_then(serde_json::Value::as_str)
.expect("builder body on the new form")
.to_owned();
assert!(body.contains("pb__headline"), "headline input missing: {body}");
}
#[tokio::test]
async fn creating_a_page_saves_its_type_fields() {
let pool = mem_pool().await;
let page = draft(&pool).await;
publish_headline_schema(&pool, page.page_type_id).await;
let page_type = PageType::objects()
.where_(PageType::id.eq(page.page_type_id))
.first(&pool)
.await
.expect("type query");
let id = page.id.get().copied().expect("id");
let form = std::collections::HashMap::from([("pb__headline".to_owned(), "Hello".to_owned())]);
super::save_type_content(&pool, page_type.as_ref(), page.page_type_id, id, &form)
.await
.expect("save");
let data = crate::page_builder::model::data_for_page(&pool, id)
.await
.expect("builder data query")
.expect("builder data row")
.data;
assert_eq!(data["headline"], "Hello", "{data}");
}
#[tokio::test]
async fn going_live_by_any_route_needs_the_publish_right() {
let pool = mem_pool().await;
let page = draft(&pool).await;
for (status, go_live) in [
("archived", None),
("published", None),
("draft", Some(1)),
("scheduled", Some(-1)),
] {
assert_eq!(
save(&pool, &page, status, go_live, false).await,
Err("publish denied"),
"{status} / {go_live:?}"
);
assert_eq!(stored_status(&pool, &page).await, "draft", "nothing written");
}
assert_eq!(
save(&pool, &page, "scheduled", None, false).await,
Ok("draft".to_owned()),
"scheduled without a date is parked as a draft, so it is allowed"
);
assert_eq!(
save(&pool, &page, "draft", Some(1), true).await,
Ok("scheduled".to_owned()),
"the publish right schedules"
);
}
async fn bind_review(pool: &Pool, type_id: i64, reapproval: bool) -> crate::workflow::Workflow {
let mut wf = crate::workflow::Workflow {
id: Auto::Unset,
name: "Owner review".to_owned(),
description: String::new(),
active: true,
require_reapproval_on_edit: reapproval,
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
wf.save_pool(pool).await.expect("workflow");
rustango::sql::raw_execute_pool(pool, "INSERT INTO rustango_roles (id, name, description) VALUES (1, 'Owner', '')", Vec::new())
.await
.expect("role");
let mut task = crate::workflow::WorkflowTask {
id: Auto::Unset,
workflow_id: wf.id.get().copied().expect("id"),
name: "Owner checks".to_owned(),
role_id: 1,
sort_order: 10,
kind: "group_approval".to_owned(),
webhook_url: String::new(),
};
task.save_pool(pool).await.expect("task");
let mut pt = PageType::objects()
.where_(PageType::id.eq(type_id))
.first(pool)
.await
.expect("q")
.expect("type");
pt.workflow = "Owner review".to_owned();
pt.save_pool(pool).await.expect("bind");
wf
}
#[tokio::test]
async fn a_review_workflow_cannot_be_published_around() {
let pool = mem_pool().await;
let page = draft(&pool).await;
let mut wf = bind_review(&pool, page.page_type_id, false).await;
assert_eq!(save(&pool, &page, "published", None, false).await, Err("review required"));
assert_eq!(save(&pool, &page, "draft", Some(1), false).await, Err("review required"), "nor scheduled");
assert_eq!(stored_status(&pool, &page).await, "draft");
assert_eq!(save(&pool, &page, "draft", None, false).await, Ok("draft".to_owned()), "drafts still save");
assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()), "the owner can");
let other = draft_named(&pool, page.page_type_id, "second").await;
wf.name = "Studio review".to_owned();
wf.save_pool(&pool).await.expect("rename");
assert_eq!(crate::workflow::rebind_page_types(&pool, "Owner review", "Studio review").await.expect("rebind"), 1);
assert_eq!(save(&pool, &other, "published", None, false).await, Err("review required"));
}
async fn retitle(pool: &Pool, page: &Page, title: &str, actor: Option<&PageEditActor>) -> super::PageEditOutcome {
let mut form = crate::page_form::prefill(pool, page).await;
form.insert("title".into(), title.to_owned());
let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
std::sync::Arc::new(crate::cache_invalidate::Noop);
let id = page.id.get().copied().expect("id");
match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, actor).await.expect("save") {
Ok(o) => o,
Err(_) => panic!("refused"),
}
}
async fn stored_title(pool: &Pool, page: &Page) -> String {
Page::objects()
.where_(Page::id.eq(page.id.get().copied().expect("id")))
.first(pool)
.await
.expect("query")
.expect("page")
.title
}
#[tokio::test]
async fn a_live_page_edit_waits_for_review() {
let pool = mem_pool().await;
let page = draft(&pool).await;
bind_review(&pool, page.page_type_id, true).await;
assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()));
let id = page.id.get().copied().expect("id");
let mut mia = rustango::tenancy::auth::User {
id: Auto::Unset,
username: "mia".to_owned(),
password_hash: String::new(),
email: None,
is_superuser: false,
active: true,
created_at: chrono::Utc::now(),
data: serde_json::json!({}),
password_changed_at: None,
sessions_revoked_at: None,
};
mia.save_pool(&pool).await.expect("user");
let editor = PageEditActor { id: mia.id.get().copied().expect("id"), username: "mia".to_owned(), is_superuser: false };
let out = retitle(&pool, &page, "Proposed", Some(&editor)).await;
assert!(out.held_for_review && out.reapproval_kicked);
assert_eq!(stored_title(&pool, &page).await, "Draft", "the live page is unchanged");
let held = crate::pending_change::for_page(&pool, id).await.expect("q").expect("held");
assert_eq!(held.form_map().get("title").map(String::as_str), Some("Proposed"));
let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review started");
let tasks = crate::workflow::tasks_for(&pool, state.workflow_id).await.expect("tasks");
crate::workflow::approve_current(&pool, &mut state, &tasks, editor.id, "").await.expect("approve");
let applied = retitle(&pool, &page, "Proposed", None).await;
assert!(!applied.held_for_review);
assert_eq!(stored_title(&pool, &page).await, "Proposed");
retitle(&pool, &page, "Second try", Some(&editor)).await;
let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review restarted");
crate::workflow::cancel(&pool, &mut state, editor.id).await.expect("cancel");
assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
retitle(&pool, &page, "Third try", Some(&editor)).await;
let owner = PageEditActor { id: 1, username: "owner".to_owned(), is_superuser: true };
assert!(!retitle(&pool, &page, "Owner's", Some(&owner)).await.held_for_review);
assert_eq!(stored_title(&pool, &page).await, "Owner's");
assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
}
async fn draft_named(pool: &Pool, type_id: i64, slug: &str) -> Page {
let mut p = draft_template(type_id);
slug.clone_into(&mut p.slug);
p.path = "0002/".to_owned();
p.url_path = format!("/{slug}");
p.save_pool(pool).await.expect("page");
p
}
}
#[cfg(test)]
mod active_upload_tests {
use super::refuse_active_upload;
#[test]
fn page_like_types_are_refused_and_media_is_not() {
for bad in ["text/html", "application/xhtml+xml", "text/javascript", "application/xml"] {
assert!(refuse_active_upload(bad).is_err(), "{bad}");
}
for ok in ["image/png", "image/svg+xml", "application/pdf", "text/plain", "video/mp4"] {
assert!(refuse_active_upload(ok).is_ok(), "{ok}");
}
}
}