use axum::extract::{Query, State};
use axum::response::{IntoResponse, Redirect, Response};
use axum::Form;
use rustango::extractors::{SessionUser, Tenant};
use serde::Deserialize;
use tera::Context;
use super::handlers::{self, add_admin_theme, add_chrome, render_with_csrf};
use super::AdminError;
use crate::tenant_templates::{self, EditError, Source};
#[derive(Debug, Deserialize)]
pub(crate) struct NameQuery {
#[serde(default)]
pub name: String,
#[serde(default)]
pub saved: Option<String>,
}
#[derive(Debug, Deserialize)]
pub(crate) struct SaveForm {
pub name: String,
pub body: String,
}
#[derive(Debug, Deserialize)]
pub(crate) struct NameForm {
pub name: String,
}
pub const CODENAME: &str = "cms_template.edit";
async fn ensure_access(
tenant: &Tenant,
user: Option<&rustango::tenancy::auth::User>,
) -> Option<Response> {
super::codename_gate(tenant, user, CODENAME).await
}
fn store() -> Result<std::sync::Arc<tenant_templates::TenantTemplates>, ()> {
tenant_templates::installed().ok_or(())
}
pub(crate) async fn list(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "templates", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
match store() {
Err(()) => ctx.insert("not_configured", &true),
Ok(tt) => {
let rows: Vec<serde_json::Value> = tt
.list_for(&tenant.org.slug)
.into_iter()
.map(|e| {
serde_json::json!({
"name": e.name,
"overridden": e.source == Source::Override,
"bytes": e.bytes,
})
})
.collect();
let overridden = rows.iter().filter(|r| r["overridden"] == true).count();
ctx.insert("not_configured", &false);
ctx.insert("rows", &rows);
ctx.insert("overridden_count", &overridden);
ctx.insert("tenant_slug", &tenant.org.slug);
}
}
render_with_csrf(&state, &headers, "rcms_admin/template_list.html", &mut ctx)
}
pub(crate) async fn edit_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
Query(q): Query<NameQuery>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Ok(tt) = store() else {
return Ok(Redirect::to("/cms-admin/templates").into_response());
};
let Ok(name) = tenant_templates::safe_name(&q.name) else {
return Ok(Redirect::to("/cms-admin/templates").into_response());
};
let slug = &tenant.org.slug;
let own = tt.read_override(slug, &name);
let global = tt.read_global(&name);
let body = own.clone().or_else(|| global.clone()).unwrap_or_default();
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "templates", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("name", &name);
ctx.insert("body", &body);
ctx.insert("is_override", &own.is_some());
ctx.insert("has_global", &global.is_some());
ctx.insert("saved", &q.saved.is_some());
ctx.insert("tenant_slug", slug);
render_with_csrf(&state, &headers, "rcms_admin/template_form.html", &mut ctx)
}
pub(crate) async fn save(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
Form(form): Form<SaveForm>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Ok(tt) = store() else {
return Ok(Redirect::to("/cms-admin/templates").into_response());
};
let slug = &tenant.org.slug;
match tt.write_override(slug, &form.name, &form.body) {
Ok(()) => Ok(Redirect::to(&format!(
"/cms-admin/templates/edit?name={}&saved=1",
urlencode(&form.name)
))
.into_response()),
Err(e) => {
let mut ctx = Context::new();
add_chrome(&mut ctx, &tenant, "templates", session_user.as_ref()).await;
add_admin_theme(&mut ctx, tenant.pool()).await;
ctx.insert("name", &form.name);
ctx.insert("body", &form.body);
ctx.insert("is_override", &tt.read_override(slug, &form.name).is_some());
ctx.insert("has_global", &tt.read_global(&form.name).is_some());
ctx.insert("saved", &false);
ctx.insert("error", &error_text(&e));
ctx.insert("tenant_slug", slug);
render_with_csrf(&state, &headers, "rcms_admin/template_form.html", &mut ctx)
}
}
}
pub(crate) async fn validate(
tenant: Tenant,
SessionUser(session_user): SessionUser,
Form(form): Form<SaveForm>,
) -> Response {
if ensure_access(&tenant, session_user.as_ref()).await.is_some() {
return (
axum::http::StatusCode::FORBIDDEN,
axum::Json(serde_json::json!({ "ok": false, "error": "not permitted" })),
)
.into_response();
}
let Ok(tt) = store() else {
return axum::Json(serde_json::json!({
"ok": false,
"error": "per-tenant templates are not configured",
}))
.into_response();
};
match tt.validate(&tenant.org.slug, &form.name, &form.body) {
Ok(()) => axum::Json(serde_json::json!({ "ok": true })).into_response(),
Err(e) => {
axum::Json(serde_json::json!({ "ok": false, "error": e.to_string() })).into_response()
}
}
}
pub(crate) async fn create(
State(_state): State<super::AdminState>,
tenant: Tenant,
SessionUser(session_user): SessionUser,
Form(form): Form<NameForm>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
match tenant_templates::safe_name(&form.name) {
Ok(name) => Ok(Redirect::to(&format!(
"/cms-admin/templates/edit?name={}",
urlencode(&name)
))
.into_response()),
Err(_) => Ok(Redirect::to("/cms-admin/templates?bad_name=1").into_response()),
}
}
pub(crate) async fn delete(
State(_state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
Form(form): Form<NameForm>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Ok(tt) = store() else {
return Ok(Redirect::to("/cms-admin/templates").into_response());
};
if tt.read_global(&form.name).is_none() {
let dependents = page_types_using(&tenant, &form.name).await?;
if !dependents.is_empty() {
let types = dependents.join(", ");
return handlers::redirect_named_with_params_and_message_args(
"rcms-admin:templates:list",
&[],
rustango::messages::Level::Error,
"Cannot remove {name} — {types} render with it and nothing would replace it. Point those page types elsewhere first.",
&[("name", form.name.as_str()), ("types", types.as_str())],
&headers,
);
}
}
if let Err(e) = tt.delete_override(&tenant.org.slug, &form.name) {
tracing::warn!(
target: "rustango_cms::admin",
template = %form.name, error = %e,
"could not remove tenant template override",
);
}
Ok(Redirect::to("/cms-admin/templates").into_response())
}
async fn page_types_using(tenant: &Tenant, name: &str) -> Result<Vec<String>, AdminError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let rows: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::default_template.eq(name.to_owned()))
.fetch(tenant.pool())
.await?;
Ok(rows
.into_iter()
.map(|r| {
if r.verbose_name.trim().is_empty() {
r.type_name
} else {
r.verbose_name
}
})
.collect())
}
fn error_text(e: &EditError) -> String {
e.to_string()
}
fn urlencode(raw: &str) -> String {
let mut out = String::with_capacity(raw.len());
for b in raw.bytes() {
if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
out.push(char::from(b));
} else {
out.push_str(&format!("%{b:02X}"));
}
}
out
}
#[derive(Debug, Deserialize)]
pub(crate) struct TemplateAssignForm {
#[serde(default)]
pub template: String,
}
pub(crate) async fn assign_form(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
axum::extract::Path(id): axum::extract::Path<i64>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Some(row) = load_type(&tenant, id).await? else {
return Ok(Redirect::to("/cms-admin/page-types").into_response());
};
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("type_name", &row.type_name);
ctx.insert("verbose_name", &row.verbose_name);
ctx.insert("type_id", &id);
ctx.insert("current", &row.default_template);
ctx.insert("choices", &renderable_templates(&tenant, &row.default_template));
ctx.insert(
"is_api_only",
&matches!(
crate::page_view::kind_for(&row),
crate::page_view::PageViewKind::ApiOnly
),
);
render_with_csrf(
&state,
&headers,
"rcms_admin/page_type_template_form.html",
&mut ctx,
)
}
pub(crate) async fn assign_save(
State(state): State<super::AdminState>,
tenant: Tenant,
headers: axum::http::HeaderMap,
SessionUser(session_user): SessionUser,
axum::extract::Path(id): axum::extract::Path<i64>,
Form(form): Form<TemplateAssignForm>,
) -> Result<Response, AdminError> {
if let Some(r) = ensure_access(&tenant, session_user.as_ref()).await {
return Ok(r);
}
let Some(mut row) = load_type(&tenant, id).await? else {
return Ok(Redirect::to("/cms-admin/page-types").into_response());
};
let chosen = form.template.trim().to_owned();
if !chosen.is_empty()
&& !renderable_templates(&tenant, &row.default_template)
.iter()
.any(|t| t == &chosen)
{
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("type_name", &row.type_name);
ctx.insert("verbose_name", &row.verbose_name);
ctx.insert("type_id", &id);
ctx.insert("current", &row.default_template);
ctx.insert("choices", &renderable_templates(&tenant, &row.default_template));
ctx.insert("is_api_only", &false);
ctx.insert("error", &chosen);
return render_with_csrf(
&state,
&headers,
"rcms_admin/page_type_template_form.html",
&mut ctx,
);
}
row.default_template = chosen;
row.save(tenant.pool()).await?;
Ok(Redirect::to("/cms-admin/page-types").into_response())
}
async fn load_type(
tenant: &Tenant,
id: i64,
) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
use rustango::core::Column as _;
Ok(crate::page_type_model::PageType::objects()
.where_(crate::page_type_model::PageType::id.eq(id))
.first(tenant.pool())
.await?)
}
fn renderable_templates(tenant: &Tenant, current: &str) -> Vec<String> {
let Some(tt) = tenant_templates::installed() else {
return if current.is_empty() {
Vec::new()
} else {
vec![current.to_owned()]
};
};
let mut names: Vec<String> = tt
.for_tenant(&tenant.org.slug)
.get_template_names()
.filter(|n| offerable(n) || *n == current)
.map(str::to_owned)
.collect();
if !current.is_empty() && !names.iter().any(|n| n == current) {
names.push(current.to_owned());
}
names.sort();
names.dedup();
names
}
pub(crate) fn offerable(name: &str) -> bool {
if name == crate::page_builder::DEFAULT_SCHEMA_TEMPLATE {
return true;
}
if name.starts_with("rcms_admin/") || name.starts_with("rcms/") {
return false;
}
let mut segments = name.split('/');
let file = segments.next_back().unwrap_or(name);
!file.starts_with('_') && !segments.any(|dir| dir == "blocks")
}
#[cfg(test)]
mod tests {
use super::offerable;
#[test]
fn admin_chrome_is_not_offered_for_a_page_type() {
assert!(!offerable("rcms_admin/_base.html"));
assert!(!offerable("rcms_admin/page_form.html"));
assert!(!offerable("rcms/view_password.html"));
}
#[test]
fn the_builder_default_is_offered_despite_its_namespace() {
assert!(offerable(crate::page_builder::DEFAULT_SCHEMA_TEMPLATE));
assert!(offerable("rcms_admin/schema_page.html"));
}
#[test]
fn ordinary_site_templates_are_offered() {
assert!(offerable("landing.html"));
assert!(offerable("shop/product.html"));
assert!(offerable("login.html"));
}
#[test]
fn partials_are_not_offered_for_a_page_type() {
assert!(!offerable("_base.html"));
assert!(!offerable("_product_card.html"));
assert!(!offerable("shop/_card.html"));
assert!(!offerable("blocks/hero.html"));
assert!(!offerable("theme/blocks/quote.html"));
assert!(offerable("blocks_index.html"));
assert!(offerable("myblocks/page.html"));
}
}