use std::sync::Arc;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post};
use axum::Router;
use serde::Deserialize;
use tera::Tera;
use crate::page::PageStatus;
use crate::tree_ops::TreeError;
pub mod admin_page;
pub mod cms_admin;
pub use handlers::add_chrome;
pub use handlers::issue_password_reset_link;
pub mod chooser;
mod handlers;
mod i18n;
pub(crate) fn tr(headers: &axum::http::HeaderMap, source: &str) -> String {
i18n::tr(headers, source, &[])
}
pub(crate) mod members;
pub use members::{authenticate_member, MemberLoginError};
pub use i18n::extend_ui_catalog;
pub mod model_admin;
pub mod pagination;
pub mod report;
pub mod resources;
mod route_perms;
pub(crate) mod notifications;
pub(crate) mod sites;
pub(crate) mod help_center;
pub(crate) mod site_theme;
pub(crate) mod template_editor;
pub use template_editor::CODENAME as TEMPLATE_EDIT_CODENAME;
pub use notifications::CODENAME as NOTIFICATION_MANAGE_CODENAME;
pub use sites::CODENAME as SITE_MANAGE_CODENAME;
pub(crate) use template_editor::offerable as template_offerable;
pub use handlers::ListQuery;
pub(crate) use handlers::{
allowed_children_for, allowed_root_types, apply_page_edit, dedup_slug_under_parent,
media_picker_payload, slugify, store_media, upsert_page_translations, MediaPickerQuery,
PageEditActor, PageEditOutcome, PageEditRefusal,
};
#[derive(Clone)]
pub(crate) struct AdminState {
pub(crate) tera: Arc<Tera>,
pub(crate) signing_secret: Arc<Vec<u8>>,
pub(crate) cache_invalidator: Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
pub(crate) mailer: Option<Arc<dyn rustango::email::Mailer>>,
pub(crate) mailer_from: Arc<String>,
}
pub fn router(tera: Arc<Tera>) -> Router {
let secret = crate::signing::derived_key(PASSWORD_RESET_KEY_PURPOSE);
crate::perf::instrument(router_with_state(AdminState {
tera,
signing_secret: Arc::new(secret),
cache_invalidator: crate::cache_invalidate::noop(),
mailer: None,
mailer_from: Arc::new(String::new()),
}))
}
pub fn router_with_invalidator(
tera: Arc<Tera>,
invalidator: Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
) -> Router {
let secret = crate::signing::derived_key(PASSWORD_RESET_KEY_PURPOSE);
crate::task_queue::set_default_invalidator(Arc::clone(&invalidator));
router_with_state(AdminState {
tera,
signing_secret: Arc::new(secret),
cache_invalidator: invalidator,
mailer: None,
mailer_from: Arc::new(String::new()),
})
}
pub fn router_with_mailer(
tera: Arc<Tera>,
invalidator: Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
mailer: Arc<dyn rustango::email::Mailer>,
from_addr: impl Into<String>,
) -> Router {
let secret = crate::signing::derived_key(PASSWORD_RESET_KEY_PURPOSE);
crate::task_queue::set_default_invalidator(Arc::clone(&invalidator));
let from_addr: String = from_addr.into();
crate::task_queue::set_default_mailer(Arc::clone(&mailer), from_addr.clone());
router_with_state(AdminState {
tera,
signing_secret: Arc::new(secret),
cache_invalidator: invalidator,
mailer: Some(mailer),
mailer_from: Arc::new(from_addr),
})
}
pub fn public_router(tera: Arc<Tera>) -> Router {
public_router_inner(tera, None, String::new())
}
pub fn public_router_with_mailer(
tera: Arc<Tera>,
mailer: Arc<dyn rustango::email::Mailer>,
from_addr: impl Into<String>,
) -> Router {
public_router_inner(tera, Some(mailer), from_addr.into())
}
fn public_router_inner(
tera: Arc<Tera>,
mailer: Option<Arc<dyn rustango::email::Mailer>>,
mailer_from: String,
) -> Router {
let secret = crate::signing::derived_key(PASSWORD_RESET_KEY_PURPOSE);
let state = AdminState {
tera,
signing_secret: Arc::new(secret),
cache_invalidator: crate::cache_invalidate::noop(),
mailer,
mailer_from: Arc::new(mailer_from),
};
Router::new()
.route(
"/cms-admin/password-reset",
get(handlers::password_reset_request_form)
.post(handlers::password_reset_request_submit),
)
.route(
"/cms-admin/password-reset/confirm",
get(handlers::password_reset_confirm_form)
.post(handlers::password_reset_confirm_submit),
)
.route("/login", get(handlers::cms_login_form))
.route(
"/members/login",
get(members::member_login_form).post(members::member_login_submit),
)
.route(
"/members/signup",
get(members::member_signup_form).post(members::member_signup_submit),
)
.route("/members/logout", post(members::member_logout))
.route(
"/__cms-branding/logo",
get(handlers::settings_branding_serve_logo),
)
.route(
"/__cms-branding/favicon",
get(handlers::settings_branding_serve_favicon),
)
.route("/cms-admin/no-access", get(handlers::no_access_page))
.route("/cms-admin/static/cms.css", get(serve_cms_css))
.route("/cms-admin/static/fonts.css", get(serve_admin_fonts_css))
.route(
"/cms-admin/static/vendor/fonts/{file}",
get(serve_admin_font_file),
)
.route("/cms-admin/static/brand/{file}", get(serve_admin_brand_file))
.route("/cms-admin/static/cms-ux.js", get(serve_cms_ux_js))
.route(
"/cms-admin/static/stream_editor.js",
get(serve_stream_editor_js),
)
.route("/cms-admin/static/block_tree.js", get(serve_block_tree_js))
.route("/cms-admin/static/cms-preview.js", get(serve_cms_preview_js))
.route(
"/cms-admin/static/menu-builder.js",
get(serve_menu_builder_js),
)
.route(
"/cms-admin/static/form_builder.js",
get(serve_form_builder_js),
)
.route(
"/cms-admin/static/page_type_builder.js",
get(serve_page_type_builder_js),
)
.route(
"/cms-admin/static/page_builder_rules.js",
get(serve_page_builder_rules_js),
)
.route(
"/cms-admin/static/vendor/axe-core.min.js",
get(serve_axe_core_js),
)
.route(
"/cms-admin/static/cms-axe-preview.js",
get(serve_cms_axe_preview_js),
)
.route(
"/cms-admin/static/cms-preview-guard.js",
get(serve_cms_preview_guard_js),
)
.route(
"/cms-admin/static/template-editor.js",
get(serve_template_editor_js),
)
.route(
"/cms-admin/static/vendor/codemirror.bundle.js",
get(serve_codemirror_bundle_js),
)
.route(
"/cms-admin/static/vendor/tiptap.bundle.js",
get(serve_tiptap_bundle_js),
)
.route(
"/cms-admin/static/richtext-editor.js",
get(serve_richtext_editor_js),
)
.route(
"/cms-admin/static/vendor/THIRD-PARTY-NOTICES.txt",
get(serve_third_party_notices),
)
.route_layer(axum::middleware::from_fn(i18n::tenant_overrides_layer))
.with_state(state)
}
async fn serve_third_party_notices() -> impl axum::response::IntoResponse {
(
[(
axum::http::header::CONTENT_TYPE,
axum::http::HeaderValue::from_static("text/plain; charset=utf-8"),
)],
include_str!("static/vendor/THIRD-PARTY-NOTICES.txt"),
)
}
const PASSWORD_RESET_KEY_PURPOSE: &str = "rcms:password-reset";
pub fn with_login_required(router: Router, login_url: impl Into<String> + 'static) -> Router {
use axum::middleware::{from_fn, Next};
let login_url: Arc<str> = Arc::from(login_url.into());
router.layer(from_fn(
move |req: axum::http::Request<axum::body::Body>, next: Next| {
let login_url = login_url.clone();
async move {
use axum::extract::FromRequestParts as _;
let (mut parts, body) = req.into_parts();
let user = rustango::extractors::SessionUser::from_request_parts(&mut parts, &())
.await
.unwrap_or(rustango::extractors::SessionUser(None));
if let Some(user) = user.0 {
let allowed = user.is_superuser
|| parts.uri.path().starts_with("/cms-admin/static/")
|| matches!(
check_codename(&mut parts, "cms_admin.access").await,
AccessResult::Allowed
);
if !allowed {
use axum::response::IntoResponse as _;
return axum::response::Redirect::to("/cms-admin/no-access").into_response();
}
let req = axum::http::Request::from_parts(parts, body);
return next.run(req).await;
}
let original = parts
.uri
.path_and_query()
.map(|p| p.as_str().to_owned())
.unwrap_or_else(|| "/".to_owned());
rustango::auth_decorators::redirect_to_login(&login_url, "next", &original)
}
},
))
}
pub fn with_cms_admin_access(router: Router, no_access_url: impl Into<String>) -> Router {
with_codename_gate(router, "cms_admin.access", no_access_url)
}
pub fn with_codename_gate(
router: Router,
codename: &'static str,
no_access_url: impl Into<String>,
) -> Router {
use axum::middleware::{from_fn, Next};
use axum::response::{IntoResponse, Redirect};
let no_access_url: Arc<str> = Arc::from(no_access_url.into());
router.layer(from_fn(
move |req: axum::http::Request<axum::body::Body>, next: Next| {
let no_access_url = no_access_url.clone();
async move {
let path = req.uri().path();
if path == &*no_access_url || path.starts_with("/cms-admin/static/") {
return next.run(req).await;
}
let (mut parts, body) = req.into_parts();
let outcome = check_codename(&mut parts, codename).await;
let req = axum::http::Request::from_parts(parts, body);
match outcome {
AccessResult::Allowed | AccessResult::DeniedNoUser => next.run(req).await,
AccessResult::Denied => Redirect::to(&no_access_url).into_response(),
}
}
},
))
}
enum AccessResult {
Allowed,
Denied,
DeniedNoUser,
}
pub(crate) async fn codename_gate(
tenant: &rustango::extractors::Tenant,
user: Option<&rustango::tenancy::auth::User>,
codename: &str,
) -> Option<axum::response::Response> {
use axum::response::{IntoResponse, Redirect};
let Some(user) = user else {
return Some(Redirect::to("/login").into_response());
};
if user.is_superuser {
return None;
}
let uid = user.id.get().copied().unwrap_or_default();
let codes = crate::permissions::user_codenames(tenant.pool(), uid)
.await
.unwrap_or_default();
if codes.contains(codename) {
None
} else {
Some(Redirect::to("/cms-admin/no-access").into_response())
}
}
async fn check_codename(parts: &mut axum::http::request::Parts, codename: &str) -> AccessResult {
let (user, pool) = match request_user_and_pool(parts).await {
Ok(Some(found)) => found,
Ok(None) => return AccessResult::DeniedNoUser,
Err(()) => return AccessResult::Denied,
};
if user.is_superuser {
return AccessResult::Allowed;
}
let uid = user.id.get().copied().unwrap_or_default();
let codenames = crate::permissions::user_codenames(&pool, uid)
.await
.unwrap_or_default();
if codenames.contains(codename) {
AccessResult::Allowed
} else {
AccessResult::Denied
}
}
pub(crate) async fn request_user_and_pool(
parts: &mut axum::http::request::Parts,
) -> Result<Option<(rustango::tenancy::auth::User, rustango::sql::Pool)>, ()> {
use axum::extract::FromRequestParts as _;
use rustango::tenancy::OrgResolver as _;
use std::sync::Arc;
let Some(ctx) = parts
.extensions
.get::<Arc<rustango::extractors::TenantContext>>()
.cloned()
else {
return Ok(None);
};
let Ok(rustango::extractors::SessionUser(Some(user))) =
rustango::extractors::SessionUser::from_request_parts(parts, &()).await
else {
return Ok(None);
};
let Ok(Some(org)) = ctx.resolver.resolve(parts, &ctx.pools.registry_pool()).await else {
return Ok(None);
};
let pool = ctx.pools.scoped_pool_dyn(&org).await.map_err(|_| ())?;
Ok(Some((user, pool)))
}
fn router_with_state(state: AdminState) -> Router {
Router::new()
.route("/cms-admin", get(redirect_root))
.route("/cms-admin/", get(redirect_root))
.route("/cms-admin/pages", get(handlers::page_list))
.route(
"/cms-admin/pages/new",
get(handlers::page_new_form).post(handlers::page_new_submit),
)
.route(
"/cms-admin/pages/{id}/edit",
get(handlers::page_edit_form).post(handlers::page_edit_submit),
)
.route(
"/cms-admin/pages/{id}/translate",
post(handlers::page_translate_submit),
)
.route(
"/cms-admin/pages/{id}/delete",
post(handlers::page_delete_submit),
)
.route(
"/cms-admin/pages/{id}/preview",
get(handlers::page_preview).post(handlers::page_preview_draft),
)
.route(
"/cms-admin/pages/{id}/preview-token",
get(handlers::page_preview_token),
)
.route(
"/cms-admin/pages/{id}/revert/{rev_id}",
post(handlers::page_revert_submit),
)
.route(
"/cms-admin/pages/{id}/history/diff",
get(handlers::history_diff),
)
.route("/cms-admin/pages/{id}/log.csv", get(handlers::page_log_csv))
.route(
"/cms-admin/pages/{id}/permissions",
post(handlers::page_permissions_submit),
)
.route(
"/cms-admin/pages/{id}/move",
post(handlers::page_move_submit),
)
.route(
"/cms-admin/pages/{id}/clone",
post(handlers::page_clone_submit),
)
.route(
"/cms-admin/pages/{id}/alias",
post(handlers::page_alias_submit),
)
.route(
"/cms-admin/pages/{id}/privacy",
post(handlers::page_privacy_submit),
)
.route("/cms-admin/pages/bulk", post(handlers::page_bulk_submit))
.route(
"/cms-admin/pages/{id}/unlock",
post(handlers::page_unlock_submit),
)
.route(
"/cms-admin/pages/{id}/inline/{panel}/order",
post(handlers::inline_cards_order),
)
.route(
"/cms-admin/pages/{id}/inline/{panel}/{row}",
get(handlers::inline_card_body).post(handlers::inline_card_save),
)
.route(
"/cms-admin/pages/{id}/inline/{panel}/{row}/remove",
post(handlers::inline_card_remove),
)
.route(
"/cms-admin/pages/{id}/lock-release",
post(handlers::page_lock_release),
)
.route(
"/cms-admin/pages/{id}/lock-heartbeat",
post(handlers::page_lock_heartbeat),
)
.route(
"/cms-admin/pages/{id}/autosave",
post(handlers::page_autosave_submit),
)
.route(
"/cms-admin/pages/{id}/sessions",
get(handlers::page_sessions_json),
)
.route(
"/cms-admin/pages/{id}/subscribe",
post(handlers::page_subscribe_submit),
)
.route(
"/cms-admin/pages/{id}/unsubscribe",
post(handlers::page_unsubscribe_submit),
)
.route(
"/cms-admin/pages/{id}/comments/new",
post(handlers::comment_new_submit),
)
.route(
"/cms-admin/pages/{id}/comments/{comment_id}/reply",
post(handlers::comment_reply_submit),
)
.route(
"/cms-admin/pages/{id}/comments/{comment_id}/resolve",
post(handlers::comment_resolve_submit),
)
.route(
"/cms-admin/pages/{id}/comments/{comment_id}/reopen",
post(handlers::comment_reopen_submit),
)
.route(
"/cms-admin/pages/{id}/workflow/submit",
post(handlers::page_workflow_submit),
)
.route(
"/cms-admin/pages/{id}/workflow/approve",
post(handlers::page_workflow_approve),
)
.route(
"/cms-admin/pages/{id}/workflow/reject",
post(handlers::page_workflow_reject),
)
.route(
"/cms-admin/pages/{id}/workflow/cancel",
post(handlers::page_workflow_cancel),
)
.route("/cms-admin/library", get(handlers::library_list))
.route("/cms-admin/forms", get(handlers::forms_list))
.route("/cms-admin/set-language", post(handlers::admin_set_language))
.route(
"/cms-admin/forms/{id}/build",
get(handlers::form_build_form).post(handlers::form_build_submit),
)
.route(
"/cms-admin/forms/{id}/preview",
get(handlers::form_preview).post(handlers::form_preview_draft),
)
.route(
"/cms-admin/forms/{id}/publish",
post(handlers::form_publish_submit),
)
.route(
"/cms-admin/forms/{id}/submissions",
get(handlers::form_submissions_list),
)
.route(
"/cms-admin/forms/{id}/submissions/export.csv",
get(handlers::form_submissions_csv),
)
.route(
"/cms-admin/forms/{id}/submissions/file/{key}",
get(handlers::form_submission_file),
)
.route(
"/cms-admin/library/new",
get(handlers::snippet_new_form).post(handlers::snippet_create_submit),
)
.route(
"/cms-admin/library/{id}/edit",
get(handlers::snippet_edit_form).post(handlers::snippet_edit_submit),
)
.route(
"/cms-admin/library/{id}/translate",
post(handlers::snippet_translate_submit),
)
.route(
"/cms-admin/library/{type_name}/bulk",
post(handlers::library_bulk_submit),
)
.route(
"/cms-admin/library/{id}/delete",
post(handlers::snippet_delete_submit),
)
.route(
"/cms-admin/library/{id}/revert/{seq}",
post(handlers::snippet_revert_submit),
)
.route(
"/cms-admin/library/{type_name}/import",
get(handlers::snippet_import_form).post(handlers::snippet_import_submit),
)
.route("/cms-admin/media", get(handlers::media_list))
.route(
"/cms-admin/media/{id}/edit",
get(handlers::media_edit_form).post(handlers::media_edit_submit),
)
.route(
"/cms-admin/media/{id}/crop",
post(handlers::media_crop_submit),
)
.route(
"/cms-admin/media/{id}/replace",
post(handlers::media_replace_submit),
)
.route(
"/cms-admin/media/collections",
get(handlers::collections_list),
)
.route(
"/cms-admin/media/collections/new",
post(handlers::collections_create),
)
.route(
"/cms-admin/media/collections/{id}/edit",
post(handlers::collections_edit),
)
.route(
"/cms-admin/media/collections/{id}/delete",
post(handlers::collections_delete),
)
.route(
"/cms-admin/media/bulk-move-collection",
post(handlers::media_bulk_move_collection),
)
.route("/cms-admin/taxonomies", get(handlers::taxonomies_index))
.route("/cms-admin/taxonomies/{slug}", get(handlers::category_tree))
.route(
"/cms-admin/taxonomies/{slug}/categories/new",
get(handlers::category_new_form).post(handlers::category_create),
)
.route(
"/cms-admin/taxonomies/{slug}/categories/{id}/edit",
get(handlers::category_edit_form).post(handlers::category_update),
)
.route(
"/cms-admin/taxonomies/{slug}/categories/{id}/delete",
post(handlers::category_delete),
)
.route(
"/cms-admin/taxonomies/{slug}/categories/{id}/translate",
post(handlers::category_translate_submit),
)
.route(
"/cms-admin/media/collections/{id}/permissions",
get(handlers::collection_permissions_form)
.post(handlers::collection_permissions_submit),
)
.route(
"/cms-admin/media/collections/{id}/privacy",
post(handlers::collection_privacy_submit),
)
.route(
"/cms-admin/media/unused",
get(handlers::media_unused_report),
)
.route(
"/cms-admin/media/unused/delete",
post(handlers::media_unused_bulk_delete),
)
.route(
"/cms-admin/media/upload",
get(handlers::media_upload_form).post(handlers::media_upload_submit),
)
.route(
"/cms-admin/media/upload-staged",
post(handlers::media_upload_staged)
.route_layer(axum::extract::DefaultBodyLimit::max(50 * 1024 * 1024)),
)
.route(
"/cms-admin/media/upload-staged/{id}/cancel",
post(handlers::media_upload_staged_cancel),
)
.route(
"/cms-admin/media/upload-staged/commit",
post(handlers::media_upload_staged_commit),
)
.route(
"/cms-admin/media/{id}/delete",
post(handlers::media_delete_submit),
)
.route("/cms-admin/documents", get(handlers::documents_list))
.route("/cms-admin/model/{slug}", get(handlers::model_admin_list))
.route("/cms-admin/report/{slug}", get(handlers::report_view))
.route(
"/cms-admin/__chooser/{slug}",
get(handlers::chooser_search_json),
)
.route(
"/cms-admin/__media-picker",
get(handlers::media_picker_json),
)
.route("/cms-admin/sso-providers", get(handlers::sso_provider_list))
.route(
"/cms-admin/sso-providers/new",
get(handlers::sso_provider_new_form).post(handlers::sso_provider_new_submit),
)
.route(
"/cms-admin/sso-providers/{id}/edit",
get(handlers::sso_provider_edit_form).post(handlers::sso_provider_edit_submit),
)
.route(
"/cms-admin/sso-providers/{id}/delete",
post(handlers::sso_provider_delete_submit),
)
.route("/cms-admin/locales", get(handlers::locale_list))
.route(
"/cms-admin/locales/new",
get(handlers::locale_new_form).post(handlers::locale_new_submit),
)
.route(
"/cms-admin/locales/{id}/edit",
get(handlers::locale_edit_form).post(handlers::locale_edit_submit),
)
.route(
"/cms-admin/locales/{id}/delete",
post(handlers::locale_delete_submit),
)
.route("/cms-admin/search", get(handlers::admin_search))
.route(
"/cms-admin/site-settings",
get(handlers::site_settings_list),
)
.route(
"/cms-admin/site-settings/{scope}/edit",
get(handlers::site_setting_edit_form).post(handlers::site_setting_edit_submit),
)
.route(
"/cms-admin/site-settings/{scope}/delete",
post(handlers::site_setting_delete_submit),
)
.route(
"/cms-admin/site-settings/{scope}/translate",
post(handlers::site_setting_translate_submit),
)
.route("/cms-admin/templates", get(template_editor::list))
.route(
"/cms-admin/templates/edit",
get(template_editor::edit_form).post(template_editor::save),
)
.route("/cms-admin/templates/new", post(template_editor::create))
.route(
"/cms-admin/templates/validate",
post(template_editor::validate),
)
.route("/cms-admin/templates/delete", post(template_editor::delete))
.route("/cms-admin/help", get(help_center::index))
.route("/cms-admin/help/{slug}", get(help_center::guide))
.route("/cms-admin/site-theme", get(site_theme::index))
.route("/cms-admin/site-theme/download", get(site_theme::download))
.route(
"/cms-admin/site-theme/upload",
post(site_theme::upload).route_layer(axum::extract::DefaultBodyLimit::max(10 * 1024 * 1024)),
)
.route("/cms-admin/site-theme/preview", get(site_theme::preview_page))
.route("/cms-admin/site-theme/install", post(site_theme::install))
.route("/cms-admin/site-theme/restore", post(site_theme::restore))
.route(
"/cms-admin/page-types/{id}/template",
get(template_editor::assign_form).post(template_editor::assign_save),
)
.route("/cms-admin/analytics", get(handlers::analytics_dashboard))
.route(
"/cms-admin/reports/aging",
get(handlers::aging_pages_report),
)
.route(
"/cms-admin/reports/aging.csv",
get(handlers::aging_pages_csv),
)
.route(
"/cms-admin/reports/locked-pages",
get(handlers::locked_pages_report),
)
.route(
"/cms-admin/reports/locked-pages.csv",
get(handlers::locked_pages_csv),
)
.route(
"/cms-admin/reports/workflows",
get(handlers::workflows_report),
)
.route(
"/cms-admin/reports/workflows.csv",
get(handlers::workflows_report_csv),
)
.route(
"/cms-admin/reports/revisions",
get(handlers::revisions_report),
)
.route(
"/cms-admin/reports/revisions/prune",
post(handlers::revisions_report_prune),
)
.route(
"/cms-admin/reports/scheduled",
get(handlers::scheduled_report),
)
.route(
"/cms-admin/reports/scheduled.csv",
get(handlers::scheduled_report_csv),
)
.route(
"/cms-admin/reports/search",
get(handlers::search_promotions_report),
)
.route(
"/cms-admin/reports/search/{id}/edit",
get(handlers::search_promotion_edit_form).post(handlers::search_promotion_edit_submit),
)
.route("/cms-admin/workflows", get(handlers::workflows_list))
.route(
"/cms-admin/workflows/new",
get(handlers::workflow_new_form).post(handlers::workflow_new_submit),
)
.route(
"/cms-admin/workflows/{id}/edit",
get(handlers::workflow_edit_form).post(handlers::workflow_edit_submit),
)
.route(
"/cms-admin/workflows/{id}/delete",
post(handlers::workflow_delete_submit),
)
.route(
"/cms-admin/workflows/{id}/tasks/add",
post(handlers::workflow_task_add),
)
.route(
"/cms-admin/workflows/{id}/tasks/{task_id}/delete",
post(handlers::workflow_task_delete),
)
.route("/cms-admin/notifications", get(notifications::list))
.route("/cms-admin/notifications/new", post(notifications::create))
.route(
"/cms-admin/notifications/{id}/toggle",
post(notifications::toggle),
)
.route(
"/cms-admin/notifications/{id}/delete",
post(notifications::delete),
)
.route(
"/cms-admin/notifications/deliveries/{id}/retry",
post(notifications::retry_delivery),
)
.route("/cms-admin/sites", get(sites::list))
.route("/cms-admin/sites/new", post(sites::add))
.route("/cms-admin/sites/root", post(sites::set_root))
.route("/cms-admin/sites/toggle", post(sites::toggle))
.route("/cms-admin/sites/delete", post(sites::remove))
.route("/cms-admin/redirects", get(handlers::redirect_list))
.route(
"/cms-admin/redirects/new",
get(handlers::redirect_new_form).post(handlers::redirect_new_submit),
)
.route(
"/cms-admin/redirects/{id}/edit",
get(handlers::redirect_edit_form).post(handlers::redirect_edit_submit),
)
.route(
"/cms-admin/redirects/{id}/delete",
post(handlers::redirect_delete_submit),
)
.route(
"/cms-admin/redirects/{id}/enable",
post(handlers::redirect_enable_submit),
)
.route(
"/cms-admin/redirects/import",
get(handlers::redirect_import_form).post(handlers::redirect_import_submit),
)
.route(
"/cms-admin/redirects/export.csv",
get(handlers::redirect_export_csv),
)
.route("/cms-admin/users", get(handlers::users_list))
.route("/cms-admin/users/bulk", post(handlers::users_bulk_submit))
.route(
"/cms-admin/users/new",
get(handlers::users_new_form).post(handlers::users_create_submit),
)
.route(
"/cms-admin/users/{id}/edit",
get(handlers::users_edit_form).post(handlers::users_edit_submit),
)
.route(
"/cms-admin/users/{id}/deactivate",
post(handlers::users_deactivate_submit),
)
.route("/cms-admin/security-log", get(handlers::security_log_page))
.route("/cms-admin/roles", get(handlers::roles_list))
.route(
"/cms-admin/permissions",
get(handlers::permissions_overview),
)
.route(
"/cms-admin/roles/new",
get(handlers::roles_new_form).post(handlers::roles_create_submit),
)
.route(
"/cms-admin/roles/{id}/edit",
get(handlers::roles_edit_form).post(handlers::roles_edit_submit),
)
.route(
"/cms-admin/roles/{id}/delete",
post(handlers::roles_delete_submit),
)
.route("/cms-admin/navigation", get(handlers::navigation_list))
.route(
"/cms-admin/navigation/new",
post(handlers::navigation_create_submit),
)
.route(
"/cms-admin/navigation/{id}/delete",
post(handlers::navigation_delete_submit),
)
.route(
"/cms-admin/navigation/{id}/clone",
post(handlers::navigation_clone_submit),
)
.route(
"/cms-admin/navigation/{id}/save-tree",
post(handlers::navigation_save_tree_submit),
)
.route(
"/cms-admin/navigation/{id}/seed-from-pages",
post(handlers::navigation_seed_from_pages_submit),
)
.route(
"/cms-admin/navigation/{id}/edit",
get(handlers::navigation_edit_form),
)
.route(
"/cms-admin/navigation/{id}/translate",
post(handlers::navigation_translate_submit),
)
.route(
"/cms-admin/navigation/{id}/items",
post(handlers::navigation_item_create),
)
.route(
"/cms-admin/navigation/{menu_id}/items/{id}/delete",
post(handlers::navigation_item_delete),
)
.route("/cms-admin/history", get(handlers::history_page))
.route("/cms-admin/page-types", get(handlers::page_types_dashboard))
.route(
"/cms-admin/page-types/new",
get(handlers::page_type_new_form).post(handlers::page_type_create),
)
.route(
"/cms-admin/page-types/{id}/edit",
get(handlers::page_type_edit_form).post(handlers::page_type_update),
)
.route(
"/cms-admin/page-types/{id}/delete",
post(handlers::page_type_delete),
)
.route(
"/cms-admin/page-types/{id}/build",
get(handlers::page_type_build_form).post(handlers::page_type_build_submit),
)
.route(
"/cms-admin/page-types/{id}/build/publish",
post(handlers::page_type_publish_submit),
)
.route(
"/cms-admin/page-types/{id}/translate",
get(handlers::page_type_translate_form).post(handlers::page_type_translate_submit),
)
.route("/cms-admin/components", get(handlers::components_index))
.route(
"/cms-admin/components/new",
get(handlers::component_new_form).post(handlers::component_create),
)
.route(
"/cms-admin/components/{id}/edit",
get(handlers::component_edit_form).post(handlers::component_update),
)
.route(
"/cms-admin/components/{id}/delete",
post(handlers::component_delete),
)
.route("/cms-admin/settings", get(handlers::settings_page))
.route(
"/cms-admin/settings/branding",
post(handlers::settings_branding_submit),
)
.route(
"/cms-admin/settings/theme",
post(handlers::settings_theme_switch),
)
.route("/cms-admin/me", get(handlers::account_preferences))
.route(
"/cms-admin/__page-chooser",
get(handlers::page_chooser_json),
)
.route(
"/cms-admin/__snippet-chooser",
get(handlers::snippet_chooser_json),
)
.route(
"/cms-admin/__document-chooser",
get(handlers::document_chooser_json),
)
.route(
"/cms-admin/me/notifications",
post(handlers::account_notifications_submit),
)
.route(
"/cms-admin/me/profile",
post(handlers::account_profile_submit),
)
.route(
"/cms-admin/me/language",
post(handlers::account_language_submit),
)
.route(
"/cms-admin/me/show-templates",
post(handlers::account_show_templates_submit),
)
.route("/cms-admin/me/email", post(handlers::account_email_submit))
.route(
"/cms-admin/me/email/confirm",
get(handlers::account_email_confirm),
)
.route(
"/cms-admin/me/password",
post(handlers::account_password_submit),
)
.route(
"/cms-admin/me/mcp-keys",
post(handlers::account_mcp_key_create),
)
.route(
"/cms-admin/me/mcp-keys/{id}/revoke",
post(handlers::account_mcp_key_revoke),
)
.route(
"/cms-admin/users/{id}/mcp-keys",
post(handlers::users_mcp_key_create),
)
.route(
"/cms-admin/users/{id}/mcp-keys/{key_id}/revoke",
post(handlers::users_mcp_key_revoke),
)
.route(
"/__cms-avatar/{user_id}",
get(handlers::account_avatar_serve),
)
.route("/cms-admin/styleguide", get(handlers::styleguide))
.route("/cms-admin/dashboard", get(handlers::dashboard))
.route(
"/cms-admin/dismissibles/{key}",
post(handlers::dismissible_submit),
)
.route("/cms-admin/logout", post(handlers::cms_logout_submit))
.route(
"/cms-admin/x/{slug}",
get(handlers::admin_page_dispatch).post(handlers::admin_page_dispatch),
)
.route(
"/cms-admin/x/{slug}/{action}",
get(handlers::admin_page_dispatch).post(handlers::admin_page_dispatch),
)
.route_layer(axum::middleware::from_fn(route_perms::gate))
.route_layer(axum::middleware::from_fn(i18n::tenant_overrides_layer))
.route_layer(axum::middleware::from_fn(crate::seed::lazy_seed_layer))
.with_state(state)
}
async fn redirect_root() -> axum::response::Redirect {
axum::response::Redirect::permanent("/cms-admin/dashboard")
}
fn immutable_asset<B: axum::response::IntoResponse>(
content_type: &'static str,
body: B,
) -> axum::response::Response {
use axum::response::IntoResponse as _;
(
[
(
axum::http::header::CONTENT_TYPE,
axum::http::HeaderValue::from_static(content_type),
),
(
axum::http::header::CACHE_CONTROL,
axum::http::HeaderValue::from_static("public, max-age=31536000, immutable"),
),
],
body,
)
.into_response()
}
async fn serve_stream_editor_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/stream_editor.js"))
}
async fn serve_cms_preview_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/cms-preview.js"))
}
async fn serve_block_tree_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/block_tree.js"))
}
async fn serve_cms_ux_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/cms-ux.js"))
}
async fn serve_menu_builder_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/menu-builder.js"))
}
async fn serve_form_builder_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/form_builder.js"))
}
async fn serve_page_type_builder_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/page_type_builder.js"))
}
async fn serve_page_builder_rules_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/page_builder_rules.js"))
}
async fn serve_axe_core_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/vendor/axe-core.min.js"))
}
async fn serve_cms_axe_preview_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/cms-axe-preview.js"))
}
async fn serve_cms_preview_guard_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/cms-preview-guard.js"))
}
const ADMIN_FONT_FILES: &[(&str, &[u8])] = &[
(
"icons-00.woff2",
include_bytes!("static/vendor/fonts/icons-00.woff2"),
),
(
"text-00.woff2",
include_bytes!("static/vendor/fonts/text-00.woff2"),
),
(
"text-02.woff2",
include_bytes!("static/vendor/fonts/text-02.woff2"),
),
(
"text-03.woff2",
include_bytes!("static/vendor/fonts/text-03.woff2"),
),
(
"text-16.woff2",
include_bytes!("static/vendor/fonts/text-16.woff2"),
),
(
"text-17.woff2",
include_bytes!("static/vendor/fonts/text-17.woff2"),
),
(
"text-21.woff2",
include_bytes!("static/vendor/fonts/text-21.woff2"),
),
(
"text-22.woff2",
include_bytes!("static/vendor/fonts/text-22.woff2"),
),
];
async fn serve_admin_fonts_css() -> impl axum::response::IntoResponse {
immutable_asset("text/css; charset=utf-8", include_str!("static/vendor/fonts/fonts.css"))
}
async fn serve_admin_font_file(axum::extract::Path(file): axum::extract::Path<String>) -> Response {
match ADMIN_FONT_FILES.iter().find(|(name, _)| *name == file) {
Some((_, bytes)) => immutable_asset("font/woff2", *bytes)
.into_response(),
None => (axum::http::StatusCode::NOT_FOUND, "unknown font").into_response(),
}
}
const ADMIN_BRAND_FILES: &[(&str, &str, &[u8])] = &[
("logo-light.png", "image/png", include_bytes!("static/brand/logo-light.png")),
("logo-dark.png", "image/png", include_bytes!("static/brand/logo-dark.png")),
("icon-light.png", "image/png", include_bytes!("static/brand/icon-light.png")),
("icon-dark.png", "image/png", include_bytes!("static/brand/icon-dark.png")),
("favicon.ico", "image/x-icon", include_bytes!("static/brand/favicon.ico")),
("apple-touch-icon.png", "image/png", include_bytes!("static/brand/apple-touch-icon.png")),
];
async fn serve_admin_brand_file(axum::extract::Path(file): axum::extract::Path<String>) -> Response {
match ADMIN_BRAND_FILES.iter().find(|(name, _, _)| *name == file) {
Some((_, content_type, bytes)) => immutable_asset(content_type, *bytes).into_response(),
None => (axum::http::StatusCode::NOT_FOUND, "unknown brand file").into_response(),
}
}
async fn serve_tiptap_bundle_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/vendor/tiptap.bundle.js"))
}
async fn serve_template_editor_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/template-editor.js"))
}
async fn serve_codemirror_bundle_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/vendor/codemirror.bundle.js"))
}
async fn serve_richtext_editor_js() -> impl axum::response::IntoResponse {
immutable_asset("text/javascript; charset=utf-8", include_str!("static/richtext-editor.js"))
}
const BUNDLED_CMS_CSS: &str = include_str!("static/cms.css");
async fn serve_cms_css() -> Response {
let override_path = std::path::Path::new("static/cms_admin/cms.css");
if override_path.exists() {
match std::fs::read_to_string(override_path) {
Ok(source) => {
return (
[
(
axum::http::header::CONTENT_TYPE,
axum::http::HeaderValue::from_static("text/css; charset=utf-8"),
),
(
axum::http::header::CACHE_CONTROL,
axum::http::HeaderValue::from_static(
"public, max-age=31536000, immutable",
),
),
],
source,
)
.into_response();
}
Err(err) => {
tracing::warn!(
target: "rustango_cms::admin",
error = %err,
path = %override_path.display(),
"failed to read cms.css override; falling back to bundled stylesheet",
);
}
}
}
immutable_asset("text/css; charset=utf-8", BUNDLED_CMS_CSS)
.into_response()
}
fn cms_asset_version() -> String {
static BUNDLED: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
let bundled = *BUNDLED.get_or_init(|| {
let mut h: u64 = 0xcbf29ce4_84222325;
let mut feed_bytes = |bytes: &[u8]| {
for &b in bytes {
h ^= u64::from(b);
h = h.wrapping_mul(0x0000_0100_0000_01b3);
}
};
for (_, _, bytes) in ADMIN_BRAND_FILES {
feed_bytes(bytes);
}
let mut feed = |s: &str| feed_bytes(s.as_bytes());
feed(BUNDLED_CMS_CSS);
feed(include_str!("static/cms-ux.js"));
feed(include_str!("static/stream_editor.js"));
feed(include_str!("static/richtext-editor.js"));
feed(include_str!("static/block_tree.js"));
feed(include_str!("static/page_type_builder.js"));
feed(include_str!("static/form_builder.js"));
feed(include_str!("static/menu-builder.js"));
feed(include_str!("static/cms-axe-preview.js"));
feed(include_str!("static/cms-preview-guard.js"));
feed(include_str!("static/cms-preview.js"));
feed(include_str!("static/page_builder_rules.js"));
h
});
if let Ok(meta) = std::fs::metadata("static/cms_admin/cms.css") {
let mtime = meta
.modified()
.ok()
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map_or(0, |d| d.as_secs());
return format!("{bundled:x}.{mtime:x}.{:x}", meta.len());
}
format!("{bundled:x}")
}
struct CmsAssetVersionFn;
impl tera::Function for CmsAssetVersionFn {
fn call(
&self,
_args: &std::collections::HashMap<String, tera::Value>,
) -> tera::Result<tera::Value> {
Ok(tera::Value::String(cms_asset_version()))
}
}
struct JsonScriptFilter;
impl tera::Filter for JsonScriptFilter {
fn filter(
&self,
value: &tera::Value,
_args: &std::collections::HashMap<String, tera::Value>,
) -> tera::Result<tera::Value> {
Ok(tera::Value::String(json_script(value)))
}
fn is_safe(&self) -> bool {
true
}
}
fn json_script(value: &tera::Value) -> String {
serde_json::to_string(value)
.unwrap_or_else(|_| "null".to_owned())
.replace('<', "\\u003c")
.replace('>', "\\u003e")
.replace('&', "\\u0026")
.replace('\'', "\\u0027")
}
pub fn register_templates(tera: &mut Tera) -> Result<(), tera::Error> {
crate::urls::register_tera_helpers(tera);
tera.register_function("cms_asset_version", CmsAssetVersionFn);
tera.register_filter("json_script", JsonScriptFilter);
rustango::i18n::tera_tags::register(tera, i18n::cached_translator().clone());
i18n::register_tera_bindings(tera);
tera.register_function(
"get_env",
|_args: &std::collections::HashMap<String, tera::Value>| -> tera::Result<tera::Value> {
Err(tera::Error::msg(
"get_env is disabled in CMS templates for security reasons",
))
},
);
tera.add_raw_templates(vec![
(
"rcms_admin/_base.html",
include_str!("templates/_base.html"),
),
(
"rcms_admin/_auth_layout.html",
include_str!("templates/_auth_layout.html"),
),
(
"rcms_admin/_brand_icons.html",
include_str!("templates/_brand_icons.html"),
),
(
"rcms_admin/_list_base.html",
include_str!("templates/_list_base.html"),
),
(
"rcms_admin/_stream_widget.html",
"{% import \"rcms_admin/_widget.html\" as widget %}{{ widget::render(w=w) }}",
),
(
"rcms_admin/member_login.html",
include_str!("templates/member_login.html"),
),
(
"rcms_admin/member_signup.html",
include_str!("templates/member_signup.html"),
),
(
"rcms_admin/_mcp_keys_card.html",
include_str!("templates/_mcp_keys_card.html"),
),
(
"rcms_admin/_pagination.html",
include_str!("templates/_pagination.html"),
),
(
"rcms_admin/_preview_pane.html",
include_str!("templates/_preview_pane.html"),
),
(
"rcms_admin/notifications.html",
include_str!("templates/notifications.html"),
),
("rcms_admin/sites.html", include_str!("templates/sites.html")),
(
"rcms_admin/_widget.html",
include_str!("templates/_widget.html"),
),
(
"rcms_admin/_inline_card.html",
include_str!("templates/_inline_card.html"),
),
(
"rcms_admin/_inline_panel.html",
include_str!("templates/_inline_panel.html"),
),
(
"rcms_admin/_widget_group.html",
include_str!("templates/_widget_group.html"),
),
(
"rcms_admin/_permissions_tab.html",
include_str!("templates/_permissions_tab.html"),
),
(
"rcms_admin/page_list.html",
include_str!("templates/page_list.html"),
),
(
"rcms_admin/page_form.html",
include_str!("templates/page_form.html"),
),
(
"rcms_admin/page_type_picker.html",
include_str!("templates/page_type_picker.html"),
),
(
"rcms_admin/library_list.html",
include_str!("templates/library_list.html"),
),
(
"rcms_admin/snippet_form.html",
include_str!("templates/snippet_form.html"),
),
(
"rcms_admin/form_builder.html",
include_str!("templates/form_builder.html"),
),
(
"rcms_admin/form_submissions.html",
include_str!("templates/form_submissions.html"),
),
(
"rcms_admin/forms_list.html",
include_str!("templates/forms_list.html"),
),
(
"rcms_admin/form_translate.html",
include_str!("templates/form_translate.html"),
),
(
"rcms_admin/page_type_translate.html",
include_str!("templates/page_type_translate.html"),
),
(
"rcms_admin/media_list.html",
include_str!("templates/media_list.html"),
),
(
"rcms_admin/media_upload.html",
include_str!("templates/media_upload.html"),
),
(
"rcms_admin/model_admin_list.html",
include_str!("templates/model_admin_list.html"),
),
(
"rcms_admin/cms_admin_list.html",
include_str!("templates/cms_admin_list.html"),
),
(
"rcms_admin/cms_admin_form.html",
include_str!("templates/cms_admin_form.html"),
),
(
"rcms_admin/report.html",
include_str!("templates/report.html"),
),
(
"rcms_admin/locale_list.html",
include_str!("templates/locale_list.html"),
),
(
"rcms_admin/locale_form.html",
include_str!("templates/locale_form.html"),
),
(
"rcms_admin/sso_provider_list.html",
include_str!("templates/sso_provider_list.html"),
),
(
"rcms_admin/sso_provider_form.html",
include_str!("templates/sso_provider_form.html"),
),
(
"rcms_admin/workflow_list.html",
include_str!("templates/workflow_list.html"),
),
(
"rcms_admin/workflow_form.html",
include_str!("templates/workflow_form.html"),
),
(
"rcms_admin/history_diff.html",
include_str!("templates/history_diff.html"),
),
(
"rcms_admin/admin_search.html",
include_str!("templates/admin_search.html"),
),
(
"rcms_admin/analytics.html",
include_str!("templates/analytics.html"),
),
(
"rcms_admin/aging_pages.html",
include_str!("templates/aging_pages.html"),
),
(
"rcms_admin/locked_pages.html",
include_str!("templates/locked_pages.html"),
),
(
"rcms_admin/workflow_report.html",
include_str!("templates/workflow_report.html"),
),
(
"rcms_admin/revisions_report.html",
include_str!("templates/revisions_report.html"),
),
(
"rcms_admin/scheduled_report.html",
include_str!("templates/scheduled_report.html"),
),
(
"rcms_admin/search_promotions_report.html",
include_str!("templates/search_promotions_report.html"),
),
(
"rcms_admin/search_promotion_edit.html",
include_str!("templates/search_promotion_edit.html"),
),
(
"rcms_admin/styleguide.html",
include_str!("templates/styleguide.html"),
),
(
"rcms_admin/dashboard.html",
include_str!("templates/dashboard.html"),
),
(
"rcms_admin/redirect_import.html",
include_str!("templates/redirect_import.html"),
),
(
"rcms_admin/snippet_import.html",
include_str!("templates/snippet_import.html"),
),
(
"rcms_admin/site_settings_list.html",
include_str!("templates/site_settings_list.html"),
),
(
"rcms_admin/template_list.html",
include_str!("templates/template_list.html"),
),
(
"rcms_admin/help_index.html",
include_str!("templates/help_index.html"),
),
(
"rcms_admin/help_page.html",
include_str!("templates/help_page.html"),
),
(
"rcms_admin/site_theme.html",
include_str!("templates/site_theme.html"),
),
(
"rcms_admin/site_theme_preview.html",
include_str!("templates/site_theme_preview.html"),
),
(
"rcms_admin/template_form.html",
include_str!("templates/template_form.html"),
),
(
"rcms_admin/page_type_template_form.html",
include_str!("templates/page_type_template_form.html"),
),
(
"rcms_admin/site_setting_form.html",
include_str!("templates/site_setting_form.html"),
),
(
"rcms/view_password.html",
include_str!("templates/view_password.html"),
),
(
"rcms_admin/redirect_list.html",
include_str!("templates/redirect_list.html"),
),
(
"rcms_admin/redirect_form.html",
include_str!("templates/redirect_form.html"),
),
(
"rcms_admin/settings.html",
include_str!("templates/settings.html"),
),
(
"rcms_admin/history.html",
include_str!("templates/history.html"),
),
(
"rcms_admin/navigation_list.html",
include_str!("templates/navigation_list.html"),
),
(
"rcms_admin/navigation_edit.html",
include_str!("templates/navigation_edit.html"),
),
(
"rcms_admin/page_types.html",
include_str!("templates/page_types.html"),
),
(
"rcms_admin/page_type_builder.html",
include_str!("templates/page_type_builder.html"),
),
(
"rcms_admin/components_list.html",
include_str!("templates/components_list.html"),
),
(
"rcms_admin/schema_page.html",
include_str!("templates/schema_page.html"),
),
(
"rcms_admin/page_type_form.html",
include_str!("templates/page_type_form.html"),
),
(
"rcms_admin/component_builder.html",
include_str!("templates/component_builder.html"),
),
(
"rcms_admin/users_list.html",
include_str!("templates/users_list.html"),
),
(
"rcms_admin/security_log.html",
include_str!("templates/security_log.html"),
),
(
"rcms_admin/user_form.html",
include_str!("templates/user_form.html"),
),
(
"rcms_admin/roles_list.html",
include_str!("templates/roles_list.html"),
),
(
"rcms_admin/permissions_overview.html",
include_str!("templates/permissions_overview.html"),
),
(
"rcms_admin/role_form.html",
include_str!("templates/role_form.html"),
),
(
"rcms_admin/media_unused.html",
include_str!("templates/media_unused.html"),
),
(
"rcms_admin/media_edit.html",
include_str!("templates/media_edit.html"),
),
(
"rcms_admin/collection_permissions.html",
include_str!("templates/collection_permissions.html"),
),
(
"rcms_admin/collections_list.html",
include_str!("templates/collections_list.html"),
),
(
"rcms_admin/taxonomies_list.html",
include_str!("templates/taxonomies_list.html"),
),
(
"rcms_admin/category_tree.html",
include_str!("templates/category_tree.html"),
),
(
"rcms_admin/category_form.html",
include_str!("templates/category_form.html"),
),
("login.html", include_str!("templates/login.html")),
(
"rcms_admin/password_reset_request.html",
include_str!("templates/password_reset_request.html"),
),
(
"rcms_admin/password_reset_sent.html",
include_str!("templates/password_reset_sent.html"),
),
(
"rcms_admin/password_reset_confirm.html",
include_str!("templates/password_reset_confirm.html"),
),
(
"rcms_admin/password_reset_done.html",
include_str!("templates/password_reset_done.html"),
),
(
"rcms_admin/no_access.html",
include_str!("templates/no_access.html"),
),
(
"rcms_admin/account_preferences.html",
include_str!("templates/account_preferences.html"),
),
(
"rcms_admin/_breadcrumbs.html",
include_str!("templates/_breadcrumbs.html"),
),
(
"blocks/heading.html",
include_str!("templates/blocks/heading.html"),
),
(
"blocks/paragraph.html",
include_str!("templates/blocks/paragraph.html"),
),
(
"blocks/image.html",
include_str!("templates/blocks/image.html"),
),
(
"blocks/quote.html",
include_str!("templates/blocks/quote.html"),
),
(
"blocks/embed.html",
include_str!("templates/blocks/embed.html"),
),
(
"blocks/code.html",
include_str!("templates/blocks/code.html"),
),
(
"blocks/text.html",
include_str!("templates/blocks/text.html"),
),
(
"blocks/boolean.html",
include_str!("templates/blocks/boolean.html"),
),
(
"blocks/date.html",
include_str!("templates/blocks/date.html"),
),
(
"blocks/datetime.html",
include_str!("templates/blocks/datetime.html"),
),
(
"blocks/email.html",
include_str!("templates/blocks/email.html"),
),
("blocks/url.html", include_str!("templates/blocks/url.html")),
(
"blocks/integer.html",
include_str!("templates/blocks/integer.html"),
),
(
"blocks/choice.html",
include_str!("templates/blocks/choice.html"),
),
(
"blocks/table.html",
include_str!("templates/blocks/table.html"),
),
(
"blocks/float.html",
include_str!("templates/blocks/float.html"),
),
(
"blocks/decimal.html",
include_str!("templates/blocks/decimal.html"),
),
(
"blocks/regex.html",
include_str!("templates/blocks/regex.html"),
),
(
"blocks/rich_text.html",
include_str!("templates/blocks/rich_text.html"),
),
(
"blocks/typed_table_row.html",
include_str!("templates/blocks/typed_table_row.html"),
),
(
"blocks/typed_table.html",
include_str!("templates/blocks/typed_table.html"),
),
(
"blocks/time.html",
include_str!("templates/blocks/time.html"),
),
(
"blocks/multiple_choice.html",
include_str!("templates/blocks/multiple_choice.html"),
),
(
"blocks/static.html",
include_str!("templates/blocks/static.html"),
),
(
"blocks/raw_html.html",
include_str!("templates/blocks/raw_html.html"),
),
(
"blocks/page_chooser.html",
include_str!("templates/blocks/page_chooser.html"),
),
(
"blocks/snippet_chooser.html",
include_str!("templates/blocks/snippet_chooser.html"),
),
(
"blocks/document_chooser.html",
include_str!("templates/blocks/document_chooser.html"),
),
("blocks/cards.html", include_str!("templates/blocks/cards.html")),
("blocks/slider.html", include_str!("templates/blocks/slider.html")),
("blocks/gallery.html", include_str!("templates/blocks/gallery.html")),
])?;
if !tera.get_template_names().any(|n| n == "error_page.html") {
tera.add_raw_template("error_page.html", include_str!("templates/error_page.html"))?;
}
let override_root = std::path::PathBuf::from("templates/cms_admin");
if override_root.is_dir() {
let count = load_template_overrides(&override_root, "", tera)?;
if count > 0 {
tracing::info!(
target: "rustango_cms::admin",
count,
path = %override_root.display(),
"loaded admin template overrides",
);
}
}
Ok(())
}
fn load_template_overrides(
dir: &std::path::Path,
prefix: &str,
tera: &mut Tera,
) -> Result<usize, tera::Error> {
let mut count = 0;
let entries = std::fs::read_dir(dir)
.map_err(|e| tera::Error::msg(format!("read_dir {}: {e}", dir.display())))?;
for entry in entries {
let entry = entry
.map_err(|e| tera::Error::msg(format!("read_dir entry in {}: {e}", dir.display())))?;
let path = entry.path();
let name = match entry.file_name().into_string() {
Ok(n) => n,
Err(_) => continue,
};
if path.is_dir() {
let nested_prefix = if prefix.is_empty() {
name.clone()
} else {
format!("{prefix}/{name}")
};
count += load_template_overrides(&path, &nested_prefix, tera)?;
} else if path.extension().and_then(|e| e.to_str()) == Some("html") {
let template_name = derive_override_template_name(prefix, &name);
let source = std::fs::read_to_string(&path)
.map_err(|e| tera::Error::msg(format!("read {}: {e}", path.display())))?;
tera.add_raw_template(&template_name, &source)?;
tracing::info!(
target: "rustango_cms::admin",
path = %path.display(),
template = %template_name,
"registered admin template override",
);
count += 1;
}
}
Ok(count)
}
fn derive_override_template_name(prefix: &str, file_name: &str) -> String {
if prefix.is_empty() {
match file_name {
"_auth_layout.html" => "rcms_admin/_auth_layout.html".to_owned(),
other => other.to_owned(),
}
} else {
format!("{prefix}/{file_name}")
}
}
#[derive(Debug, thiserror::Error)]
pub(crate) enum AdminError {
#[error(transparent)]
Tree(#[from] TreeError),
#[error(transparent)]
Exec(#[from] rustango::sql::ExecError),
#[error(transparent)]
Sqlx(#[from] rustango::sql::sqlx::Error),
#[error(transparent)]
Tera(#[from] tera::Error),
#[error("page {0} not found")]
NotFound(i64),
#[error("upload failed: {0}")]
Upload(String),
#[error("{0}")]
Validation(String),
}
impl IntoResponse for AdminError {
fn into_response(self) -> Response {
let status = match &self {
AdminError::NotFound(_) => StatusCode::NOT_FOUND,
AdminError::Tree(TreeError::DisallowedChildType { .. })
| AdminError::Tree(TreeError::DisallowedParentType { .. })
| AdminError::Tree(TreeError::CycleAttempt) => StatusCode::BAD_REQUEST,
AdminError::Upload(_) => StatusCode::BAD_REQUEST,
AdminError::Validation(_) => StatusCode::BAD_REQUEST,
_ => StatusCode::INTERNAL_SERVER_ERROR,
};
let mut chain = self.to_string();
let mut src: Option<&dyn std::error::Error> = std::error::Error::source(&self);
while let Some(s) = src {
chain.push_str("\n caused by: ");
chain.push_str(&s.to_string());
src = s.source();
}
if status != StatusCode::INTERNAL_SERVER_ERROR {
return (status, chain).into_response();
}
let reference = crate::mcp::mint_uuid4();
tracing::error!(target: "rustango_cms::admin", error_ref = %reference, "{chain}");
(status, format!("Internal server error (ref {reference})")).into_response()
}
}
#[derive(Debug, Deserialize)]
pub struct PageForm {
pub title: String,
pub slug: String,
pub page_type_id: i64,
pub status: String,
#[serde(rename = "_action", default)]
pub action: String,
#[serde(default)]
pub seo_title: String,
#[serde(default)]
pub seo_description: String,
#[serde(default)]
pub robots_index: Option<String>,
#[serde(default)]
pub sitemap_priority: Option<f32>,
#[serde(default)]
pub show_in_menus: Option<String>,
#[serde(default)]
pub parent_id: Option<i64>,
#[serde(default, deserialize_with = "deserialize_present_optional_i64")]
pub theme_id: Option<Option<i64>>,
#[serde(default)]
pub go_live_at: Option<String>,
#[serde(default)]
pub expire_at: Option<String>,
#[serde(default)]
pub preview_path: String,
#[serde(default)]
pub template_override: String,
#[serde(default)]
pub og_title: String,
#[serde(default)]
pub og_description: String,
#[serde(default, deserialize_with = "deserialize_optional_i64")]
pub og_image_media_id: Option<i64>,
#[serde(default)]
pub twitter_card: Option<String>,
#[serde(default)]
pub tags: Option<String>,
#[serde(default)]
pub categories: Option<String>,
}
pub(crate) fn deserialize_optional_i64<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::Deserialize as _;
let s = String::deserialize(deserializer)?;
if s.is_empty() || s == "0" {
return Ok(None);
}
s.parse::<i64>().map(Some).map_err(serde::de::Error::custom)
}
fn deserialize_present_optional_i64<'de, D>(deserializer: D) -> Result<Option<Option<i64>>, D::Error>
where
D: serde::Deserializer<'de>,
{
deserialize_optional_i64(deserializer).map(Some)
}
impl PageForm {
fn parsed_status(&self) -> PageStatus {
PageStatus::parse_editable(&self.status).unwrap_or(PageStatus::Draft)
}
fn parsed_robots_index(&self) -> bool {
self.robots_index.is_some()
}
fn parsed_sitemap_priority(&self) -> f32 {
self.sitemap_priority.unwrap_or(0.5)
}
fn parsed_show_in_menus(&self) -> bool {
self.show_in_menus.is_some()
}
fn parsed_go_live_at(&self) -> Option<chrono::DateTime<chrono::Utc>> {
parse_datetime_local(self.go_live_at.as_deref())
}
fn parsed_expire_at(&self) -> Option<chrono::DateTime<chrono::Utc>> {
parse_datetime_local(self.expire_at.as_deref())
}
fn go_live_at_in_minutes(&self) -> bool {
datetime_input_in_minutes(self.go_live_at.as_deref())
}
fn expire_at_in_minutes(&self) -> bool {
datetime_input_in_minutes(self.expire_at.as_deref())
}
}
fn datetime_input_in_minutes(raw: Option<&str>) -> bool {
let Some(raw) = raw.map(str::trim) else {
return false;
};
let raw = raw.strip_suffix('Z').unwrap_or(raw);
chrono::NaiveDateTime::parse_from_str(raw, "%Y-%m-%dT%H:%M").is_ok()
}
fn parse_datetime_local(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
let raw = raw?.trim();
if raw.is_empty() {
return None;
}
if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(raw) {
return Some(dt.with_timezone(&chrono::Utc));
}
if let Some(utc) = raw.strip_suffix('Z') {
return parse_datetime_local(Some(utc));
}
chrono::NaiveDateTime::parse_from_str(raw, "%Y-%m-%dT%H:%M")
.or_else(|_| chrono::NaiveDateTime::parse_from_str(raw, "%Y-%m-%dT%H:%M:%S"))
.ok()
.map(|naive| chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(naive, chrono::Utc))
}
#[cfg(test)]
mod datetime_input_tests {
use super::parse_datetime_local;
#[test]
fn utc_offset_and_bare_values_parse_to_the_same_instant() {
let want = chrono::DateTime::parse_from_rfc3339("2026-12-01T12:00:00Z")
.unwrap()
.with_timezone(&chrono::Utc);
for raw in ["2026-12-01T12:00Z", "2026-12-01T12:00:00Z", "2026-12-01T09:00:00-03:00", "2026-12-01T12:00", " 2026-12-01T12:00:00 "] {
assert_eq!(parse_datetime_local(Some(raw)), Some(want), "{raw}");
}
assert_eq!(parse_datetime_local(Some("")), None);
assert_eq!(parse_datetime_local(Some("tomorrow")), None);
}
#[test]
fn minute_precision_is_read_from_the_posted_text() {
use super::datetime_input_in_minutes;
for raw in ["2026-12-01T12:00", "2026-12-01T12:00Z", " 2026-12-01T12:00 "] {
assert!(datetime_input_in_minutes(Some(raw)), "{raw}");
}
for raw in ["2026-12-01T12:00:00Z", "2026-12-01T12:00:00", "2026-12-01T09:00:00-03:00", ""] {
assert!(!datetime_input_in_minutes(Some(raw)), "{raw}");
}
assert!(!datetime_input_in_minutes(None));
}
}
#[cfg(test)]
mod admin_error_tests {
use super::AdminError;
use axum::response::IntoResponse as _;
async fn body(e: AdminError) -> (u16, String) {
let resp = e.into_response();
let status = resp.status().as_u16();
let bytes = axum::body::to_bytes(resp.into_body(), 1 << 16).await.expect("body");
(status, String::from_utf8(bytes.to_vec()).expect("utf8"))
}
#[tokio::test]
async fn server_errors_hide_their_cause_and_client_errors_do_not() {
let tera_err = tera::Tera::one_off("{{ secret_column | nope }}", &tera::Context::new(), false)
.expect_err("bad template");
let (status, text) = body(AdminError::Tera(tera_err)).await;
assert_eq!(status, 500);
assert!(text.starts_with("Internal server error (ref "), "{text}");
assert!(!text.contains("secret_column") && !text.contains("nope"), "{text}");
let (status, text) = body(AdminError::Validation("slug is taken".into())).await;
assert_eq!(status, 400);
assert!(text.contains("slug is taken"));
}
}
#[cfg(test)]
mod template_shape_tests {
#[test]
fn json_script_cannot_close_the_script_element() {
let hostile = serde_json::json!([{
"name": "</script><script>alert('x')</script> & <!--",
}]);
let mut tera = tera::Tera::default();
super::register_templates(&mut tera).expect("register");
tera.add_raw_template("t", "<script>const X = {{ v | json_script }};</script>")
.expect("template");
let mut ctx = tera::Context::new();
ctx.insert("v", &hostile);
let out = tera.render("t", &ctx).expect("render");
let body = out
.strip_prefix("<script>const X = ")
.and_then(|r| r.strip_suffix(";</script>"))
.expect("one script element");
assert!(!body.contains('<') && !body.contains('>') && !body.contains('\''), "{body}");
let back: serde_json::Value = serde_json::from_str(body).expect("still JSON");
assert_eq!(back, hostile);
}
#[test]
fn no_admin_template_inlines_raw_json() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/admin/templates");
let offenders: Vec<String> = std::fs::read_dir(&dir)
.expect("read templates dir")
.filter_map(|e| {
let path = e.expect("dir entry").path();
let src = std::fs::read_to_string(&path).ok()?;
src.contains("json_encode | safe")
.then(|| path.file_name().unwrap().to_string_lossy().to_string())
})
.collect();
assert!(offenders.is_empty(), "use `| json_script` instead: {offenders:?}");
}
#[test]
fn page_descriptions_come_from_the_shared_intro_card() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/admin/templates");
let mut offenders = Vec::new();
let mut checked = 0;
for entry in std::fs::read_dir(&dir).expect("read templates dir") {
let path = entry.expect("dir entry").path();
if path.extension().and_then(|e| e.to_str()) != Some("html") {
continue;
}
let src = std::fs::read_to_string(&path).expect("read template");
let name = path.file_name().unwrap().to_string_lossy().to_string();
if src.contains("rcms_admin/_list_base.html") {
checked += 1;
continue;
}
let Some(rest) = src.split_once("{% block content %}") else {
continue;
};
checked += 1;
let head = rest.1.trim_start();
if head.starts_with("<p class=\"rcms-hint") {
offenders.push(format!(
"{name}: bare <p class=\"rcms-hint\"> opens the content \
column — extend rcms_admin/_list_base.html and put the \
prose in {{% block description %}}"
));
} else if rest
.1
.contains("<div class=\"rcms-card\">\n <p class=\"rcms-hint")
{
offenders.push(format!(
"{name}: hand-rolled intro card — extend \
rcms_admin/_list_base.html instead"
));
}
}
assert!(
checked > 40,
"expected to scan most admin templates, scanned {checked} — \
the `{{% block content %}}` probe is broken"
);
assert!(
offenders.is_empty(),
"{} page(s) don't use the shared intro card:\n{}",
offenders.len(),
offenders.join("\n")
);
}
#[test]
fn get_env_is_disabled_in_the_render_engine() {
let secret = std::env::var("CARGO_PKG_NAME").expect("cargo sets CARGO_PKG_NAME");
let mut tera = tera::Tera::default();
super::register_templates(&mut tera).expect("register_templates");
tera.add_raw_template("ssti.html", r#"{{ get_env(name="CARGO_PKG_NAME") }}"#)
.expect("add template");
match tera.render("ssti.html", &tera::Context::new()) {
Err(_) => {}
Ok(out) => assert!(
!out.contains(&secret),
"get_env leaked the process environment into a template: {out}"
),
}
}
}